#include "termIn.h"

#define DIN_BUTTON 0
#define DIN_TERMINALLOOP 1
#define DIN_GATELOOP 2
#define DOUT_RELAY4 3
#define DOUT_RELAY1 0

#ifdef __cplusplus
extern "C"
{
#endif

#include <pixtend.h>

#ifdef __cplusplus
}
#endif

termIn::termIn()
{
    //ctor
    //TODO set by args
    setDisplayButtonPress=false;
    buttonWasPressed=false;
    displayOff=false;
}

termIn::~termIn()
{
    //dtor
}

void termIn::cardPresent(mutekDispenser* d){
    try
    {
        d->statusCheck();
        egateTimer::esleep(10000);
    }
    catch(std::exception &e)
    {
        std::cout<<"Exception in cardPresent:"<<e.what()<< std::endl;
    }
}

void termIn::maintainButtonPressed(){
    int dinVal=0;
    int doutVal=0;
    int bitPosition=0;

    Spi_Setup(0);

    while(1==1){
        dinVal= Spi_Get_Din();
        // if pressed button
        if ((dinVal & (1 << bitPosition)) >> bitPosition == 1)
        {
            doutVal = Spi_Get_Relays();
            if ((doutVal & (1 << 3))>>3 ==0)
                Spi_Set_Relays(doutVal+8);
        }
    }
}

void termIn::runTerminalLoop(){

    int dinVal=0;

    //beforeRfidReadTime = std::chrono::high_resolution_clock::now();

    // std::string rezTest=dal.hasReaderLogSince(1,100000);

    //std::thread thread1;

    //while(1==1)
    //{
        try
        {
            dinVal = Spi_Get_Din();

            // Terminal Loop Active (loop at gate)
            if ((dinVal & (1<< DIN_TERMINALLOOP))>> DIN_TERMINALLOOP == 1)
            {
                displayOff=false;
                if (!dispenser.stateAcceptCardIn)
                {
                    beforeRfidReadTime = std::chrono::high_resolution_clock::now();
                    dispenser.cardInEnable();
                }

                //TODO: Display command press button
                if (setDisplayButtonPress==false)
                {
                    display.displayLines("PRESS THE BUTTON ","PRITISNITE DUGME", 250, terminalId);
                    setDisplayButtonPress=true;
                }

                //create new thread and check for card present for prepaid
                if (atTerminalLoopCounter%100==0)
                    dispenser.statusCheck(); // for now don't use threading
                    //thread1=std::thread(termIn::cardPresent, &dispenser);

                if (dispenser.sensorRead && dispenser.deconstructStatusOk)
                {
                    //TOOD: entrance for prepaid
                    display.displayLines("PREPAID CARD CHECK","PROVJERA KARTICE", 250, terminalId);

                    issueNewPrepaidTicket();

                    setDisplayButtonPress=false;
                    buttonWasPressed=false;
                    beforeRfidReadTime = std::chrono::high_resolution_clock::now();
                    dispenser.statusCheck();
                    //atTerminalLoopCounter=0;
                }

                //Button is pressed
                if (((dinVal & (1<< DIN_BUTTON))>> DIN_BUTTON == 1) || buttonWasPressed)
                {
                    // Finish t1 thread checking already accepted Prepaid potential
                    if (thread1.joinable())
                        thread1.join();

                    if (!dispenser.sensorRead)
                    {
                        issueNewTicket();

                        setDisplayButtonPress=false;
                        buttonWasPressed=false;
                        dispenser.deconstructStatusOk = false;
                        //atTerminalLoopCounter=0;
                        dinVal=0;
                    }
                }

                if (thread1.joinable())
                    thread1.join();

                if (atTerminalLoopCounter>1000000)
                    atTerminalLoopCounter=0;
                else
                    atTerminalLoopCounter++;

                displayOff=false;
            }
            else
            {
                if (dispenser.stateAcceptCardIn)
                {
                    dispenser.statusCheck();
                    if (dispenser.stateAcceptCardIn)
                        dispenser.cardInDisable();
                }

                if (!displayOff)
                {
                    display.displayLines("","",0,terminalId);
                    egateTimer::esleep(100000);
                    displayOff=true;
                }

                if (setDisplayButtonPress)
                    setDisplayButtonPress=false;
            }

            egateTimer::esleep(10000);
        }
        catch(std::exception &ex)
        {
            std::cout<<"Main loop error: ";
            std::cout<<ex.what()<<std::endl;
        }

    //}// while

    //t1.join();
}

