#include "elite.h"

#if (DEF_ELITE_MODEL == DEF_ELITE_DEV)
#include "elite_dev.h"
#elif (DEF_ELITE_MODEL == DEF_ELITE_EDC_20)
#include "edc.h"
#elif (DEF_ELITE_MODEL == DEF_PULSE_E_LOAD_10)
#include "pel.h"
#elif (DEF_ELITE_MODEL == DEF_CURRENT_PULSE_GANERATOR_10)
#include "cpg.h"
#else
#error "Unknown DEF_ELITE_MODEL"
#endif

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

#include "FreeRTOS.h"
#include "message_buffer.h"
#include "stream_buffer.h"
#include "task.h"

#include <stdlib.h>
#include <string.h>

static const elite_instance_t *p_instance = NULL;

MessageBufferHandle_t instr_msg = NULL;

static void decode_ris_ins(uint8_t *ins, uint16_t size)
{
    uint8_t oper = ins[2];
    if (p_instance->ris_func[oper])
    {
        p_instance->ris_func[oper](ins, size);
    }
    else
    {
        NRF_LOG_INFO("unknown ris instruction");
    }
}

static void decode_vis_ins(uint8_t *ins, uint16_t size)
{
    uint8_t oper = ins[1] & 0xF0; // this is don't care in RISASD;//
    if (p_instance->vis_func[oper])
    {
        p_instance->vis_func[oper](ins, size);
    }
    else
    {
        NRF_LOG_INFO("unknown vis instruction");
    }
}

static void decode_cis_ins(uint8_t *ins, uint16_t size)
{
    uint8_t oper = ins[1] & 0xF0;
    if (p_instance->cis_func[oper])
    {
        p_instance->cis_func[oper](ins, size);
    }
    else
    {
        NRF_LOG_INFO("unknown vis instruction");
    }
}

static void elite_instr_task(void *p_arg)
{
    static size_t instr_size = 0;
    static uint8_t instr[256];

    for (;;)
    {
        instr_size = xMessageBufferReceive(instr_msg, instr, sizeof(instr), portMAX_DELAY);

        if (instr_size)
        {
            uint16_t ins_type = instr[0] & 0b11110000;
            uint16_t chip_id  = instr[0] & 0b00001111;
            switch (ins_type)
            {
                case INS_TYPE_RIS:
                    decode_ris_ins(instr, instr_size);
                    break;
                case INS_TYPE_VIS:
                    decode_vis_ins(instr, instr_size);
                    break;
                case INS_TYPE_CIS:
                    decode_cis_ins(instr, instr_size);
                    break;
                default:
                    break;
            }
        }
    }
}

void elite_init(void)
{
#if (DEF_ELITE_MODEL == DEF_ELITE_DEV)
    p_instance = dev_init();
#elif (DEF_ELITE_MODEL == DEF_ELITE_EDC_20)
    edc.init();
    p_instance = edc.p_elite_instance;
#elif (DEF_ELITE_MODEL == DEF_PULSE_E_LOAD_10)
    p_instance = pel_init();
#elif (DEF_ELITE_MODEL == DEF_CURRENT_PULSE_GANERATOR_10)
    p_instance = cpg_init();
#else
#error "Unknown DEF_ELITE_MODEL"
#endif

    instr_msg = xMessageBufferCreate(1024);
    xTaskCreate(elite_instr_task, "elite_instr", 2048, NULL, 3, NULL);
}

void elite_instr_send(void *p, size_t size)
{
    /* reply the instruction */
    extern ret_code_t le_data_upadate(uint8_t * p_value, uint16_t len);
    le_data_upadate(p, size);

    xMessageBufferSend(instr_msg, p, size, portMAX_DELAY);
}