#include "board.h"
#include "myRadio.h"
#include "myRadio_gpio.h"

/**-------------------------radio include----------------------------------**/
#include "radio.h"
#include "sx1276.h"
#include "crc.h"
#include "sx1276-Lora.h"
#include "sx1276-LoRaMisc.h"
/**-------------------------radio include end----------------------------------**/

static int8_t rfTxPower;
static uint32_t rfFrequence;
static uint32_t rfBaudrate;
static rfRxCallBack rxCb;
static uint8_t rfRxBuffer[255];
static uint32_t rf_handle;
static uint8_t rf_workProcess;
static uint8_t chipType;
/**-------------------------radio params----------------------------------**/
tRadioDriver *Radio = NULL;
uint16_t num_rx=0;
uint8_t   RXBuffer[RF_BUFFER_SIZE];  //RX buffer            
uint8_t   TXBuffer[RF_BUFFER_SIZE];  //TX buffer
uint16_t  crc_value;
uint8_t isContinues;
const loraBaudrateFrame_ts loraBaudrateFrame[MAX_RF_BAUDRATE_COUNT] = 
{
    {//91.55bps,SF=12,BW=62.5kHz(6),CR=4
    .SpreadingFactor = 12,        
    .SignalBw = 6,               
    .ErrorCoding = 4,            
    },
    {//610.35bps,SF=10,BW=125kHz(7),CR=4
    .SpreadingFactor = 10,        
    .SignalBw = 7,               
    .ErrorCoding = 4,            
    },
    {//1220.7bps,SF=10,BW=250kHz(8),CR=4
    .SpreadingFactor = 10,        
    .SignalBw = 8,               
    .ErrorCoding = 4,            
    },
    {//2441.41bps,SF=10,BW=500kHz(9),CR=4
    .SpreadingFactor = 10,        
    .SignalBw = 9,               
    .ErrorCoding = 4,            
    },
    {//5022.32bps,SF=9,BW=500kHz(9),CR=3
    .SpreadingFactor = 9,        
    .SignalBw = 9,               
    .ErrorCoding = 3,            
    },
    {//12500bps,SF=8,BW=500kHz(9),CR=1
    .SpreadingFactor = 8,        
    .SignalBw = 9,               
    .ErrorCoding = 1,            
    },
    {//37500bps,SF=6,BW=500kHz(9),CR=1
    .SpreadingFactor = 7,        
    .SignalBw = 9,               
    .ErrorCoding = 1,            
    },    
    {//62500bps,SF=5,BW=500kHz(9),CR=1
    .SpreadingFactor = 5,        
    .SignalBw = 9,               
    .ErrorCoding = 1,            
    },
};
/**-------------------------radio params end----------------------------------**/
void myRadio_delay(uint32_t time_ms)
{
    uint32_t i, j;
    i = time_ms;
    while (i --)
    {
        for ( j = 0; j < 1000; j++)
        {
            ;
        }
    }
}
/**
 * @brief IO口中断回调
 *      IO口产生中断后会执行该函数
 *      用于接收射频工作的中断响应
 * 
 * @param index 
 */
void myRadio_gpioCallback(uint8_t index)
{

}
/**
 * @brief 射频初始化
 * 
 * @param agr0 
 * @param agr1_ptr 无线工作状态响应回调
 *          产生回调给外部使用，@rfRxCallBack
 */
void myRadio_init(int agr0, void *agr1_ptr)
{
    myRadio_gpio_init(0);
    
/**-------------------------radio init----------------------------------**/
    Radio = RadioDriverInit();
    Radio->Init();
/**-------------------------radio init end----------------------------------**/
    RF_EXT_PA_TO_IDLE();
    if ((rfRxCallBack )agr1_ptr)
    {
        rxCb = (rfRxCallBack )agr1_ptr;
    }
    rf_handle = 0xe5;
}
/**
 * @brief 射频底层执行程序
 *      要放在主循环中执行
 * 
 */
