#include <stdio.h>
#include <string.h>

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"

#include "esp_log.h"
#include "esp_timer.h"
#include "freertos/timers.h"

#include "freertos/queue.h"
#include "driver/uart.h"

#include "HUB75.h"
#include "Numeros.h"
#include "FlechasV.h"
#include "FlechasA.h"
#include "FlechasR.h"
#include "Circulos.h"

#include "Pines.h"

const char * TAG = "PAS";

#define EDO_AMA 1
#define EDO_VER 2
#define EDO_ROJ 3

#define SIMULACION 

#ifdef SIMULACION
#define CONT_ROJ 12
#define CONT_VER  6
#define CONT_AMA  3
#else
static void Luces_task(void *arg);
#endif

static void HUB75_task(void *arg);

#define TAM 1536

uint32_t graphicsBuffer[TAM];

int16_t ds = 0;

uint8_t estado_actual, estado_inicial;

uint8_t estado_solapado, estado_solapado_ant = 0;

uint8_t tiempos_OK = 0;

uint8_t estado = EDO_VER;

uint8_t contador;

uint8_t at = 40;

//#define AAA   1     
//#define DDD   2   
//#define III   3
//
//#define ADD   4   
//#define AAD   5   
//#define IAA   6   
//#define IIA   7   
//#define IDD   8   
//#define IID   9
//
//#define IAD  10    
//
//#define SOL  20
//
//#define NADD 21 
//#define AAND 22  
//#define NIAA 23   
//#define IINA 24 
//#define NIDD 25 
//#define IIND 26 
//
//#define IAND 27 
//#define NIAD 28 

uint8_t MODO = IAD; 

