#include "hwCtrl.h"
#include "r_cg_port.h"
#include "iodefine.h"

#include "r_cg_adc.h"
static uint8_t keystate[SIG_NUM] = {0};
static uint8_t keyPressFlag[SIG_NUM] = {0};
static uint8_t keyReleaseFlag[SIG_NUM] = {0};
static uint16_t keydelay[SIG_NUM] = {0};
uint16_t g_adval[12];

#define KEY_DELAY_TIMES 20 //20Ms
void ClearKeyState(void)
{
    uint8_t i;
    for (i = 0; i < SIG_NUM; i++)
    {
        keystate[i] = 0;
    }
}
void setKeyPressFlag(uint8_t id)
{
    if (id < SIG_NUM)
    {
        keyPressFlag[id] = KEY_PRESSED;
    }
}
void setKeyReleaseFlag(uint8_t id)
{
    
    if (id < SIG_NUM)
    {
        keyReleaseFlag[id] = KEY_PRESSED;
    }
}
uint8_t getKeyPressFlag(uint8_t id)
{
    uint8_t retVal = KEY_NOPRESSED;
    if (id < SIG_NUM)
    {
        retVal = keyPressFlag[id];
        keyPressFlag[id] = KEY_NOPRESSED;
    }
    return retVal;
}
uint8_t getKeyReleaseFlag(uint8_t id)
{
    uint8_t retVal = KEY_NOPRESSED;
    if (id < SIG_NUM)
    {
        retVal = keyReleaseFlag[id];
        keyReleaseFlag[id] = KEY_NOPRESSED;
    }
    return retVal;
}

void KeyScan(void)
{
    uint8_t i,key,key_nopress;
    key_nopress = 0;
    for (i = 0; i < SIG_NUM; i++)
    {
        key = GetIOState(i);
        if (key == KEY_PRESSED && keystate[i] == KEY_NOPRESSED)
        {
            keydelay[i]++;
            if (keydelay[i] >= KEY_DELAY_TIMES)
            {
                keystate[i] = KEY_PRESSED;
                setKeyPressFlag(i);
            }
        }
        else if(key == KEY_NOPRESSED)
        {
            if (keydelay[i] > 0)
            {
                keydelay[i]--;
            }
            else
            {
                if (keystate[i] == KEY_PRESSED)
                {
                    setKeyReleaseFlag(i);
                }
                keystate[i] = KEY_NOPRESSED;
                key_nopress++;
            }  
        }
    }
    if (key_nopress == 6)
    {
        //
    }
    
}

void P_light_Ctrl(uint8_t state)
{
    switch (state)
    {
    case P_LIGHT_NONE:
        O_IND5_CTRL = 0;
        O_IND1_CTRL = 0;
        break;
    case P_LIGHT_RED:
        O_IND5_CTRL = 1;
        O_IND1_CTRL = 0;
        break;
    case P_LIGHT_YELLOE:
        O_IND5_CTRL = 0;
        O_IND1_CTRL = 1;
        break;
    default:
        break;
    }
}


uint8_t GetIOState(uint8_t keyno)
{
    switch (keyno)
    {
    //KEY
    case SIGID_SW_LOCK_IN:
        return I_SW_LOCK_IN==0?1:0;
    case SIGID_SW_L_IN:
        return I_SW_L_IN==0?1:0;
    case SIGID_SW_P_IN:
        return I_SW_RE1==0?1:0;
    case SIGID_SW_RE2:
        return I_SW_RE2==0?1:0;
    default:
        return 0;
    }
}

uint8_t GetKeyState(uint8_t keyno)
{
    if (keyno < SIG_NUM)
    {
        return keystate[keyno];
    }
    return KEY_NOPRESSED;
}


void IND_Ctrl(uint8_t fnr_state)
{
    //O_IND_CTRL = 1;
    switch (fnr_state)
    {
    case FNR_STATE_F:
        O_IND2_CTRL = 1;
        O_IND3_CTRL = 0;
        O_IND4_CTRL = 0;
        break;
    case FNR_STATE_N:
        O_IND2_CTRL = 0;
        O_IND3_CTRL = 1;
        O_IND4_CTRL = 0;
        break;

    case FNR_STATE_R:
        O_IND2_CTRL = 0;
        O_IND3_CTRL = 0;
        O_IND4_CTRL = 1;
        break;
    case FNR_ALL_LIGHT:
        O_IND2_CTRL = 1;
        O_IND3_CTRL = 1;
        O_IND4_CTRL = 1;
        break;
    default:
        break;
    }
}

void RE1LED_CTRL(uint8_t state)
{
    if (state == 0)
    {
        O_IND5_CTRL = 0;
    }
    else
    {
        O_IND5_CTRL = 1;
    }
    
}
void RE2LED_CTRL(uint8_t state)
{
    if (state == 0)
    {
        O_IND6_CTRL = 0;
    }
    else
    {
        O_IND6_CTRL = 1;
    }
}


uint16_t getAdval(ADCH_type ch)
{
    if (ch < ADCH_NUM)
    {
        return g_adval[ch];
    }
    
    return 0;
}

void ad_handle(void)
{
    switch (ADS)
    {
    case _00_AD_INPUT_CHANNEL_0:
        R_ADC_Get_Result(g_adval);
        ADS = _01_AD_INPUT_CHANNEL_1;
        break;
    case _01_AD_INPUT_CHANNEL_1:
        R_ADC_Get_Result(g_adval+1);
        ADS = _02_AD_INPUT_CHANNEL_2;
        break;
    case _02_AD_INPUT_CHANNEL_2:
        R_ADC_Get_Result(g_adval+2);
        ADS = _03_AD_INPUT_CHANNEL_3;
        break;
    case _03_AD_INPUT_CHANNEL_3:
        R_ADC_Get_Result(g_adval+3);
        ADS = _00_AD_INPUT_CHANNEL_0;
        break;
    default:
        ADS = _00_AD_INPUT_CHANNEL_0;
        break;
    }
}


/*****************diagnostic******************/

void getInputStatus(unsigned char* data)
{
    data[0] = 0;

}