#pragma once
#include "IR_DecoderRaw.h"
#include "PacketTypes.h"

class IR_Decoder : public IR_DecoderRaw {
public:
    IR_Decoder(const uint8_t isrPin, uint16_t addr, IR_Encoder* encPair = nullptr) : IR_DecoderRaw(isrPin, addr, encPair) {
    }

    Data gotData;

    void tick() {
        IR_DecoderRaw::tick();
        if (available()) {
            Serial.println("PARSING RAW DATA");

            switch (packInfo.buffer[0] >> 5 & IR_MASK_MSG_TYPE) {
                case IR_MSG_DATA_NOACCEPT:
                    gotData.set(&packInfo);
                    break;
                case IR_MSG_DATA_ACCEPT:
                    break;
                case IR_MSG_BACK:
                    break;
                case IR_MSG_BACK_TO:
                    break;
                case IR_MSG_REQUEST:
                    break;
                case IR_MSG_ACCEPT:
                    break;

                default:
                    break;
            }
        }
    }
};

//     class IDataPack : protected IR_FOX {
//         friend IR_Decoder;
//     public:
//         IDataPack(IR_Decoder* dec) : dec(dec) {};

//     public:
//         bool available() { if (isAvailable) { isAvailable = false; return true; } else { return isAvailable; }; };
//         virtual uint8_t getMsgInfo() { return msgPtr[0] & IR_MASK_MSG_INFO; };
//         virtual uint8_t getMsgType() { return (msgPtr[0] >> 5) & IR_MASK_MSG_TYPE; };
//         virtual uint8_t getMsgRAW() { return msgPtr[0]; };
//         virtual uint16_t getErrorCount() { return err.all(); };
//         virtual uint8_t getErrorLowSignal() { return err.lowSignal; };
//         virtual uint8_t getErrorHighSignal() { return err.highSignal; };
//         virtual uint8_t getErrorOther() { return err.other; };
//         // uint16_t getCrcIN() { return crcPtr[0] << 8 | crcPtr[1]; };
//         // uint16_t getCrcCALC() { return crcCalcVal; };
//         virtual uint16_t getTunerTime() { return bitPeriod; };
//         void resetAvailable() { isAvailable = false; };

//     protected:
//         inline static uint8_t data[dataByteSizeMax] { 0 };

//         inline static uint8_t* msgPtr;
//         inline static uint8_t* addrFromPtr;
//         inline static uint8_t* addrToPtr;
//         inline static uint8_t* dataPtr;
//         inline static uint8_t* crcPtr;

//         inline static ErrorsStruct err;
//         inline static uint8_t packRawSize;
//         inline static uint16_t bitPeriod;
//         inline static uint16_t crcCalcVal;

//         IR_Decoder* dec;
//         bool isAvailable = false;
//         virtual bool checkAddress(PackOutInfo* packInfo) {
//             bool ret;
//             uint8_t targetAddrOffset = packInfo->offsets.addrToOffset;
//             uint16_t address = (packInfo->ptr[targetAddrOffset] << 8) | (packInfo->ptr[targetAddrOffset + 1]);
//             checkaddressRuleApply(address, dec->id, ret);
//             return ret;
//         };
//         virtual void onPackAddressCorrect(PackOutInfo* packInfo) {
//             memset(IDataPack::data, 0, dataByteSizeMax);
//             memcpy(data, packInfo->ptr, min(packInfo->packSize, dataByteSizeMax));
//             err = packInfo->err;
//             bitPeriod = packInfo->rTime;
//             crcCalcVal = packInfo->crc;
//             packRawSize = packInfo->packSize;

//             msgPtr = (data + packInfo->offsets.msgOffset);
//             addrFromPtr = (data + packInfo->offsets.addrFromOffset);
//             addrToPtr = (data + packInfo->offsets.addrToOffset);
//             dataPtr = (data + packInfo->offsets.dataOffset);
//             crcPtr = (data + packInfo->offsets.crcOffset);
//         }

//         virtual void onPackAddressIncorrect(PackOutInfo* packInfo) {}
//         virtual void afterSet() {}