void myRadio_process(void)
{
    if (rf_handle == 0)
    {
        return;
    }
    if (isContinues)
    {
        return;
    }
    
    switch (Radio->Process())
    {
    case RF_IDLE:
    {

    }
        break;
    case RF_BUSY:
    {

    }
        break;
    case RF_RX_DONE:
    {
        rfRxPacket_ts rfRxPacket;
        Radio->GetRxPacket( RXBuffer, ( uint16_t* )&num_rx );
        
        if(num_rx > 0)
        {
            if (rxCb)
            {
                rfRxPacket.len = num_rx;
                rfRxPacket.rssi = SX1276GetPacketRssi();
                memset(rfRxPacket.payload, 0, sizeof(rfRxPacket.payload));
                memcpy(rfRxPacket.payload, RXBuffer, rfRxPacket.len);
                rxCb(RX_STA_SECCESS, rfRxPacket);
            }
        }  
    }
        break;
    case RF_RX_TIMEOUT:
    {
        rfRxPacket_ts rfRxPacket;
        if (rxCb)
        {
            rxCb(RX_STA_TIMEOUT, rfRxPacket);
        }
    }
        break;
    case RF_TX_DONE:
    {
        rfRxPacket_ts rfRxPacket;
        if (rxCb)
        {
            rxCb(TX_STA_SECCESS, rfRxPacket);
        }
    }
        break;
    case RF_TX_TIMEOUT:
    {
        rfRxPacket_ts rfRxPacket;
        if (rxCb)
        {
            rxCb(TX_STA_ERROR, rfRxPacket);
        }
    }
        break;
    case RF_LEN_ERROR:
    {

    }
        break;
    case RF_CHANNEL_EMPTY:
    {

    }
        break;
    case RF_CHANNEL_ACTIVITY_DETECTED:
    {

    }
        break;

    default:
        break;
    }
}
/**
 * @brief 退出射频进入休眠
 * 
 */
void myRadio_abort(void)
{
    if (rf_handle == 0)
    {
        return;
    }
    RF_EXT_PA_TO_IDLE();

    isContinues = 0;
    SX1276FskSetOpMode( RF_OPMODE_SLEEP );
}
/**
 * @brief 获取射频工作中心频率
 * 
 * @return uint32_t 
 */
uint32_t myRadio_getFrequency(void)
{
    if (rf_handle == 0)
    {
        return 0;
    }
    return rfFrequence;
}
/**
 * @brief 设置射频工作中心频率
 * 
 * @param freq 
 *      具体频点，单位：Hz
 */
void myRadio_setFrequency(uint32_t freq)
{
    if (rf_handle == 0)
    {
        return;
    }
    rfFrequence = freq;
    if (SX1276GetLoRaOn())
    {
        SX1276LoRaSetRFFrequency(rfFrequence);
    }
    else
    {
        SX1276FskSetRFFrequency(rfFrequence);
    }
}
/**
 * @brief 获取发射功率
 * 
 * @return int8_t 
 */
int8_t myRadio_getTxPower(void)
{
    if (rf_handle == 0)
    {
        return 0;
    }
    return rfTxPower;
}
/**
 * @brief 设置发射功率
 * 
 * @param power 
 *          单位：dbm
 */
