#include "api_rt_cap.h"
#include "api_rt_dbg.h"

#include "board_config.h"
#include "gd32f30x.h"

ApiRtCap_Handle Caps[1];


/* ========================================================================== */
/* ============================ Api RT Functions ============================ */
/* ========================================================================== */
void iRtCap_Init(void)
{
    Caps[0].CapBase = TIMER1;

    Caps[0].CountMaxISR.Enable = 0;
    Caps[0].CountMaxISR.Action = 0;

    for (int i = 0; i < 4; i++)
    {
        Caps[0].ChannelISR[i].Enable = 0;
        Caps[0].ChannelISR[i].Action = 0;
    }
}

void iRtCap_Isr(uint8_t devIndex)
{   
    uint32_t base = Caps[devIndex].CapBase;
    uint8_t  capValues[5]={0,0,0,0,0};
    uint8_t  results[5]={0,1,2,3,4};
    uint16_t tmpIntf;
    
    tmpIntf = TIMER_INTF(base);   
    for (int i = 1; i < 5; i++)
    {
        if (tmpIntf & (0x01 << i ))
        {
            capValues[i] = iCap_GetCaptureValue(devIndex,(i));
        }
    }
    if (tmpIntf & 0x01)
    {      
        capValues[0] = iCap_GetPeriod(devIndex) >> 1;
    }

    for(int i = 0; i < 4; i++)
    { 
        for(int j = 0;j < (4-i); j++)
        {
           if(capValues[results[j]]< capValues[results[j + 1]])
           {
               uint8_t tmp = results[j];
               results[j] = results[j + 1];
               results[j + 1] = tmp;
           }
        }
    }
    for(int i = 0; i < 5; i++)
    { 
          if (tmpIntf & (0x01 << results[i]))
          {
              if(results[i]==0)
              {
                  if (Caps[devIndex].CountMaxISR.Enable && Caps[devIndex].CountMaxISR.Action != 0)
                  {
                      Caps[devIndex].CountMaxISR.Action();
                  }
                  TIMER_INTF(base) &= ~0x01;
              }
              else
              {
                    if (Caps[devIndex].ChannelISR[results[i]-1].Enable && Caps[devIndex].ChannelISR[results[i]-1].Action != 0)
                    {
                        Caps[devIndex].ChannelISR[results[i]-1].Action();
                    }
                    TIMER_INTF(base) &= ~(0x01 << results[i]);
              }
              
          }
    }
}


/* ========================================================================== */
/* ============================== API Functions ============================= */
/* ========================================================================== */

uint32_t iCap_GetClock(uint8_t devIndex)
{
    return HW_TIM_CLOCK_HZ;
}

void iCap_SetEdgeType(uint8_t devIndex, uint8_t channelIndex, ApiCap_EdgeType edge)
{
    uint32_t base = Caps[devIndex].CapBase;

    uint32_t data = 0x00;
    uint32_t mask = 0x0F;

    switch (edge)
    {
    case ApiCap_NoneEdge:
        data = 0x00;
        break;
    case ApiCap_RisingEdge:
        data = 0x01;
        break;
    case ApiCap_FallingEdge:
        data = 0x03;
        break;
    case ApiCap_BothEdge:
        data = 0x0B;
        break;
    default:
        break;
    }

    data = data << (channelIndex * 4);
    mask = mask << (channelIndex * 4);
    
    TIMER_CHCTL2(base) &= ~mask;
    TIMER_CHCTL2(base) |= data;
}

void iCap_Enable(uint8_t devIndex)
{
    uint32_t base = Caps[devIndex].CapBase;
    TIMER_CTL0(base)|= ((uint32_t)0x01);
}

void iCap_Disable(uint8_t devIndex)
{
    uint32_t base = Caps[devIndex].CapBase;
    TIMER_CTL0(base) &= ~((uint32_t)0x01);
}

void iCap_SetPeriod(uint8_t devIndex, uint32_t prd)
{
    uint32_t base = Caps[devIndex].CapBase;

    TIMER_CAR(base) = prd;
}

uint32_t iCap_GetPeriod(uint8_t devIndex)
{
    return TIMER_CAR(Caps[devIndex].CapBase);
}

uint32_t iCap_GetCaptureValue(uint8_t devIndex, uint8_t channelIndex)
{
    uint32_t base = Caps[devIndex].CapBase;

    uint32_t value = 0;
    switch (channelIndex)
    {
    case 0:
        value = TIMER_CH0CV(base);
        break;
    case 1:
        value = TIMER_CH1CV(base);
        break;
    case 2:
        value = TIMER_CH2CV(base);
        break;
    case 3:
        value = TIMER_CH3CV(base);
        break;
    default:
        break;
    }
    return value;
}
    

void iCap_EnableCaptureReset(uint8_t devIndex, uint8_t channelIndex)
{

}

void iCap_DisableCaptureReset(uint8_t devIndex, uint8_t channelIndex)
{

}

void iCap_EnableDeviceInterrupt(uint8_t devIndex)
{
    Caps[devIndex].CountMaxISR.Enable = 1;
}

void iCap_DisableDeviceInterrupt(uint8_t devIndex)
{
    Caps[devIndex].CountMaxISR.Enable = 0;
}

void iCap_BindDeviceInterrupt(uint8_t devIndex, void (*action)())
{
    Caps[devIndex].CountMaxISR.Action = action;
}

void iCap_EnableChannelInterrupt(uint8_t devIndex, uint8_t channelIndex)
{
    Caps[devIndex].ChannelISR[channelIndex].Enable = 1;
}

void iCap_DisableChannelInterrupt(uint8_t devIndex, uint8_t channelIndex)
{
    Caps[devIndex].ChannelISR[channelIndex].Enable = 0;
}

void iCap_BindChannelInterrupt(uint8_t devIndex, uint8_t channelIndex, void (*action)())
{
    Caps[devIndex].ChannelISR[channelIndex].Action = action;
}