#include "CableTestEngine.h"
#include "CableTestBench.h"

CCableTestEngine::CCableTestEngine()
{

    mCableTestSMState = CABLE_TEST_INIT_STATE;
}

CCableTestEngine::~CCableTestEngine()
{
    delete mCableTestSMTimer;
}

int CCableTestEngine::InitCableTestEngine(CCableTestBench *ProgramHandle)
{
    mProgramHandle = ProgramHandle;
    mTestCable = ProgramHandle->GetActualCable();
    mTestInputConnectorHandle = mTestCable->GetInputConnector();
    mTestOutputConnectorHandle = mTestCable->GetOutputConnector();


    mCableTestSMTimer = new QTimer();
    mCableTestSMTimer->setSingleShot(false);
    mCableTestSMTimer->setInterval(TEST_ENGINE_SM_TIMEOUT);
    mCableTestSMTimer->stop();
    connect(mCableTestSMTimer,SIGNAL(timeout()),this,SLOT(SMTimerExpired()));

    //TODO: Get this from the options page...
    mPinHoldTime = 500;    //ms

    CableTestEngineStateMachine(CABLE_TEST_TICK_SM_EVENT);

    return RET_OK;
}

void CCableTestEngine::CableTestEngineStateMachine(int Event)
{
    switch(mCableTestSMState)
    {
        case CABLE_TEST_INIT_STATE:
        {
            mCableTestSMState = CABLE_TEST_STBY_STATE;
            mCableTestSMTimer->start();
            break;
        }//case CABLE_TEST_INIT_STATE

        case CABLE_TEST_STBY_STATE:
        {
            switch(Event)
            {
                case CABLE_TEST_START_AUTO_TEST_SM_EVENT:
                {
                    mCableTestSMState = CABLE_TEST_START_AUTOMATED_TEST_STATE;
                    mProgramHandle->CableEngineModeChanged(GetTestEngineCurrentMode());
                    break;
                }
                case CABLE_TEST_START_MANUAL_TEST_SM_EVENT:
                {
                    mCableTestSMState = CABLE_TEST_START_MANUAL_TEST_STATE;
                    break;
                }
                default:
                {
                    break;
                }
            }

            break;
        }// case CABLE_TEST_STBY_STATE

        case CABLE_TEST_START_AUTOMATED_TEST_STATE:
        {
            mTestOutputConnectorHandle->ClearAllPins();
            mCableTestSMState = CABLE_AUTO_TEST_SELF_TEST_STATE;

            mCableTestGPTimer.start();

            qDebug("Test automatique démarré...");
            break;
        }//case CABLE_TEST_START_AUTOMATED_TEST_STATE

        case CABLE_AUTO_TEST_SELF_TEST_STATE:
        {
            if(mCableTestGPTimer.elapsed() < mPinHoldTime)
            {
                break;
            }
            else
            {
                if(mTestOutputConnectorHandle->GetOutputPinsStates().count(true) != 0)
                {
                    //TODO: Manage this failure mode
                    qDebug("Échec de l'auto test des modules de sortie");
                }
                else
                {
                    mCurPinUnderTest = 1;
                    mTestOutputConnectorHandle->SetSinglePin(mCurPinUnderTest);
                    //OK
                }

                mCableTestGPTimer.start();
                mCableTestSMState = CABLE_AUTO_TEST_PINS_STATE;
            }
            break;
        }//case CABLE_AUTO_TEST_SELF_TEST_STATE

        case CABLE_AUTO_TEST_PINS_STATE:
        {
            switch(Event)
            {
                case CABLE_TEST_TICK_SM_EVENT:
                {
                    if(mCableTestGPTimer.elapsed() < mPinHoldTime)
                    {
                        break;
                    }
                    else
                    {
                        QBitArray Out = mTestOutputConnectorHandle->GetOutputPinsStates();
                        QBitArray In = mTestInputConnectorHandle->GetInputPinsStates();

                        //Analyse the inputs buffer...

                        if(In.count(true) != 1)    //check if only 1 input pin is active
                        {
                            //TODO: Manage this failure mode

                            if(In.count(true) == 0) //Check if no input pin is active
                            {
                                qDebug("Échec du test du contact %d : aucune pin activée en entrée",mCurPinUnderTest);
                            }
                            else    //If here, many input pins are active...
                            {
                                qDebug("Échec du test du contact %d : plusieurs (%d) pins activées en entrée",mCurPinUnderTest,In.count(true));
                            }
                        }
                        else if(In.at(mCurPinUnderTest-1) == false)
                        {
                            //TODO: Manage this failure mode
                            //the output pin isn't set...
                            qDebug("Échec du test du contact %d: mauvais contact activé en entrée",mCurPinUnderTest);
                        }
                        else
                        {
                            //Pin test passed.  Test the next one
                            qDebug("Succès du test du contact %d", mCurPinUnderTest);
                        }
                        mCurPinUnderTest++;
                        if(mCurPinUnderTest > (mTestOutputConnectorHandle->GetPinCount()))
                        {
                            //Test finished.
                            mCableTestSMState = CABLE_AUTO_TEST_END_TEST_STATE;
                        }
                        else
                        {
                            mTestOutputConnectorHandle->SetSinglePin(mCurPinUnderTest);
                            mCableTestGPTimer.start();
                        }

                    }
                    break;
                }
                case CABLE_TEST_PAUSE_AUTO_TEST_SM_EVENT:
                {
                    mCableTestSMState = CABLE_AUTO_TEST_PAUSE_STATE;
                    mProgramHandle->CableEngineModeChanged(GetTestEngineCurrentMode());
                    qDebug("Test mis en pause...");
                    break;
                }
                case CABLE_TEST_CANCEL_AUTO_TEST_SM_EVENT:
                {
                    mCableTestSMState = CABLE_AUTO_TEST_END_TEST_STATE;
                    qDebug("Test annulé...");
                    break;
                }
                default:
                {
                    break;
                }

            }

            break;
        }//case CABLE_AUTO_TEST_PINS_STATE:

        case CABLE_AUTO_TEST_PAUSE_STATE:
        {
            switch(Event)
            {
                case CABLE_TEST_RESUME_AUTO_TEST_SM_EVENT:
                {
                    mCableTestSMState = CABLE_AUTO_TEST_PINS_STATE;
                    mProgramHandle->CableEngineModeChanged(GetTestEngineCurrentMode());
                    qDebug("Test redémarré...");
                    break;
                }
                case CABLE_TEST_CANCEL_AUTO_TEST_SM_EVENT:
                {
                    mCableTestSMState = CABLE_AUTO_TEST_END_TEST_STATE;
                    qDebug("Test annulé...");
                    break;
                }
                default:
                {
                    break;
                }
            }

            break;
        }//case CABLE_AUTO_TEST_PAUSE_STATE

        case CABLE_AUTO_TEST_END_TEST_STATE:
        {
            qDebug("Test automatique terminé...");
            mTestOutputConnectorHandle->ClearAllPins();
            mCableTestSMState = CABLE_TEST_STBY_STATE;
            mProgramHandle->CableEngineModeChanged(GetTestEngineCurrentMode());
            break;
        }//case CABLE_TEST_END_TEST_STATE

        case CABLE_TEST_START_MANUAL_TEST_STATE:
        {
            mTestOutputConnectorHandle->ClearAllPins();
            qDebug("Entrée en mode test manuel");
            mCableTestSMState = CABLE_MANUAL_TEST_PINS_STATE;
            mProgramHandle->CableEngineModeChanged(GetTestEngineCurrentMode());
            break;
        }//CABLE_TEST_START_MANUAL_TEST_STATE

        case CABLE_MANUAL_TEST_PINS_STATE:
        {
            switch(Event)
            {
                case CABLE_TEST_EXIT_MANUAL_TEST_SM_EVENT:
                {
                    mCableTestSMState = CABLE_MANUAL_TEST_END_TEST_STATE;
                    break;
                }
                default:
                {
                    break;
                }
            }

            break;
        }//CABLE_MANUAL_TEST_PINS_STATE

        case CABLE_MANUAL_TEST_END_TEST_STATE:
        {
            mTestOutputConnectorHandle->ClearAllPins();
            mCableTestSMState = CABLE_TEST_STBY_STATE;
            mProgramHandle->CableEngineModeChanged(GetTestEngineCurrentMode());
            break;
        }
    }
}

