#include "SIM7080GInterface.h"
#include "BoardCfg.h"
#include "timer.h"
#include "Uart.h"
#include "Syslog.h"
#include "WiFiCtrl.h"
#include "ATCmdInterpreter.h"

static BYTE mActivateNetworkCmd[] = "AT+CNACT=0,1\r";
static BYTE mCheckAPNConnectionCmd[] = "AT+CNACT?\r";
static BYTE mConnectToMasterCmd[] = "AT+CAOPEN=0,0,\"TCP\",\"grosgin.myftp.org\",6463\r";
static BYTE mDisconnectFromMasterCmd[] = "AT+CACLOSE=0\r";
static BYTE mReceiveDataCmd[] = "AT+CARECV=0,100\r";


int mLTEModuleSMState;
int mLTEModuleOperationSMState;
int mNbCmdCharsReceived;
char mATCmd[LTE_MODULE_MAX_CMD_LENGTH];
bool mIsPassthroughEnabled;
bool mModuleSerialDebugEnabled;
bool mPICSerialDebugEnabled;
int mCurrentCmd;

bool mMasterConnected;
bool mAPNConnected;

void InitLTEModule()
{
    mLTEModuleSMState = LTE_MODULE_SM_INIT_STATE;
    mLTEModuleOperationSMState = LTE_MODULE_OPERATION_INIT_STATE;
    mNbCmdCharsReceived = 0;
    mIsPassthroughEnabled = false;
    mModuleSerialDebugEnabled = false;
    mPICSerialDebugEnabled = false;
    mCurrentCmd = LTE_MODULE_NO_CMD;
    
    mMasterConnected = false;
    mAPNConnected = false;
}

void LTEModuleSM(int SMEvent)
{
    switch(mLTEModuleSMState)
    {
        case LTE_MODULE_SM_INIT_STATE:
        {
            LORA_MODULE_RELAY_PIN = 1;
            TimerStart(LTE_MODULE_TIMER,LTE_MODULE_POWERUP_TIMEOUT);
            mLTEModuleSMState = LTE_MODULE_SM_RESET_STATE;
            break;
        }
        case LTE_MODULE_SM_RESET_STATE:
        {
            if(IsTimerExpired(LTE_MODULE_TIMER) == true)
            {
                LORA_MODULE_RELAY_PIN = 0;
                LTE_MODULE_PWR_PIN = 0;
                TimerStart(LTE_MODULE_TIMER,LTE_MODULE_POWERUP_TIMEOUT);
                mLTEModuleSMState = LTE_MODULE_SM_POWERUP_STATE;
            }
            break;
        }
        case LTE_MODULE_SM_POWERUP_STATE:
        {
            if(IsTimerExpired(LTE_MODULE_TIMER) == true)
            {
                LTE_MODULE_PWR_PIN = 1;
                TimerStart(LTE_MODULE_TIMER,LTE_MODULE_WAIT_INIT_TIMEOUT);
                mLTEModuleSMState = LTE_MODULE_SM_WAIT_RDY_STATE;
            }
            break;
        }
        case LTE_MODULE_SM_WAIT_RDY_STATE:
        {
            if(SMEvent == LTE_MODULE_RX_RDY_EVENT)
            {
                mLTEModuleSMState = LTE_MODULE_SM_SETECHOOFF_STATE;
            }
            else if(SMEvent == LTE_MODULE_SM_TICK_EVENT)
            {
                //TODO: it module takes too much time... reset..
                //            if(IsTimerExpired(LTE_MODULE_TIMER) == true)
                //            {
                //                mLTEModuleSMState = LTE_MODULE_SM_SETAPN_STATE;
                //            }
            }
            break;
        }
        case LTE_MODULE_SM_SETECHOOFF_STATE:
        {
            char Cmd[5] = {'A','T','E','0','\r'};
            //UartTransmitData(LTE_IF_UART_PORT,Cmd,5);
            SendDataToLteModule(Cmd,5);
            TimerStart(LTE_MODULE_TIMER,4000);
            mLTEModuleSMState = LTE_MODULE_SM_DELAY_STATE;
            break;
        }
        case LTE_MODULE_SM_SETAPN_STATE:
        {
            char Cmd[10] = {'A','T','+','C','G','N','A','P','N','\r'};
            //UartTransmitData(LTE_IF_UART_PORT,Cmd,10);
            SendDataToLteModule(Cmd,10);
            TimerStart(LTE_MODULE_TIMER,4000);
            mLTEModuleSMState = LTE_MODULE_SM_DELAY_STATE;
            break;
        }
        case LTE_MODULE_SM_DELAY_STATE:
        {
            if(IsTimerExpired(LTE_MODULE_TIMER) == true)
            {
                mLTEModuleSMState = LTE_MODULE_SM_RUN_STATE;
            }
            break;
        }
        case LTE_MODULE_SM_RUN_STATE:
        {
            if(SMEvent == LTE_MODULE_ENTER_PASSTHROUGH_EVENT)
            {
                mLTEModuleSMState = LTE_MODULE_SM_PASSTHROUGH_STATE;
                SyslogNewString("LTE Module entering passthrough mode...");
            }
            if(SMEvent == LTE_MODULE_SM_TICK_EVENT)
            {
                LTEModuleOperationSM(LTE_MODULE_OP_TICK_EVENT);
            }
            
            break;
        }
        case LTE_MODULE_SM_PASSTHROUGH_STATE:
        {
            if(SMEvent == LTE_MODULE_EXIT_PASSTHROUGH_EVENT)
            {
                SyslogNewString("LTE Module exiting passthrough mode...");
                mLTEModuleSMState = LTE_MODULE_SM_RUN_STATE;  
            }
            break;
        }
    }
}

