#include "IR_Decoder.h"
#include "IR_Encoder.h"
#include "TimerStatic.h"
#include "MemoryCheck.h"
/////////////// Pinout ///////////////

#define encForward_PIN PB5
#define encBackward_PIN PB4

#define dec1_PIN PB7
#define dec2_PIN PB8

#define LoopOut PB3
// #define ISR_Out 10

// #define TestOut 13

#define SignalDetectLed PB15

//////////////// Ini /////////////////

#define INFO "IR_FOX TEST"
#define SERIAL_SPEED 115200

//////////////// Var /////////////////

IR_Decoder decForward(PB7, 555);
IR_Decoder decBackward(PB8, 777);

IR_Encoder encForward(42 /* , &decBackward */);
// IR_Encoder encBackward(321, encBackward_PIN);
// IR_Encoder encTree(325, A2);

//////////////////////// Функции прерываний ////////////////////////

void decForwardISR()
{
    decForward.isr();
    // Serial.println("ISR");
}

void decBackwardISR()
{
    decBackward.isr();
    // Serial.println("ISR");
}

static uint8_t *portOut;

void EncoderISR()
{
    encForward.isr();
    // encBackward.isr();
    // encTree.isr();
    // TODO: Сделать выбор порта
    // *portOut = (*portOut & 0b11001111) |
    //     (
    //         encForward.ir_out_virtual << 5U
    //         // | encBackward.ir_out_virtual << 6U
    //         // | encTree.ir_out_virtual << 2U
    //         );
    digitalWrite(PB5, encForward.ir_out_virtual);
}
/////////////////////////////////////////////////////////////////////
uint8_t data0[] = {};
uint8_t data1[] = {42};
uint8_t data2[] = {42, 127};
uint8_t data3[] = {42, 127, 137};
uint8_t data4[] = {42, 127, 137, 255};

uint32_t loopTimer;
uint8_t sig = 0;

uint16_t targetAddr = IR_Broadcast;
Timer t1(500, millis, []()
         {
             // Serial.println(sig);

             switch (sig)
             {
             case 0:
                 encForward.sendData(targetAddr);
                 break;
             case 1:
                 encForward.sendData(targetAddr, data1, sizeof(data1));
                 break;
             case 2:
                 encForward.sendData(targetAddr, data2, sizeof(data2));
                 break;
             case 3:
                 encForward.sendData(targetAddr, data3, sizeof(data3));
                 break;
             case 4:
                 encForward.sendData(targetAddr, data4, sizeof(data4));
                 break;

             case 10:
                 encForward.sendData(targetAddr, data0, sizeof(data0), true);
                 break;
             case 11:
                 encForward.sendData(targetAddr, data1, sizeof(data1), true);
                 break;
             case 12:
                 encForward.sendData(targetAddr, data2, sizeof(data2), true);
                 break;
             case 13:
                 encForward.sendData(targetAddr, data3, sizeof(data3), true);
                 break;
             case 14:
                 encForward.sendData(targetAddr, data4, sizeof(data4), true);
                 break;

             case 20:
                 encForward.sendBack();
                 break;
             case 21:
                 encForward.sendBack(data1, sizeof(data1));
                 break;
             case 22:
                 encForward.sendBack(data2, sizeof(data2));
                 break;
             case 23:
                 encForward.sendBack(data3, sizeof(data3));
                 break;
             case 24:
                 encForward.sendBack(data4, sizeof(data4));
                 break;

             case 30:
                 encForward.sendBackTo(targetAddr);
                 break;
             case 31:
                 encForward.sendBackTo(targetAddr, data1, sizeof(data1));
                 break;
             case 32:
                 encForward.sendBackTo(targetAddr, data2, sizeof(data2));
                 break;
             case 33:
                 encForward.sendBackTo(targetAddr, data3, sizeof(data3));
                 break;
             case 34:
                 encForward.sendBackTo(targetAddr, data4, sizeof(data4));
                 break;

             case 41:
                 encForward.sendRequest(targetAddr);
                 break;
             case 42:
                 encForward.sendAccept(targetAddr);
                 break;

             default:
                 break;
             }
             // encBackward.sendData(IR_Broadcast, data2);
             // encTree.sendData(IR_Broadcast, rawData3);
         });
Timer t2(500, millis, []()
         { digitalToggle(LED_BUILTIN); });