void CCableTestEngine::SMTimerExpired()
{
    //TODO: manage the end of the test
    CableTestEngineStateMachine(CABLE_TEST_TICK_SM_EVENT);

}

int CCableTestEngine::StartAutomatedTest()
{
    if(mCableTestSMState != CABLE_TEST_STBY_STATE)
    {
        return RET_ERROR;
    }

    CableTestEngineStateMachine(CABLE_TEST_START_AUTO_TEST_SM_EVENT);

    return RET_OK;
}

int CCableTestEngine::PauseAutomatedTest()
{
    CableTestEngineStateMachine(CABLE_TEST_PAUSE_AUTO_TEST_SM_EVENT);

    return RET_OK;
}

int CCableTestEngine::ResumeAutomatedTest()
{
    CableTestEngineStateMachine(CABLE_TEST_RESUME_AUTO_TEST_SM_EVENT);

    return RET_OK;
}

int CCableTestEngine::StopAutomatedTest()
{
    CableTestEngineStateMachine(CABLE_TEST_CANCEL_AUTO_TEST_SM_EVENT);
    return RET_OK;
}

int CCableTestEngine::StartManualTest()
{
    CableTestEngineStateMachine(CABLE_TEST_START_MANUAL_TEST_SM_EVENT);
    return RET_OK;
}

int CCableTestEngine::StopManualTest()
{
    CableTestEngineStateMachine(CABLE_TEST_EXIT_MANUAL_TEST_SM_EVENT);
    return RET_OK;
}

CCableTestEngine::eCableTestEngineMode CCableTestEngine::GetTestEngineCurrentMode()
{
    switch(mCableTestSMState)
    {
        case CABLE_TEST_INIT_STATE:
        case CABLE_TEST_STBY_STATE:
        case CABLE_AUTO_TEST_END_TEST_STATE:
        case CABLE_MANUAL_TEST_END_TEST_STATE:
        {
            return CABLE_TEST_STBY_MODE;
            break;
        }
        case CABLE_TEST_START_AUTOMATED_TEST_STATE:
        case CABLE_AUTO_TEST_SELF_TEST_STATE:
        case CABLE_AUTO_TEST_PINS_STATE:
        {
            return CABLE_AUTO_TEST_RUNNING_MODE;
            break;
        }
        case CABLE_AUTO_TEST_PAUSE_STATE:
        {
            return CABLE_AUTO_TEST_PAUSED_MODE;
            break;
        }
        case CABLE_TEST_START_MANUAL_TEST_STATE:
        case CABLE_MANUAL_TEST_PINS_STATE:
        default:
        {
            return CABLE_TEST_MANUAL_MODE;
            break;
        }

    }
}

int CCableTestEngine::ManualPinToggle(int ConnectorPinNbr)
{
    if(GetTestEngineCurrentMode() == CABLE_TEST_MANUAL_MODE)
    {
        return mTestOutputConnectorHandle->TogglePin(ConnectorPinNbr);
    }

    return RET_ERROR;
}