void TickLTEModule()
{
    LTEModuleSM(LTE_MODULE_SM_TICK_EVENT);
}


void LTEModuleNewData(unsigned char Data)
{
    if(mIsPassthroughEnabled == true)
    {
        SyslogNewByte(Data);
        //        SendSyslogByte(Data);
        return;
    }
    
    if(mModuleSerialDebugEnabled == true)
    {
        SyslogNewByte(Data);
    }
    
    if(Data == '\n')    //ignore line feeds
        return;
    
    if(Data != '\r')
    {
        if(mNbCmdCharsReceived < LTE_MODULE_MAX_CMD_LENGTH)
        {
            mATCmd[mNbCmdCharsReceived] = Data;
            mNbCmdCharsReceived++;
        }
        else
        {
            //error...
            mNbCmdCharsReceived = 0;
        }
    }
    else
    {
        if(mNbCmdCharsReceived != 0)    //New Command received
        {
            
            if(mLTEModuleSMState == LTE_MODULE_SM_WAIT_RDY_STATE)
            {
                if(mATCmd[0] == 'R' && mATCmd[1] == 'D' && mATCmd[2] == 'Y')
                {
                    LTEModuleSM(LTE_MODULE_RX_RDY_EVENT);
                }
            }
            else if(mLTEModuleSMState == LTE_MODULE_SM_RUN_STATE)
            {
                AnalyzeNewATString(mATCmd,mNbCmdCharsReceived,mCurrentCmd);
                mNbCmdCharsReceived = mNbCmdCharsReceived;
            }
            
            mNbCmdCharsReceived = 0;
        }
        
    }
}

void LTEEnterSerialPassthrough()
{
    LTEModuleSM(LTE_MODULE_ENTER_PASSTHROUGH_EVENT);
    mIsPassthroughEnabled = true;
    SyslogSetLTEPassthrough(true);
    mPICSerialDebugEnabled = false;
    mModuleSerialDebugEnabled = false;
}
void LTEExitSerialPassthrough()
{
    LTEModuleSM(LTE_MODULE_EXIT_PASSTHROUGH_EVENT);
    mIsPassthroughEnabled = false;
    SyslogSetLTEPassthrough(false);
}

void LTEFwdPassthroughData(char Data)
{
    if(mIsPassthroughEnabled == true)
    {
        UartTransmitData(LTE_IF_UART_PORT,&Data,1);
    }
    
}

int LTEEnableSerialDebug(bool EnModule, bool EnPic)
{
    if(EnModule == true)
    {
        if(mIsPassthroughEnabled == true)
        {
            return RET_ERROR;
        }
        mModuleSerialDebugEnabled = true;
    }
    else
    {
        mModuleSerialDebugEnabled = false;
    }
    
    if(EnPic == true)
    {
        if(mIsPassthroughEnabled == true)
        {
            return RET_ERROR;
        }
        
        mPICSerialDebugEnabled = true;
    }
    else
    {
        mPICSerialDebugEnabled = false;
    }
    
    return RET_OK;
}

void SendDataToLteModule(char *Data, int Size)
{
    if(mPICSerialDebugEnabled)
    {
        int i;
        for(i = 0; i < Size; i++)
        {
            SyslogNewByte(*Data++);
        }
    }
    UartTransmitData(LTE_IF_UART_PORT,Data,Size);
}