void termIn::issueNewPrepaidTicket()
{
    afterRfidReadTime =  std::chrono::high_resolution_clock::now();
    std::string rfidReadout;

    rfidReadout = getPrepaidRfidReadout();

    if (isNumeric(rfidReadout))
    {
        if (dal.createTicket(rfidReadout, terminalId))
        {
            display.displayLines("PREPAID VALID","KARTICA VALIDNA",250, terminalId);
            dispenseTicketWithEntrence();
            std::cout<<"Created new Ticket "<<std::endl;

            return;
        }
    }

    std::cout<<"Error on prepaidread ... dispanse back ..."<<std::endl;
    std::cout<<"Ticket was not created"<<std::endl;
    // TODO ? Probably read ID was not a ticket
    display.displayLines("INVALID CARD","NEISPRAVNA KARTICA",250, terminalId);

    dispenseTicketWithNoEntrence();
}

void termIn::issueNewTicket(){
    beforeRfidReadTime = std::chrono::high_resolution_clock::now();
    afterRfidReadTime =  std::chrono::high_resolution_clock::now();
    std::string rfidReadout="";

    display.displayLines("CREATING NEW TICKET", "KREIRAM NOVI TIKET", 250, terminalId);
    for (int i=0; i<50; i++)
    {
        dispenser.statusCheck();
        if (dispenser.deconstructStatusOk)
            i=50;
        else
        {
            std::cout<<"deconstructStatusOk was false, looping for status ..."<<std::endl<<std::flush;
            if (i>0)
                egateTimer::esleep(200000);
            else
                egateTimer::esleep(100000);
        }
    }

    if (dispenser.statusDispenseReady)
    {
        // save time before dispenser sends card to read position
        beforeRfidReadTime = std::chrono::high_resolution_clock::now();
        dispenser.dispenseToRead(true);

        for (int i=0; i<10; i++)
        {
            dispenser.statusCheck();
            if (dispenser.deconstructStatusOk && dispenser.sensorRead)
                i=10;
            else
            {
                if(!dispenser.deconstructStatusOk)
                    std::cout<<"DispenseToRead unseccessfull, running once more"<<std::endl<<std::flush;

                rfidReadout = getRfidReadout();
            }
            if (rfidReadout!="")
            {
                std::cout<<"Ticket read fetched => skipping read sensor status..."<<std::endl<<std::flush;
                i=10;
            }else
                egateTimer::esleep(100000);
        }

        if(rfidReadout=="")
            rfidReadout = getRfidReadout();

        if (dal.createTicket(rfidReadout, terminalId))
        {
            std::cout<<"Created new Ticket "<<std::endl<<std::flush;
            dispenseTicketWithEntrence();
        }
        else
        {
            std::cout<<"Ticket was not created"<<std::endl;
            dal.displayEventLog("Neuspio pokušaj kreiranja tiketa na terminalu "+std::to_string(terminalId)
                ,3
                ,"Ticket was not created. Dal.createTicket call returned false.");
            dispenser.collect();
            display.displayLines("Card error","Greska na kartici",250, terminalId);
            egateTimer::esleep(1000000);
            display.displayLines("Try again","Probajte ponovno",250, terminalId);
            egateTimer::esleep(1000000);
            dispenser.statusCheck();
        }
    }
    else
    {
        //TODO: Throw error and log ...
        std::cout<<"IssueNewTicket StatusDispense error, statusDispenseReady was false."<<std::flush;
            dal.displayEventLog("Neuspio pokušaj kreiranja tiketa na terminalu "+std::to_string(terminalId)
            ,3
            ,"Ticket was not created. Dispenser.statusDispenseReady call returned false.");
            display.displayLines("Card error","Greska na kartici",250, terminalId);
            dispenser.reset();
            egateTimer::esleep(2000000);
            dispenser.statusCheck();
    }
}