void app_main(void)
{
    uint16_t i = 0, cu, cd, vv = 0, v5 = 0;

#ifdef SIMULACION
    uint8_t cont_edo;
#else
    TaskHandle_t Luces_Handle = NULL;
#endif 
    TaskHandle_t HUB75_Handle = NULL;

    xTaskCreatePinnedToCore(HUB75_task, "HUB75_task", 4096, NULL, 10, &HUB75_Handle, 1);
#ifndef SIMULACION
    xTaskCreatePinnedToCore(Luces_task, "Luces_task", 2048, NULL, 10, &Luces_Handle, 0);
#endif
    
    i = 50;

#ifdef SIMULACION
    cont_edo = 3;
    estado_actual = EDO_VER;
    tiempos_OK = 3;
#endif

    while (true)
    {
        i++;

        if(i >= 50)
        {
            i = 0;

#ifdef SIMULACION
            cont_edo--;
            if(cont_edo == 0)
            {
                switch(estado_actual)
                {
                    case EDO_VER: 
                        estado_actual = EDO_AMA;
                        cont_edo = CONT_AMA;
                        break;
                    case EDO_AMA: 
                        estado_actual = EDO_ROJ;
                        cont_edo = CONT_ROJ;
                        break;
                    case EDO_ROJ: 
                        estado_actual = EDO_VER;
                        cont_edo = CONT_VER;
                        break; 
                }
            }

            ds = 10 * cont_edo;
#endif
            if(ds > 0)
            {
                cd = 64 * 4 * ((ds/10) / 10);
                cu = 64 * 4 * ((ds/10) % 10);
            }
            
            switch (estado_actual)
            {
                case EDO_AMA:
                    estado = EDO_ROJ;
                    break;
                case EDO_ROJ:
                    estado = EDO_VER;
                    break;
                case EDO_VER:
                    estado = EDO_AMA;
                    break;
            }

            estado_solapado = gpio_get_level(ENT_SOL);
            if (estado_solapado_ant != estado_solapado)
            {
                estado_solapado_ant = estado_solapado;
            }


            estado = estado_actual;
            switch(estado)
            {
                case EDO_ROJ:
                    if((tiempos_OK == 3)&&(ds > 10))
                    {
                        for (uint16_t i = 0; i < 64; i++)
                        {
                            graphicsBuffer[i * 24 + 0 + 0] = NumGRR[cd + 0];
                            graphicsBuffer[i * 24 + 0 + 1] = NumGRR[cd + 1];
                            graphicsBuffer[i * 24 + 0 + 2] = NumGRR[cd + 2];
                            graphicsBuffer[i * 24 + 0 + 3] = NumGRR[cd + 3];
                            graphicsBuffer[i * 24 + 4 + 0] = NumGRR[cu + 0];
                            graphicsBuffer[i * 24 + 4 + 1] = NumGRR[cu + 1];
                            graphicsBuffer[i * 24 + 4 + 2] = NumGRR[cu + 2];
                            graphicsBuffer[i * 24 + 4 + 3] = NumGRR[cu + 3];
                            cu += 4;
                            cd += 4;
                        }
                    }
                    else
                    {
                        for (uint16_t i = 0; i < 64; i++)
                        {
                            for (uint16_t j = 0; j < 8; j++)
                            {
                                graphicsBuffer[i * 24 + j] = CR[i*8 + j];
                            }                            
                        }
                    }
                    break;
                case EDO_AMA:
                    if((tiempos_OK == 3)&&(ds > 10))
                    {
                        for (uint16_t i = 0; i < 64; i++)
                        {
                            graphicsBuffer[i * 24 + 0 + 0] = NumGRA[cd + 0];
                            graphicsBuffer[i * 24 + 0 + 1] = NumGRA[cd + 1];
                            graphicsBuffer[i * 24 + 0 + 2] = NumGRA[cd + 2];
                            graphicsBuffer[i * 24 + 0 + 3] = NumGRA[cd + 3];
                            graphicsBuffer[i * 24 + 4 + 0] = NumGRA[cu + 0];
                            graphicsBuffer[i * 24 + 4 + 1] = NumGRA[cu + 1];
                            graphicsBuffer[i * 24 + 4 + 2] = NumGRA[cu + 2];
                            graphicsBuffer[i * 24 + 4 + 3] = NumGRA[cu + 3];
                            cu += 4;
                            cd += 4;
                        }
                    }
                    else
                    {
                        for (uint16_t i = 0; i < 64; i++)
                        {
                            for (uint16_t j = 0; j < 8; j++)
                            {
                                graphicsBuffer[i * 24 + j] = CA[i*8 + j];
                            }                            
                        }
                    }
                    break;
                case EDO_VER:
                    if((tiempos_OK == 3)&&(ds > 10))
                    {
                        for (uint16_t i = 0; i < 64; i++)
                        {
                            graphicsBuffer[i * 24 + 0 + 0] = NumGRV[cd + 0];
                            graphicsBuffer[i * 24 + 0 + 1] = NumGRV[cd + 1];
                            graphicsBuffer[i * 24 + 0 + 2] = NumGRV[cd + 2];
                            graphicsBuffer[i * 24 + 0 + 3] = NumGRV[cd + 3];
                            graphicsBuffer[i * 24 + 0 + 4] = NumGRV[cu + 0];
                            graphicsBuffer[i * 24 + 0 + 5] = NumGRV[cu + 1];
                            graphicsBuffer[i * 24 + 0 + 6] = NumGRV[cu + 2];
                            graphicsBuffer[i * 24 + 0 + 7] = NumGRV[cu + 3];
                            cu += 4;
                            cd += 4;
                        }
                    }
                    else
                    {
                        for (uint16_t i = 0; i < 64; i++)
                        {
                            for (uint16_t j = 0; j < 8; j++)
                            {
                                graphicsBuffer[i * 24 + j] = CV[i*8 + j];
                            }                            
                        }
                    }
                    break;
            }
        }

        if ((estado == EDO_ROJ) && ((i % 3) == 0) && (MODO < SOL))  // No hay Solpados Configurados
        {
            for (uint16_t i = 0; i < 64; i++)
            {
                for (uint16_t j = 0; j < 16; j++)
                {
                    graphicsBuffer[i * 24 + 8 + j] = Flecha_Rojo[i * 16 + j];
                }
            }
        }


        if ((estado == EDO_ROJ) && ((i % 10) == 0) && (MODO > SOL)) // Hay un Solapado configurado
        {
            if(v5 == 0)
            {
                vv++;
                if (vv >= 5)
                {
                    v5 = 1;
                    vv = 5;
                }
            }
            else if(v5 < 2)
                v5++;
            else
            {
                v5 = 0;
                vv = 0;
            }
            
            if(estado_solapado == 1)  // No hay solape
            {
                for (uint16_t i = 0; i < 64; i++)
                {
                    for (uint16_t j = 0; j < 16; j++)
                    {
                        graphicsBuffer[i * 24 + 8 + j] = Flecha_Rojo[i * 16 + j];
                    }
                }
            }
            else
            {
                for (uint16_t i = 0; i < 64; i++)
                {
                    for (uint16_t j = 0; j < 16; j++)
                    {
                        switch(MODO)
                        {
                            case NADD: 
                                graphicsBuffer[i * 24 + 8 + j] = Rojo_Sol_AI[vv * 1024 + i * 16 + j];
                                break;
                            case IINA: 
                                graphicsBuffer[i * 24 + 8 + j] = Rojo_Sol_AD[vv * 1024 + i * 16 + j];
                                break;
                            case AAND:
                            case IIND: 
                            case IAND:
                                graphicsBuffer[i * 24 + 8 + j] = Rojo_Sol_D[vv * 1024 + i * 16 + j];
                                break;
                            case NIAA: 
                            case NIDD: 
                            case NIAD: 
                                graphicsBuffer[i * 24 + 8 + j] = Rojo_Sol_I[vv * 1024 + i * 16 + j];
                                break;            
                        }
                    }                           
                }
            }
        }


        if ((estado == EDO_AMA) && (i % 10) == 0)
        {
            if (v5 == 0)
            {
                vv++;
                if (vv >= 5)
                {
                    v5 = 1;
                    vv = 5;
                }
            }
            else if (v5 < 4)
                v5++;
            else
            {
                v5 = 0;
                vv = 0;
            }
                
            if((MODO < SOL)||((MODO > SOL) && (estado_solapado == 1))) // No hay solape
            {
                for (uint16_t i = 0; i < 64; i++)
                {
                    for (uint16_t j = 0; j < 16; j++)
                    {
                        graphicsBuffer[i * 24 + 8 + j] = Flecha_Amarillo[i * 16 + j];
                    }
                }
            } 
            else
            {
                for (uint16_t i = 0; i < 64; i++)
                {
                    for (uint16_t j = 0; j < 16; j++)
                    {
                        switch(MODO)
                        {
                            case NADD: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Ama_Sol_AI[vv * 384 + i * 6 + j];
                                break;
                            case IINA: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Ama_Sol_AD[vv * 384 + i * 6 + j];
                                break;
                            case AAND:
                            case IIND: 
                            case IAND:
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Ama_Sol_D[vv * 384 + i * 6 + j];
                                break;
                            case NIAA: 
                            case NIDD: 
                            case NIAD: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Ama_Sol_I[vv * 1024 + i * 16 + j];
                                break;            
                        }
                    }
                }
            }
        }
        if ((estado == EDO_VER) && (i % 10) == 0)
        {
            if(v5 == 0)
            {
                vv++;
                if (vv >= 5)
                {
                    v5 = 1;
                    vv = 5;
                }
            }
            else if(v5 < 2)
                v5++;
            else
            {
                v5 = 0;
                vv = 0;
            }
            
            for (uint16_t i = 0; i < 64; i++)
            {
                for (uint16_t j = 0; j < 16; j++)
                {
                    if(estado_solapado == 0)
                    {
                        switch(MODO)
                        {
                            case AAA: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_AAA[vv * 1024 + i * 16 + j];
                                break;
                            case DDD: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_DDD[vv * 1024 + i * 16 + j];
                                break;
                            case III: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_III[vv * 1024 + i * 16 + j];
                                break;
                            case ADD: 
                            case NADD: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_ADD[vv * 1024 + i * 16 + j];
                                break;
                            case AAD: 
                            case AAND:
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_AAD[vv * 1024 + i * 16 + j];
                                break;
                            case IAA: 
                            case NIAA: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IAA[vv * 1024 + i * 16 + j];
                                break;
                            case IIA: 
                            case IINA: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IIA[vv * 1024 + i * 16 + j];
                                break;
                            case IDD: 
                            case NIDD: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IDD[vv * 1024 + i * 16 + j];
                                break;
                            case IID: 
                            case IIND: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IID[vv * 1024 + i * 16 + j];
                                break;
                            case IAD: 
                            case IAND: 
                            case NIAD: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IAD[vv * 1024 + i * 16 + j];
                                break;            
                        }
                    }
                    else
                    {
                        switch(MODO)
                        {
                            case NADD: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_NADD[vv * 1024 + i * 16 + j];
                                break;
                            case AAND:
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_AAND[vv * 1024 + i * 16 + j];
                                break;
                            case NIAA: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_NIAA[vv * 1024 + i * 16 + j];
                                break;
                            case IINA: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IINA[vv * 1024 + i * 16 + j];
                                break;
                            case NIDD: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_NIDD[vv * 1024 + i * 16 + j];
                                break;
                            case IIND: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IIND[vv * 1024 + i * 16 + j];
                                break;
                            case IAND: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_IAND[vv * 1024 + i * 16 + j];
                                break;   
                            case NIAD: 
                                graphicsBuffer[i * 24 + 8 + j] = Flecha_Verde_NIAD[vv * 1024 + i * 16 + j];
                                break;           
                        }

                    }
                }
            }
        }

        vTaskDelay(pdMS_TO_TICKS(20));
    }
}