//         void set(PackOutInfo packInfo, bool isNeedAddressCheck) {
//             isAvailable = false;
//             if (!isNeedAddressCheck || checkAddress(&packInfo)) {
//                 onPackAddressCorrect(&packInfo);
//                 #ifdef IRDEBUG_INFO
//                 Serial.println(" OK ");
//                 #endif
//                 isAvailable = true;
//             } else {
//                 onPackAddressIncorrect(&packInfo);
//                 #ifdef IRDEBUG_INFO
//                 Serial.println(" NOT MY ");
//                 #endif
//             }
//             afterSet();
//         }
//     };

// public:
//     ///////////////////////////////////////////////////////////////////////////////////////////////////////////
//     class HasAddrFrom {
//     public:
//         virtual uint16_t getAddrFrom() { return  IDataPack::addrFromPtr[0] << 8 | IDataPack::addrFromPtr[1]; };
//     };

//     class HasAddrTo {
//     public:
//         virtual uint16_t getAddrTo() { return  IDataPack::addrToPtr[0] << 8 | IDataPack::addrToPtr[1]; };
//     };

//     class HasData {
//     public:
//         virtual uint8_t getDataSize() { return (uint8_t)(IDataPack::crcPtr - IDataPack::dataPtr); };
//         virtual uint8_t* getDataPrt() { return IDataPack::dataPtr; };
//         virtual uint8_t getDataRawSize() { return IDataPack::packRawSize; };
//         virtual uint8_t* getDataRawPtr() { return IDataPack::data; };
//     };
//     class IAcceptable {
//     public:
//         virtual bool isNeedAccept();
//     };
//     class AnyData : public IDataPack, public HasAddrFrom, public HasAddrTo, public HasData {
//         using IDataPack::IDataPack;
//     };
//     ///////////////////////////////////////////////////////////////////////////////////////////////////////////

//     class Data : public AnyData, public IAcceptable {
//         using AnyData::AnyData;
//     public:
//         bool isNeedAccept() override { return ((IDataPack::msgPtr[0] >> 5) & IR_MASK_MSG_TYPE) == IR_MSG_DATA_ACCEPT; };
//     private:
//         void afterSet() override {
//             if (Data::IDataPack::isAvailable && isNeedAccept()) {
//                 dec->addrWaitingSendgTo = getAddrFrom();
//                 dec->startWaitingSendToTime = millis();
//                 dec->isWaitingAcceptSend = true;
//                 Serial.print("\n Need to accept to ");
//                 Serial.println(dec->addrWaitingSendgTo);
//             }
//         }
//     };

//     class BackData : public AnyData {
//         using AnyData::AnyData;
//     public:
//         bool isAddressed() { return IDataPack::msgPtr[0] & 0b00010000; };
//         uint8_t getMsgInfo() { return IDataPack::msgPtr[0] & (IR_MASK_MSG_INFO >> 1); };
//         uint16_t getAddrTo() override {
//             if (isAddressed()) {
//                 return IDataPack::addrToPtr[0] << 8 | IDataPack::addrToPtr[1];
//             } else {
//                 return IR_Broadcast;
//             }
//         };
//     };

//     class Accept : public IDataPack, public HasAddrFrom {
//         using IDataPack::IDataPack;
//     public:

//     private:
//         bool checkAddress(PackOutInfo* packInfo) override {
//             bool ret;
//             uint8_t targetAddrOffset = packInfo->offsets.addrFromOffset;
//             uint16_t address = (packInfo->ptr[targetAddrOffset] << 8) | (packInfo->ptr[targetAddrOffset + 1]);
//             ret = address == dec->addrWaitingFrom;
//             return ret;
//         }
//     };

//     class Request : public IDataPack, public HasAddrFrom, public HasAddrTo {
//         using IDataPack::IDataPack;
//     public:

//     private:
//         // void afterSet() override {
//         //     if (isAvailable) {
//         //         dec->isWaitingAcceptSend = true;
//         //         dec->addrWaitingSendgTo = getAddrFrom();
//         //         Serial.print("\n Need to accept to ");
//         //         Serial.println(dec->addrWaitingSendgTo);
//         //     }
//         // }
//     };

//     class RawTune {
//         friend IR_Decoder;
//     public:
//         bool available() { return isAvailable; };
//         uint16_t getTunerTime() { return bitPeriod; };
//         void resetAvailable() { isAvailable = false; };
//     protected:
//         bool isAvailable;
//         uint16_t bitPeriod;

//         void set(uint16_t time) {
//             bitPeriod = time;
//             isAvailable = true;
//         }
//     };

//     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////