void LTECmdResponseReceived(int Cmd, int Result)
{
    switch(Cmd)
    {
        case LTE_MODULE_NO_CMD:
        {
            break;
        }
        case LTE_MODULE_CONNECT_APN_CMD:
        {
            if(Result == LTE_MODULE_RESULT_OK)
            {
                LTEModuleOperationSM(LTE_MODULE_OP_APN_CONN_OK_EVENT);
            }
            else if(Result == LTE_MODULE_RESULT_ERROR)
            {
                LTEModuleOperationSM(LTE_MODULE_OP_APN_CONN_FAILED_EVENT);
            }
            break;
        }
        case LTE_MODULE_DISCONNECT_APN_CMD:
        {
            
            break;
        }
        case LTE_MODULE_CHECK_APN_CONNECTION_CMD:
        {
            if(Result == LTE_MODULE_RESULT_OK)
            {
                if(mAPNConnected == true)
                {
                    LTEModuleOperationSM(LTE_MODULE_OP_APN_CONNECTED_EVENT);
                }
                else
                {
                    LTEModuleOperationSM(LTE_MODULE_OP_APN_DISCONNECTED_EVENT);
                }
            }
            else if(Result == LTE_MODULE_RESULT_ERROR)
            {
                LTEModuleOperationSM(LTE_MODULE_OP_APN_CONN_FAILED_EVENT);
            }
            break;
        }
        case LTE_MODULE_CONNECT_TO_MASTER_CMD:
        {
            if(Result == LTE_MODULE_RESULT_OK)
            {
                if(mMasterConnected == true)
                {
                    LTEModuleOperationSM(LTE_MODULE_OP_SERVER_CONNECTED_EVENT);
                }
                else
                {
                    LTEModuleOperationSM(LTE_MODULE_OP_SERVER_DISCONNECTED_EVENT);
                }
            }
            else if(Result == LTE_MODULE_RESULT_ERROR)
            {
                LTEModuleOperationSM(LTE_MODULE_OP_SERVER_CONN_FAILED_EVENT);
            }
            
            break;
        }
        case LTE_MODULE_DISCONNECT_FROM_MASTER_CMD:
        {
            if(Result == LTE_MODULE_RESULT_OK)
            {
                
            }
            else if(Result == LTE_MODULE_RESULT_ERROR)
            {
                
            }
            break;
        }
        case LTE_MODULE_CHECK_MASTER_CONNECTION_CMD:
        {
            if(Result == LTE_MODULE_RESULT_OK)
            {
                
            }
            else if(Result == LTE_MODULE_RESULT_ERROR)
            {
               
            }
            break;
        }
        case LTE_MODULE_RX_DATA_CMD:
        {
            if(Result == LTE_MODULE_RESULT_OK)
            {
                    //This case is managed by LTEModuleDataReceived()
            }
            else if(Result == LTE_MODULE_RESULT_ERROR)
            {
               LTEModuleOperationSM(LTE_MODULE_OP_MASTER_DATA_RECEIVED_EVENT);
            }
            break;
        }
        case LTE_MODULE_TX_DATA_CMD:
        {
            break;
        }
    }
}
void LTEModuleAPNConnectionStatus(int Status)
{
    if(Status == LTE_MODULE_APN_CONNECTED)
    {
        mAPNConnected = true;
    }
    else
    {
        mAPNConnected = false;
        //TODO: Reconnect..
    }
}
void LTEModuleMasterConnectionStatus(int Status)
{
    if(Status == LTE_MODULE_MASTER_CONNECTED)
    {
        mMasterConnected = true;
    }
    else
    {
        mMasterConnected = false;
    }
}


