/*
  1621100004
  Jozias Martini Dequi
*/

#include "FreeRTOS_AVR.h"
#include "basic_io_avr.h"

#define PENSANDO 0
#define FAMINTO 1
#define COMENDO 2

uint8_t filosofoEstado[5] = {0, 0, 0, 0, 0}; //Vetor de estados
uint8_t filosofoPosicao[5] = {0, 1, 2, 3, 4}; //Vetor de filósofo
uint8_t rodizioControle[5]= {0, 0, 0, 0, 0}; //Controle das vezes que comeu
uint8_t mutexValor = 1; //Mutex

const TickType_t tresSegundos = 3000 / portTICK_PERIOD_MS; //Três segundos de delay/processar
QueueHandle_t filosofoFila[5], mutexFila, garfoFila; //Declaração das filas

void filosofoTarefa(void *pvParameters);
void garfoTarefa(void *pvParameters);
void imprimeTarefa(uint8_t i);
void controleTarefa(uint8_t i);

void setup() {
  Serial.begin(9600);
  uint8_t i;
  mutexFila = xQueueCreate(1, sizeof(uint8_t)); //Cria e atribui a fila do mutex
  garfoFila = xQueueCreate(1, sizeof(uint8_t)); //Cria e atribui a fila do garfo

  for(i = 0; i < 5; i++){ //Cria a tribui a fila do filósofo
    filosofoFila[i] = xQueueCreate(1, sizeof(uint8_t));
    if(!filosofoFila[i]){
      while(1); //Rodando...
    }
  }

  if(!mutexFila || !garfoFila || !filosofoFila) { //Verifica se foram criados
    while(1){}; //Rodando...
  }

  // Tarefas de filósofos e tarefa do garfo
  xTaskCreate(filosofoTarefa, "Fil", 130, filosofoPosicao[0], 1, NULL);
  xTaskCreate(filosofoTarefa, "Fil", 130, filosofoPosicao[1], 1, NULL);
  xTaskCreate(filosofoTarefa, "Fil", 130, filosofoPosicao[2], 1, NULL);
  xTaskCreate(filosofoTarefa, "Fil", 130, filosofoPosicao[3], 1, NULL);
  xTaskCreate(filosofoTarefa, "Fil", 130, filosofoPosicao[4], 1, NULL);
  xTaskCreate(garfoTarefa, "Garfo", 100, NULL, 2, NULL);

  vPrintString("As tarefas foram criadas.\n"); //Sinaliza que deu tudo certo
  vTaskStartScheduler(); //Inicia o escalonador
  //while(1){}; //Rodando...
}

void filosofoTarefa (void *pvParameters) {
  const uint8_t id = (uint8_t *)pvParameters;

  vTaskDelay(tresSegundos); //Delay de tresSegundos. Não necessário, mas ordena melhor para a visualização.
  imprimeTarefa(id); //Impressão e delay.

  while(1) {

    xQueueSend(mutexFila, &mutexValor, portMAX_DELAY); //Envia o mutexValor para mutexFila, gerando uma fila de mutex com filósofos famintos, pra depois enviar para os garfos
    filosofoEstado[id] = FAMINTO; //Altera o estado de todos os filósofos que acordam de PENSANDO (0) para FAMINTO (1)
    imprimeTarefa(id); //Impressão e delay.

    controleTarefa(id); //Controle de rodízio (antes de enviar para a fila do garfo, ! ÁREA CRÍTICA !)

    xQueueSend(garfoFila, &id, portMAX_DELAY); //Envia o id para garfoFila, se ainda não comeu
    xQueueReceive(mutexFila, &mutexValor, portMAX_DELAY); //Retira o valor de mutexFila
    xQueueReceive(filosofoFila[id], &mutexValor, portMAX_DELAY); //Retira o valor de filosofoFila
    imprimeTarefa(id); //Impressão e delay.

    xQueueSend(mutexFila, &mutexValor, portMAX_DELAY);
    filosofoEstado[id] = PENSANDO; //Coloca novamente como pensando
    imprimeTarefa(id); //Impressão e delay.

    xQueueSend(garfoFila, &filosofoPosicao[((id + 5 - 1) % 5)], portMAX_DELAY); // ((id + 5 - 1) % 5) Testa se a esquerda do 'id' está comendo
    xQueueSend(garfoFila, &filosofoPosicao[((id + 1) % 5)], portMAX_DELAY); // ((id + 5) % 5) Testa se a direita do 'id' está comendo
    xQueueReceive(mutexFila, &mutexValor, portMAX_DELAY); //Assim, ele escolhe qual recolocar no mutexFila, caso contrário, os filósofos começam a repetir
  }
}

void garfoTarefa (void *pvParameters) {
  uint8_t id; //Id = posição do filósofo
  while(1){
    xQueueReceive(garfoFila, &id, portMAX_DELAY); //Retira da fila do garfo

    if (filosofoEstado[id] == FAMINTO) {
      if (filosofoEstado[((id + 5 - 1) % 5)] != COMENDO && filosofoEstado[((id + 1) % 5)] != COMENDO) { //Se esquerda e direita de 'id' não estão comendo
        filosofoEstado[id] = COMENDO; //Pega o garfo, sinaliza COMENDO (0) no vetor de estados
        rodizioControle[id] += 1; //Contador
        xQueueSend(filosofoFila[id], &mutexValor, portMAX_DELAY); //Envia para a fila dos filósofos pra sinalizar que está comendo
      }
    }
  }
}

void imprimeTarefa (uint8_t i) { //Imprime o estado e número do filósofo
  if (filosofoEstado[i] == PENSANDO) {
    vPrintStringAndNumber("Pensando", filosofoPosicao[i]);
  }
  else if (filosofoEstado[i] == FAMINTO) {
    vPrintStringAndNumber("Faminto", filosofoPosicao[i]);
  }
  else{
    vPrintStringAndNumber("Comendo", filosofoPosicao[i]);
  }
  vTaskDelay(tresSegundos); //Delay de tresSegundos.
}

void controleTarefa (uint8_t i) { //Faz o controle do rodízio
  uint8_t j = 0, k = 0;

  while(j < 5) {
    if(rodizioControle[j] == 0) { //Se não comeu, tudo bem
      vTaskDelay(tresSegundos);
      break;
    }
    if(j == 4) { //Se chegou no último (todos estão com 1 no controle), todos comeram, e ele zera o contador
      while(k < 5) {
        rodizioControle[k] =  0;
        k++;
      }
    }
    j++;
  }
}

void loop() {}