static void HUB75_task(void *arg)
{
    HUB75_init();

    while (1)
    {
        HUB75_displayBuffer_Color64(graphicsBuffer, at);
        vTaskDelay(pdMS_TO_TICKS(1));
    }
}


#ifndef SIMULACION

#define INTERVALO 20

static void Luces_task(void *arg)
{
    uint16_t tiempo[4] = {0, 0, 0, 0};

    gpio_reset_pin(ENT_VER);
    gpio_set_direction(ENT_VER, GPIO_MODE_INPUT);
    gpio_set_pull_mode(ENT_VER, GPIO_PULLUP_ONLY);

    gpio_reset_pin(ENT_AMA);
    gpio_set_direction(ENT_AMA, GPIO_MODE_INPUT);
    gpio_set_pull_mode(ENT_AMA, GPIO_PULLUP_ONLY);

    gpio_reset_pin(ENT_SOL);
    gpio_set_direction(ENT_SOL, GPIO_MODE_INPUT);
    gpio_set_pull_mode(ENT_SOL, GPIO_PULLUP_ONLY);

    estado_inicial = gpio_get_level(ENT_AMA) * 2 + gpio_get_level(ENT_VER);
    do
    {
        vTaskDelay(pdMS_TO_TICKS(100));
        estado_actual = gpio_get_level(ENT_AMA) * 2 + gpio_get_level(ENT_VER);
    } while (estado_actual == estado_inicial);

    while (1)
    {
        if (tiempos_OK < 3)
        {
            ds = 0;
            estado_inicial = estado_actual;
            do
            {
                vTaskDelay(pdMS_TO_TICKS(100));
                ds++;
                estado_actual = gpio_get_level(ENT_AMA) * 2 + gpio_get_level(ENT_VER);
            } while (estado_actual == estado_inicial);
            tiempo[estado_inicial] = ds;
            tiempos_OK++;
        }
        else
        {
            ds = tiempo[estado_actual] + 10;
            estado_inicial = estado_actual;
            do
            {
                vTaskDelay(pdMS_TO_TICKS(100));
                if (ds < 0)
                    tiempos_OK = 0;
                else
                    ds--;
                estado_actual = gpio_get_level(ENT_AMA) * 2 + gpio_get_level(ENT_VER);
            } while (estado_actual == estado_inicial);
            if (ds > INTERVALO)
                tiempos_OK = 0;
        }
    }
}

#endif