#include <stdio.h>
#include <string.h>
#include <rpc/rpc.h>
#include <sched.h>
#include <unistd.h>

#include "strpar.h"
  
#define MAX_LETTERS 128
#define MAX_REQUESTS 128
#define THREAD_STACK_SIZE 16384
  
#define get_stack(rq_item) ((void *)(&(rq_item).stack[THREAD_STACK_SIZE - 1]))

typedef enum {
	RS_FREE = 0,
	RS_COMPUTING,
	RS_FINISHED
} REQUEST_STATE;

typedef struct {
  char stack[THREAD_STACK_SIZE];
	REQUEST_STATE state;
	char *word;
	STR_PARAM output;
} REQUEST_ITEM;

static REQUEST_ITEM request_table[MAX_REQUESTS];

/* vlakno pro vypocet vysledku */
int thread_func(void *request_index)
{
  int i;
  int index = (int) request_index;
  char *letters = (char *) malloc(MAX_LETTERS);
  char *word = request_table[index].word;
  
  /* vypocet */
  
	REQUEST_ITEM *request_item = &request_table[index];
	STR_PARAM *result = &request_item->output;

  for (i = 0; i < MAX_LETTERS; i++)
  {
    letters[i] = '\0';
  }

 result->len = strlen(word);
 result->vowels = 0;
 result->consonants = 0;
  
  for (i = 0; i < result->len; i++)
  {
    if (strchr(letters, word[i]) == NULL)
    {
      letters[strlen(letters)] = word[i];
    }

    switch (word[i]) {
      case 'a':
      case 'e':
      case 'i':
      case 'o':
      case 'u':
      case 'y':
      case 'A':
      case 'E':
      case 'I':
      case 'O':
      case 'U':
      case 'Y':
        result->vowels++;
        break;
        
      default:
        result->consonants++;
    }
  }
  
  result->lcount = strlen(letters);
  free((void *) letters);

  sleep(1);

	request_item->state = RS_FINISHED;
	printf("%3i: Pozadavek ceka na vyzvednuti vysledku.\n", index);
  
  
}

/* vzdalena procedura pro spusteni vypocetniho vlakna */
REQUEST *calc_str_param_1_svc(char **request, struct svc_req *b)
{
	// static STR_PARAM result;
	static int first_run = 1;
  static REQUEST res;
  char *word = *request;
  int i, index;

	/* Pri prvnim behu vymazat tabulku pozadavku. */
	if (first_run)
  {
		first_run = 0;
		for (i = 0; i < MAX_REQUESTS; i++)
    {
			request_table[i].state = RS_FREE;
    }
    
		printf("Inicializace serveru prave probehla.\n");
	}

	/* Najit volnou pozici pro pozadavek. */
	index = -1;
	for (i = 0; i < MAX_REQUESTS; i++)
  {
		if (request_table[i].state == RS_FREE)
    {
			index = i;
			break;
		}
  }

	if (index >= 0) {
    printf("zahajen pozadavek, slovo: %s\n", word);
  
    request_table[index].word = (char *) malloc(strlen(word) + 1);
    strcpy(request_table[index].word, word);
    request_table[index].state = RS_COMPUTING;
    
    __clone(thread_func, get_stack(request_table[index]), CLONE_VM, (void *)index);
    

  } else {
    printf("%3i: !! Pozadavek nelze zpracovat, je plna fronta.\n", index);
  }
  
  
	res.handle = index;
	return &res;
  
}

/* vzdalena procedura pro vraceni vysledku */
STR_PARAM *get_str_param_1_svc(REQUEST *request, struct svc_req *b)
{
  static STR_PARAM result;
  
	/* Pockame, kdyz neni dopocitano. */
	if (request_table[request->handle].state == RS_COMPUTING) {
		printf("%3i: Pozadovan vysledek, ceka se na dopocitani.\n", request->handle);
		while (request_table[request->handle].state == RS_COMPUTING)
			;
	}

	/* Vyzvedneme vysledek. */
	if (request_table[request->handle].state == RS_FINISHED) {
		memcpy(&result, &request_table[request->handle].output, sizeof(STR_PARAM));
    free((void *) request_table[request->handle].word);
		request_table[request->handle].state = RS_FREE;
		result.state = 1;
		printf("%3i: Vyzvednut vysledek.\n", request->handle);
	} else {
		result.state = 0;
		printf("%3i: !! Pozadovan vysledek neexistujiciho pozadavku.\n", request->handle);
	}
  
	return &result;
}