void LTEModuleOperationSM(int OperationEvent)
{
    switch(mLTEModuleOperationSMState)
    {
        case LTE_MODULE_OPERATION_INIT_STATE:
        {
            //Send the request to connect module APN
            mCurrentCmd = LTE_MODULE_CONNECT_APN_CMD;
            SendDataToLteModule(mActivateNetworkCmd,strlen(mActivateNetworkCmd));
            mLTEModuleOperationSMState = LTE_MODULE_OPERATION_WAIT_CONNECT_APN_STATE;
            
            break;
        }
        case LTE_MODULE_OPERATION_WAIT_CONNECT_APN_STATE:
        {
            if(OperationEvent == LTE_MODULE_OP_APN_CONN_OK_EVENT)
            {
                //Send the request to confirm the state of the connection
                mCurrentCmd = LTE_MODULE_CHECK_APN_CONNECTION_CMD;
                SendDataToLteModule(mCheckAPNConnectionCmd,strlen(mCheckAPNConnectionCmd));
                mLTEModuleOperationSMState = LTE_MODULE_OPERATION_CHECK_APN_STATE;
            }
            if(OperationEvent == LTE_MODULE_OP_APN_CONN_FAILED_EVENT)
            {
                //TODO: What do we do??
                
                //                mCurrentCmd = LTE_MODULE_CHECK_APN_CONNECTION_CMD;
                //                SendDataToLteModule(mCheckAPNConnectionCmd,strlen(mCheckAPNConnectionCmd));
                //                mLTEModuleOperationSMState = LTE_MODULE_OPERATION_CHECK_APN_STATE;
            }
            else if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
            {
                //TODO: manage timeouts
            }
            
            break;
        }
        case LTE_MODULE_OPERATION_CHECK_APN_STATE:
        {  
            if(OperationEvent == LTE_MODULE_OP_APN_CONNECTED_EVENT)
            {
                //Send the request to connect to Mastercontroller
                mCurrentCmd = LTE_MODULE_CONNECT_TO_MASTER_CMD;
                SendDataToLteModule(mConnectToMasterCmd,strlen(mConnectToMasterCmd));
                mLTEModuleOperationSMState = LTE_MODULE_OPERATION_WAIT_CONNECT_SERVER_STATE;
            }
            if(OperationEvent == LTE_MODULE_OP_APN_DISCONNECTED_EVENT)
            {
                //TODO:  What do we do??
                
                //Send the request to connect to Mastercontroller
//                mCurrentCmd = LTE_MODULE_CONNECT_TO_MASTER_CMD;
//                SendDataToLteModule(mConnectToMasterCmd,strlen(mConnectToMasterCmd));
//                mLTEModuleOperationSMState = LTE_MODULE_OPERATION_WAIT_CONNECT_SERVER_STATE;
            }
            else if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
            {
                //TODO: manage timeouts
            }
            break;
        }
        case LTE_MODULE_OPERATION_WAIT_CONNECT_SERVER_STATE:
        {
            if(OperationEvent == LTE_MODULE_OP_SERVER_CONNECTED_EVENT)
            {
                mCurrentCmd = LTE_MODULE_NO_CMD;
                mLTEModuleOperationSMState = LTE_MODULE_OPERATION_STANDBY_STATE;
            }
            if(OperationEvent == LTE_MODULE_OP_SERVER_DISCONNECTED_EVENT)
            {
                //TODO: What do we do?
                
                mCurrentCmd = LTE_MODULE_NO_CMD;
//                mLTEModuleOperationSMState = LTE_MODULE_OPERATION_STANDBY_STATE;
            }
            if(OperationEvent == LTE_MODULE_OP_SERVER_CONN_FAILED_EVENT)
            {
                mCurrentCmd = LTE_MODULE_NO_CMD;
                //TODO: What do we do?
            }
            else if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
            {
                //TODO: manage timeouts
            }
            break;
        }
        case LTE_MODULE_OPERATION_STANDBY_STATE:
        {
            if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
            {
                //TODO: manage timeouts
            }
            if(OperationEvent == LTE_MODULE_OP_MASTER_DATA_READY_EVENT)
            {
                mCurrentCmd = LTE_MODULE_RX_DATA_CMD;
                SendDataToLteModule(mReceiveDataCmd,strlen(mReceiveDataCmd));
                mLTEModuleOperationSMState = LTE_MODULE_OPERATION_WAIT_FOR_DATA_STATE;
            }
            break;
        }
        case LTE_MODULE_OPERATION_WAIT_FOR_DATA_STATE:
        {
            if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
            {
                //TODO: manage timeouts
            }
            if(OperationEvent == LTE_MODULE_OP_MASTER_DATA_RECEIVED_EVENT)
            {
                mCurrentCmd = LTE_MODULE_NO_CMD;
                mLTEModuleOperationSMState = LTE_MODULE_OPERATION_STANDBY_STATE;
            }
            
            break;
        }
    }
}


void LTEModuleNewDataReady()
{
    LTEModuleOperationSM(LTE_MODULE_OP_MASTER_DATA_READY_EVENT);
}
void LTEModuleDataReceived(char *Data, int Size)
{
    LTEModuleOperationSM(LTE_MODULE_OP_MASTER_DATA_RECEIVED_EVENT);
    //Execute command..
}