void myRadio_setTxPower(int8_t power)
{
    if (rf_handle == 0)
    {
        return;
    }
    rfTxPower = power;
    FskSettings.Power = rfTxPower;
    LoRaSettings.Power = rfTxPower;
}
/**
 * 获取射频波特率
 * @param : br->
*/
uint32_t myRadio_getBaudrate(void)
{
    if (rf_handle == 0)
    {
        return 0;
    }
    return rfBaudrate;
}
/**
 * 设置射频波特率
 * @param : br->
*/
void myRadio_setBaudrate(uint32_t br)
{
    if (rf_handle == 0)
    {
        return;
    }
    rfBaudrate = br;
    SX1276LoRaSetSpreadingFactor( loraBaudrateFrame[rfBaudrate].SpreadingFactor ); // SF6 only operates in implicit header mode.
    SX1276LoRaSetErrorCoding( loraBaudrateFrame[rfBaudrate].ErrorCoding );
    SX1276LoRaSetSignalBandwidth( loraBaudrateFrame[rfBaudrate].SignalBw );
    if (rfBaudrate >= RF_BAUDRATE_37500)
    {
        LoRaSettings.ImplicitHeaderOn = true;
        SX1276LoRaSetImplicitHeaderOn( LoRaSettings.ImplicitHeaderOn );
    }
    else
    {
        LoRaSettings.ImplicitHeaderOn = false;
        SX1276LoRaSetImplicitHeaderOn( LoRaSettings.ImplicitHeaderOn );
    }
}
void myRadio_setRfParams(uint8_t sf, uint8_t bw, uint8_t cr)
{
    if (rf_handle == 0)
    {
        return;
    }
    SX1276LoRaSetSpreadingFactor(sf); // SF6 only operates in implicit header mode.
    SX1276LoRaSetErrorCoding(cr);
    SX1276LoRaSetSignalBandwidth(bw);
    if( ( ( bw <= 7 ) && ( ( sf == 11 ) || (( bw <= 6 ) &&  sf == 10 ) ) ) ||
    ( ( bw <= 8 ) && ( sf == 12 ) ) )
    {
        SX1276LoRaSetLowDatarateOptimize(true);
        printf("low data rate optimize\r\n");
    }
    else
    {
        printf("low data rate optimize false\r\n");
        SX1276LoRaSetLowDatarateOptimize(false);
    }
}
/**
 * @brief 设置模组型号
 * 
 * @param type 
 */
void myRadio_setChipType(uint8_t type)
{
    chipType = type;
}
/**
 * @brief 获取模组型号
 * 
 * @return uint8_t 
 */
uint8_t myRadio_getChipType(void)
{
    return chipType;
}
int16_t myRadio_getRssi(void)
{
    return (int16_t)SX1276ReadRssi();
}
/**
 * @brief 无线发送数据包
 * 
 * @param packet 
 */
void myRadio_transmit(rfTxPacket_ts *packet)
{
    if (rf_handle == 0)
    {
        return;
    }
    RF_EXT_PA_TO_TX();
    Radio->SetTxPacket(packet->payload, packet->len);
    packet->absTime = RadioTimeOnAir(packet->len);
}
/**
 * @brief 进入无线接收
 * 
 */
void myRadio_receiver(void)
{ 
    if (rf_handle == 0)
    {
        return;
    }
    RF_EXT_PA_TO_RX();
    Radio->StartRx();
}
void myRadio_setCtrl(controlMode_te mode, uint32_t value)
{
    if (rf_handle == 0)
    {
        return;
    }
    switch (mode)
    {
    case RADIO_EXT_CONTROL_TX_UNMODULATED:
    {
        RF_EXT_PA_TO_TX();
        isContinues = 1;
        SX1276setLoRaSta(false);
        FskSettings.RFFrequency=value;
        FskSettings.Fdev=0;
        FskSettings.Power=rfTxPower;
        Radio->Init();
        myRadio_delay(100);
        EnterTestMode();
        
    }
        break;
    case RADIO_EXT_CONTROL_TX_MODULATED:
    {
        RF_EXT_PA_TO_TX();
        isContinues = 2;
        SX1276setLoRaSta(false);
        FskSettings.RFFrequency=value;
        FskSettings.Bitrate=1000;
        FskSettings.Fdev=35000;
        FskSettings.Power=rfTxPower;
        Radio->Init();
        myRadio_delay(100);
        EnterTestMode();
    }
        break;
    case RADIO_EXT_CONTROL_RX_SENSITIVITY:
    {
        RF_EXT_PA_TO_RX();
        SX1276setLoRaSta(false);
        FskSettings.RFFrequency=value;

        FskSettings.Bitrate=10000;
        FskSettings.RxBw=35000;
        FskSettings.RxBwAfc=150000;
        FskSettings.CrcOn=true;
        FskSettings.AfcOn=false;
        FskSettings.PayloadLength=255;
        Radio = RadioDriverInit();
        Radio->Init();
        myRadio_delay(50);
        EnterRxTestMode();
    }
        break;
    
    default:
        break;
    }
}

/**-------------------------radio funtion----------------------------------**/

/**-------------------------radio funtion end----------------------------------**/