std::string termIn::getPrepaidRfidReadout()
{
    std::chrono::high_resolution_clock::time_point waitPoint;

    waitPoint = std::chrono::high_resolution_clock::now();
    afterRfidReadTime = std::chrono::high_resolution_clock::now();

    std::chrono::duration<double> passed = std::chrono::duration_cast<std::chrono::duration<double>>(afterRfidReadTime - beforeRfidReadTime);
    std::chrono::duration<double> passedWait = std::chrono::duration_cast<std::chrono::duration<double>>(afterRfidReadTime - waitPoint);
    std::string hasRfidRead;
    int passedCount=0;
    int passedWaitCount=0;
    //get rfid readout
    try
    {
        while (hasRfidRead=="" && passedWaitCount < 3000) // TODO: Or time passed is over a minute throw error
        {
            if (hasRfidRead=="")
            {
                egateTimer::esleep(200000);
                afterRfidReadTime = std::chrono::high_resolution_clock::now();
                passed = std::chrono::duration_cast<std::chrono::duration<double>>(afterRfidReadTime - beforeRfidReadTime);
                passedWait = std::chrono::duration_cast<std::chrono::duration<double>>(afterRfidReadTime - waitPoint);

                passedCount=(int)(passed.count()*1000);
                passedWaitCount=(int)(passedWait.count()*1000);


                hasRfidRead = dal.hasPrepaidReaderLogSince(terminalId, passedCount);
            }
        }
    }
    catch(std::exception &e)
    {
        //TODO: Report error
        std::cout<<e.what()<<std::endl;
        hasRfidRead="Error:Cannot read card    Neispravna kartica  ";
    }

    return hasRfidRead;
}

std::string termIn::getRfidReadout()
{
    std::chrono::high_resolution_clock::time_point waitPoint;

    waitPoint = std::chrono::high_resolution_clock::now();

    std::chrono::duration<double> passed = std::chrono::duration_cast<std::chrono::duration<double>>(afterRfidReadTime - beforeRfidReadTime);
    std::chrono::duration<double> passedWait = std::chrono::duration_cast<std::chrono::duration<double>>(afterRfidReadTime - waitPoint);
    std::string hasRfidRead="";
    int passedCount=0;
    int passedWaitCount=0;
    //get rfid readout
    try
    {
        while (hasRfidRead=="" && passedWaitCount < 3000) // TODO: Or time passed is over a minute throw error
        {
            if (hasRfidRead=="")
            {
                egateTimer::esleep(200000);
                afterRfidReadTime = std::chrono::high_resolution_clock::now();
                passed = std::chrono::duration_cast<std::chrono::duration<double>>(afterRfidReadTime - beforeRfidReadTime);
                passedWait = std::chrono::duration_cast<std::chrono::duration<double>>(afterRfidReadTime - waitPoint);

                passedCount=(int)(passed.count()*1000);
                passedWaitCount=(int)(passedWait.count()*1000);

                hasRfidRead = dal.hasReaderLogSince(terminalId, passedCount);
            }
        }
    }
    catch(std::exception &e)
    {
        std::cout<<e.what()<<std::endl;
    }

    return hasRfidRead;
}