Timer signalDetectTimer;
/////////////////////////////////////////////////////////////////////
void setup()
{
    // disableDebugPorts();

    Timer3.setPeriod(1000000U / carrierFrec / 2);
    // Timer3.attachCompare1Interrupt(EncoderISR);

    Timer1.setMode(1,timer_mode::TIMER_INPUT_CAPTURE);

    Serial.begin(SERIAL_SPEED);
    Serial.println(F(INFO));

    // pinMode(A0, INPUT_PULLUP);
    // pinMode(A1, INPUT_PULLUP);
    // pinMode(A2, INPUT_PULLUP);
    // pinMode(A3, INPUT_PULLUP);

    pinMode(LoopOut, OUTPUT);
    pinMode(SignalDetectLed, OUTPUT);
    // pinMode(ISR_Out, OUTPUT);

    pinMode(2, INPUT_PULLUP);
    pinMode(3, INPUT_PULLUP);

    // pinMode(8, OUTPUT);
    // pinMode(9, OUTPUT);
    // pinMode(11, OUTPUT);
    // pinMode(13, OUTPUT);
    pinMode(encForward_PIN, OUTPUT);
    pinMode(encBackward_PIN, OUTPUT);
    pinMode(LED_BUILTIN, OUTPUT);

    // IR_DecoderRaw* blindFromForward [] { &decForward, &decBackward };
    // encForward.setBlindDecoders(blindFromForward, sizeof(blindFromForward) / sizeof(IR_DecoderRaw*));

    attachInterrupt(dec1_PIN, decForwardISR, CHANGE); // D2
    // attachInterrupt(dec2_PIN, decBackwardISR, CHANGE); // D3
}

void loop()
{
    digitalToggle(LoopOut);
    Timer::tick();

    decForward.tick();
    decBackward.tick();

    status(decForward);
    // status(decBackward);

    // Serial.println(micros() - loopTimer);
    // loopTimer = micros();
    // delayMicroseconds(120*5);

    if (Serial.available())
    {
        uint8_t in = Serial.parseInt();
        switch (in)
        {
        case 100:
            targetAddr = IR_Broadcast;
            break;
        case 101:
            targetAddr = 555;
            break;
        case 102:
            targetAddr = 777;
            break;

        default:
            sig = in;
            break;
        }
    }
}

void detectSignal()
{
    digitalWrite(SignalDetectLed, HIGH);
    signalDetectTimer.delay(50, millis, []()
                            { digitalWrite(SignalDetectLed, LOW); });
}

