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

#define encForward_PIN    5
#define encBackward_PIN   6

#define LoopOut 12
#define ISR_Out 10

#define TestOut 13

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

#define INFO "IR_FOX TEST"
#define SERIAL_SPEED 115200

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

IR_Decoder decForward(2, 555);
IR_Decoder decBackward(3, 777);

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

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

void decForwardISR() {
    decForward.isr();
}

// void decBackwardISR() {
//     decBackward.isr();
// }

static uint8_t* portOut;
ISR(TIMER2_COMPA_vect) {
    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
            );
}
/////////////////////////////////////////////////////////////////////
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(13);
});
/////////////////////////////////////////////////////////////////////
void setup() {
    IR_Encoder::timerSetup();
    portOut = &PORTD;

    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(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(13, OUTPUT);



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


    attachInterrupt(0, decForwardISR, CHANGE);  // D2 
    // attachInterrupt(1, 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;
        }
    }
}






//test
void status(IR_Decoder& dec) {
    if (dec.gotData.available()) {
        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()) {
        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()) {
        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()) {
        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());
    }


}