void termIn::dispenseTicketWithEntrence(){
    bool cardTaken=false;
    int counter=0;
    int dinVal=0;

    for(int i=0; i<30; i++)
    {
        dispenser.statusCheck(); // check for sensors that ticket is in read possition

        if (dispenser.deconstructStatusOk && dispenser.sensorRead && dispenser.sensorReadFront)
        {
            i=100;
        }
        else
        {
            std::cout<<"False ons sensor read, readFront or deconstructStatus, looping again for new status ..."<<std::flush;
            egateTimer::esleep(100000);
        }
    }

    if (dispenser.sensorRead && dispenser.sensorReadFront)
    {
        //TODO read ticket
        //TODO create new ticket in db
        display.displayLines("PLEASE TAKE TICKET","UZMITE TIKET",250,terminalId);
        dispenser.cardInDisable();
        dispenser.dispenseToFront();

        // wait for front sensor
        for(int i=0;i<10;i++)
        {
            egateTimer::esleep(30000); // wait for machine to push ticket to outside/
            dispenser.statusCheck(); // check for sensors that ticket is in read possition

            if (dispenser.sensorFront)
            {
                i=10;
                std::cout<<"SensorFront True -> Take Ticket"<<std::endl<<std::flush;
            }
            else
            {
                if (!dispenser.deconstructStatusOk )
                {
                    std::cout<<"deconstructStatusOk was false, looping again for sensorFront ..."<<std::flush;
                    egateTimer::esleep(70000); // wait for machine to push ticket to outside/
                }
            }

            if (!dispenser.sensorFront && dispenser.deconstructStatusOk && dispenser.statusDispenseReady)
            {
                std::cout<<"deconstructStatusOk and statusDispenseReady, ticket already taken..."<<std::flush;
                i = 10;
            }
        }

        if(dispenser.sensorFront)
        {
            counter=0;

            while(dispenser.sensorFront && counter<200)
            {
                dinVal = Spi_Get_Din();
                egateTimer::esleep(200000); // wait for machine to push ticket to outside
                dispenser.statusCheck();
                counter++;

                if ((dinVal & (1<< DIN_TERMINALLOOP))>> DIN_TERMINALLOOP == 0)
                    counter=200;

                if (!dispenser.deconstructStatusOk)
                {
                    std::cout<<"deconstructStatusOk was false waitng 100ms..."<<std::flush;
                    egateTimer::esleep(100000); // wait for machine to push ticket to outside
                }
                else
                    std::cout<<"Wating SensorFront false to taken ticket"<<std::endl<<std::flush;
            }

            if (dispenser.sensorFront)
            {
                display.displayLines("Ticket canceled","Tiket otkazan",250, terminalId);
                dispenser.collect();
                dal.displayEventLog("Povucena kartica na terminalu "+std::to_string(terminalId),2,"");
                dal.cancelLastTicket(terminalId);
                return;
            }
        }

        std::cout<<"Ticket TAKEN OPEN GATE !!!"<<std::endl<<std::flush;
        raiseGateAndWaitForEntrence();
        //display.displayLines("Welcome","Dobrodosli",250,terminalId);

        if (dispenser.sensorCardPreEmpty)
            dal.displayEventLog("Nedostaje kartica na terminalu "+std::to_string(terminalId),2,"");
    }
    else
    {
        //TODO Handle error
        std::cout<<"Error in dispenser sensorRead and sensorReadFront, read unsecussfull"<<std::flush;
        display.displayLines("Ticket canceled","Tiket otkazan",250, terminalId);
        dal.displayEventLog("Greska izbacivanja kartice na terminalu "+std::to_string(terminalId),3,"");
        dispenser.reset();
    }
}

void termIn::dispenseTicketWithNoEntrence(){
// NO ENTERRENCE !!!
    int dinVal=0;
    int counter=0;

    for(int i=0; i<100; i++)
    {
        dispenser.statusCheck(); // check for sensors that ticket is in read possition

        if (dispenser.deconstructStatusOk && dispenser.sensorRead && dispenser.sensorReadFront)
        {
            i=100;
        }
        else
        {
            std::cout<<"False on sensor read, readFront or deconstructStatus, looping again for new status ..."<<std::flush;
            egateTimer::esleep(100000);
        }
    }

    if (dispenser.sensorRead && dispenser.sensorReadFront)
    {
        //TODO read ticket
        //TODO create new ticket in db
        dispenser.dispenseToFront();

        // wait for front sensor
        for(int i=0;i<10;i++)
        {
            egateTimer::esleep(10000); // wait for machine to push ticket to outside/
            dispenser.statusCheck(); // check for sensors that ticket is in read possition

            if (dispenser.sensorFront)
                i=10;
            else
            {
                std::cout<<"deconstructStatusOk was false, looping again for sensorFront ..."<<std::flush;
            }
        }

        if(dispenser.sensorFront)
        {
            display.displayLines("Please take card","Uzmite karticu",250,terminalId);
            while(dispenser.sensorFront && counter<100)
            {
                dinVal = Spi_Get_Din();
                egateTimer::esleep(200000); // wait for machine to push ticket to outside
                dispenser.statusCheck();

                if ((dinVal & (1<< DIN_TERMINALLOOP))>> DIN_TERMINALLOOP == 0)
                    counter=200;

                counter++;
            }

            if (dispenser.sensorFront)
            {
                display.displayLines("Invalid card taken","Kartica povucena",250, terminalId);
                dispenser.collect();
                dal.displayEventLog("Povucena neispravna pretplatnicka kartica na terminalu "+std::to_string(terminalId),2,"");
                egateTimer::esleep(2000000); // wait for machine to push ticket to outside
            }

            //display.displayLines("","",0,terminalId);
            //egateTimer::esleep(100000); // wait for machine to push ticket to outside
            //display.displayLines("","",0,terminalId);
        }
    }
    else
    {
        //TODO Handle error
        std::cout<<"Error in dispenser sensorRead and sensorReadFront, read unsecussfull on invalid card"<<std::flush;
        display.displayLines("Ticket canceled","Tiket otkazan",250, terminalId);
        dal.displayEventLog("Greska izbacivanja nevalidne kartice na terminalu "+std::to_string(terminalId),3,"");
        dispenser.reset();
    }
}