// test
void status(IR_Decoder &dec)
{
    if (dec.gotData.available())
    {
        detectSignal();
        String str;
        if (/* dec.gotData.getDataPrt()[1] */ 1)
        {
            str += ("Data on pin ");
            str += (dec.isrPin);
            str += "\n";

            uint8_t msg = dec.gotData.getMsgRAW();
            str += ("  MSG: ");
            for (size_t i = 0; i < 8; i++)
            {
                if (i == 3)
                    str += " ";
                str += (msg >> (7 - i)) & 1U;
            }

            str += "\n";

            str += ("  DATA SIZE: ");
            str += (dec.gotData.getDataSize());
            str += "\n";
            str += ("  ADDRESS FROM: ");
            str += (dec.gotData.getAddrFrom());
            str += "\n";
            str += ("  ADDRESS TO: ");
            str += (dec.gotData.getAddrTo());
            str += "\n";
            // str += ("  CRC PACK: "); str += (dec.gotData.getCrcIN()); str += "\n";
            // str += ("  CRC CALC: "); str += (dec.gotData.getCrcCALC()); str += "\n";
            str += "\n";

            for (size_t i = 0; i < min(10, dec.gotData.getDataSize()); i++)
            {
                switch (i)
                {
                    // case 0:
                    //     str += ("  ADDR: ");
                    //     break;
                    // case 1:
                    //     str += ("  CMD: ");
                    //     break;

                default:
                    str += ("  Data[");
                    str += (i);
                    str += ("]: ");
                    break;
                }
                str += (dec.gotData.getDataPrt()[i]);
                str += "\n";
            }

            str += ("\n*******ErrAll: ");
            str += (dec.gotData.getErrorCount());
            str += "\n";
            str += ("**ErrDistance: ");
            str += ((int)(dec.gotData.getErrorHighSignal() - dec.gotData.getErrorLowSignal()));
            str += "\n";

            str += "\n";
        }
        else
        {
            str += ("SELF");
            str += "\n";
            str += "\n";
        }
        // obj->resetAvailable();
        Serial.write(str.c_str());
    }

    if (dec.gotBackData.available())
    {
        detectSignal();
        String str;
        if (/* dec.gotData.getDataPrt()[1] */ 1)
        {
            str += ("BackData on pin ");
            str += (dec.isrPin);
            str += "\n";

            uint8_t msg = dec.gotBackData.getMsgRAW();
            str += ("  MSG: ");
            for (size_t i = 0; i < 8; i++)
            {
                if (i == 3)
                    str += " ";
                str += (msg >> (7 - i)) & 1U;
            }

            str += "\n";

            str += ("  DATA SIZE: ");
            str += (dec.gotBackData.getDataSize());
            str += "\n";
            str += ("  ADDRESS FROM: ");
            str += (dec.gotBackData.getAddrFrom());
            str += "\n";
            // str += ("  ADDRESS TO: "); str += (dec.gotBackData.getAddrTo()); str += "\n";
            // str += ("  CRC PACK: "); str += (dec.gotBackData.getCrcIN()); str += "\n";
            // str += ("  CRC CALC: "); str += (dec.gotBackData.getCrcCALC()); str += "\n";
            str += "\n";

            for (size_t i = 0; i < min(10, dec.gotBackData.getDataSize()); i++)
            {
                switch (i)
                {
                    // case 0:
                    //     str += ("  ADDR: ");
                    //     break;
                    // case 1:
                    //     str += ("  CMD: ");
                    //     break;

                default:
                    str += ("  Data[");
                    str += (i);
                    str += ("]: ");
                    break;
                }
                str += (dec.gotBackData.getDataPrt()[i]);
                str += "\n";
            }

            str += ("\n*******ErrAll: ");
            str += (dec.gotBackData.getErrorCount());
            str += "\n";
            str += ("**ErrDistance: ");
            str += ((int)(dec.gotBackData.getErrorHighSignal() - dec.gotBackData.getErrorLowSignal()));
            str += "\n";

            str += "\n";
        }
        else
        {
            str += ("SELF");
            str += "\n";
            str += "\n";
        }
        // obj->resetAvailable();
        Serial.write(str.c_str());
    }

    if (dec.gotAccept.available())
    {
        detectSignal();
        String str;
        if (/* dec.gotData.getDataPrt()[1] */ 1)
        {
            str += ("Accept on pin ");
            str += (dec.isrPin);
            str += "\n";

            uint8_t msg = dec.gotAccept.getMsgRAW();
            str += ("  MSG: ");
            for (size_t i = 0; i < 8; i++)
            {
                if (i == 3)
                    str += " ";
                str += (msg >> (7 - i)) & 1U;
            }

            str += "\n";

            // str += ("  DATA SIZE: "); str += (dec.gotAccept.getDataSize()); str += "\n";
            str += ("  ADDRESS FROM: ");
            str += (dec.gotAccept.getAddrFrom());
            str += "\n";
            // str += ("  ADDRESS TO: "); str += (dec.gotAccept.getAddrTo()); str += "\n";
            // str += ("  CRC PACK: "); str += (dec.gotAccept.getCrcIN()); str += "\n";
            // str += ("  CRC CALC: "); str += (dec.gotAccept.getCrcCALC()); str += "\n";
            str += "\n";

            str += ("  Data: ");
            str += (dec.gotAccept.getCustomByte());

            str += ("\n\n*******ErrAll: ");
            str += (dec.gotAccept.getErrorCount());
            str += "\n";
            str += ("**ErrDistance: ");
            str += ((int)(dec.gotAccept.getErrorHighSignal() - dec.gotAccept.getErrorLowSignal()));
            str += "\n";

            str += "\n";
        }
        else
        {
            str += ("SELF");
            str += "\n";
            str += "\n";
        }
        // obj->resetAvailable();
        Serial.write(str.c_str());
    }

    if (dec.gotRequest.available())
    {
        detectSignal();
        String str;
        if (/* dec.gotData.getDataPrt()[1] */ 1)
        {
            str += ("Request on pin ");
            str += (dec.isrPin);
            str += "\n";

            uint8_t msg = dec.gotRequest.getMsgRAW();
            str += ("  MSG: ");
            for (size_t i = 0; i < 8; i++)
            {
                if (i == 3)
                    str += " ";
                str += (msg >> (7 - i)) & 1U;
            }

            str += "\n";

            // str += ("  DATA SIZE: "); str += (dec.gotRequest.getDataSize()); str += "\n";
            str += ("  ADDRESS FROM: ");
            str += (dec.gotRequest.getAddrFrom());
            str += "\n";
            str += ("  ADDRESS TO: ");
            str += (dec.gotRequest.getAddrTo());
            str += "\n";
            // str += ("  CRC PACK: "); str += (dec.gotRequest.getCrcIN()); str += "\n";
            // str += ("  CRC CALC: "); str += (dec.gotRequest.getCrcCALC()); str += "\n";
            str += "\n";

            str += ("\n*******ErrAll: ");
            str += (dec.gotRequest.getErrorCount());
            str += "\n";
            str += ("**ErrDistance: ");
            str += ((int)(dec.gotRequest.getErrorHighSignal() - dec.gotRequest.getErrorLowSignal()));
            str += "\n";

            str += "\n";
        }
        else
        {
            str += ("SELF");
            str += "\n";
            str += "\n";
        }
        // obj->resetAvailable();
        Serial.write(str.c_str());
    }
}