void termIn::raiseGateAndWaitForEntrence()
{
    std::chrono::high_resolution_clock::time_point waitPoint;
    std::chrono::high_resolution_clock::time_point checkPoint;

    waitPoint = std::chrono::high_resolution_clock::now();


    int counter=0;
    setRelayValue(DOUT_RELAY1, true);

    display.displayLines("Welcome","Dobrodosli",250,terminalId);

    checkPoint = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> passed = std::chrono::duration_cast<std::chrono::duration<double>>(checkPoint - waitPoint);

    if (abs((int)(passed.count()*10)) < 6)
    {
        int waitInt = 6 - abs((int)(passed.count()*10));
        egateTimer::esleep(waitInt * 100000);//egateTimer::esleep(500000);
        std::cout<<"Waiting additional decisec: "<<waitInt<<std::endl;
    }

    setRelayValue(DOUT_RELAY1, false);

    int dinVal = Spi_Get_Din();
    bool gateLoopPassed=false;
    bool gateLoopActivated=false;
    bool displaySet = false;

    // while no car over gate or 2 minutes passed
    while(!gateLoopPassed && counter<1000)
    {
        egateTimer::esleep(100000);
        dinVal = Spi_Get_Din();
        gateLoopActivated =  gateLoopActivated  || (((dinVal & (1<<DIN_GATELOOP))>>DIN_GATELOOP) == 1);

        if (gateLoopActivated)
        {
            if (!displaySet){
                display.displayLines("","",0,terminalId);
                displaySet=true;
                std::cout<<"Gate Loop Activated"<<std::endl;
            }
            gateLoopPassed = (((dinVal &(1<<DIN_GATELOOP))>>DIN_GATELOOP) == 0);
        }

        counter++;
    }

    if (gateLoopPassed)
        std::cout<<"Gate Loop passed"<<std::endl;
    else
        std::cout<<"!!!Gate Loop NOT passed"<<std::endl;
}

void termIn::setRelayValue(int relayIndex, bool turnOn)
{
    int doutVal = Spi_Get_Relays();
    int newVal=0;

    if(turnOn)
    {
        if ((doutVal & (1<< relayIndex))>>relayIndex == 0)
        {
            newVal=doutVal + (1<<relayIndex);
            Spi_Set_Relays(newVal);
        }
    }
    else
    {
        if ((doutVal & (1<< relayIndex))>>relayIndex == 1)
        {
            newVal=doutVal - (1<<relayIndex);
            Spi_Set_Relays(newVal);
        }
    }
}

void termIn::Test485()
{
    int readChar;
    int fd=serialOpen("/dev/ttyUSB0",9600);

    egateTimer::esleep(500000);
    //serialPutchar(fd, 'C');

    for (int i=0; i<100; i++)
    {
        while(serialDataAvail(fd))
        {
            egateTimer::esleep(30000);

            readChar=serialGetchar(fd);
            if (readChar!=-1)
            {
                std::cout<<readChar;
            }
        }
    }


    serialClose(fd);
}

void termIn::resetDispenser()
{
   /* dispenser.collect();

    dispenser.cardInEnable();

    dispenser.collect();

    dispenser.cardInDisable();*/

    dispenser.reset();
}

bool termIn::isNumeric(const std::string& s)
{
    std::string::const_iterator it=s.begin();

    while(it!=s.end() && std::isdigit(*it)) ++it;

    return !s.empty() && it == s.end();
}