#pragma once
#include "IR_config.h"

class IR_Decoder;
namespace PacketTypes {
    class BasePack {
        friend IR_Decoder;
    protected:
        bool isAvailable;
        bool isRawAvailable;
        bool isNeedAccept;

        uint8_t msgOffset;
        uint8_t addressFromOffset;
        uint8_t addressToOffset;
        uint8_t DataOffset;

        IR_FOX::PackInfo* packInfo;
        uint16_t id;

        virtual bool checkAddress();
        void set(IR_FOX::PackInfo* packInfo, uint16_t id) {
            this->packInfo = packInfo;
            this->id = id;

            if (isAvailable = checkAddress()) {
                isAvailable = true;
                isRawAvailable = true;
                Serial.print("  OK  ");
            } else {
                isRawAvailable = true;
                Serial.print("  NOT-OK  ");
            }
        }


        static uint16_t _getAddrFrom(BasePack* obj) {
            return (obj->packInfo->buffer[obj->addressFromOffset] << 8) | obj->packInfo->buffer[obj->addressFromOffset + 1];
        };
        static uint16_t _getAddrTo(BasePack* obj) {
            return (obj->packInfo->buffer[obj->addressToOffset] << 8) | obj->packInfo->buffer[obj->addressToOffset + 1];
        };

        static uint8_t _getDataSize(BasePack* obj) {
            return obj->packInfo->packSize - crcBytes - obj->DataOffset;
        };
        static uint8_t* _getDataPrt(BasePack* obj) {
            return obj->packInfo->buffer + obj->DataOffset;
        };
        static uint8_t _getDataRawSize(BasePack* obj) {
            return obj->packInfo->packSize;
        };

    public:
        bool available() { if (isAvailable) { isAvailable = false; isRawAvailable = false; return true; } else { return false; } };
        bool availableRaw() { if (isRawAvailable) { isRawAvailable = false; return true; } else { return false; } };
        uint8_t getMsgInfo() { return packInfo->buffer[0] & IR_MASK_MSG_INFO; };
        uint8_t getMsgType() { return (packInfo->buffer[0] >> 5) & IR_MASK_MSG_TYPE; };
        uint8_t getMsgRAW() { return packInfo->buffer[0]; };
        uint16_t getErrorCount() { return packInfo->err.all(); };
        uint8_t getErrorLowSignal() { return packInfo->err.lowSignal; };
        uint8_t getErrorHighSignal() { return packInfo->err.highSignal; };
        uint8_t getErrorOther() { return packInfo->err.other; };
        uint16_t getTunerTime() { return packInfo->rTime; };
        uint8_t* getDataRawPtr() { return packInfo->buffer; };
    };


    class Data : public BasePack {
    public:
        Data() {
            msgOffset = 0;
            addressFromOffset = 1;
            addressToOffset = 3;
            DataOffset = 5;
        }

        uint16_t getAddrFrom() { return  _getAddrFrom(this); };
        uint16_t getAddrTo() { return _getAddrTo(this); };

        uint8_t getDataSize() { return _getDataSize(this); };
        uint8_t* getDataPrt() { return _getDataPrt(this); };
        uint8_t getDataRawSize() { return _getDataRawSize(this); };

    private:
        bool checkAddress() override {
            bool ret;
            IR_FOX::checkaddressRuleApply(getAddrTo(), this->id, ret);
            return ret;
        }
    };

    class DataBack : public BasePack {
    public:
        DataBack() {
            msgOffset = 0;
            addressFromOffset = 1;
            addressToOffset = 3;
            DataOffset = 3;
        }

        uint16_t getAddrFrom() { return  _getAddrFrom(this); };
        uint16_t getAddrTo() { return _getAddrTo(this); };

        uint8_t getDataSize() { return _getDataSize(this); };
        uint8_t* getDataPrt() { return _getDataPrt(this); };
        uint8_t getDataRawSize() { return _getDataRawSize(this); };
    private:
        bool checkAddress() override {
            bool ret;
            if (getMsgType() == IR_MSG_BACK_TO) {
                DataOffset = 5;
                IR_FOX::checkaddressRuleApply((packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1], this->id, ret);
            } else {
                DataOffset = 3;
                ret = true;
            }
            return ret;
        }
    };

    class Accept : public BasePack {
    public:
        Accept() {
            msgOffset = 0;
            addressFromOffset = 1;
            DataOffset = 3;
        }

        uint16_t getAddrFrom() { return  _getAddrFrom(this); };
        uint8_t getCustomByte() { return packInfo->buffer[DataOffset]; };
    private:
        bool checkAddress() override { return true; }
    };

    class Request : public BasePack {
    public:
        Request() {
            msgOffset = 0;
            addressFromOffset = 1;
            addressToOffset = 3;
            DataOffset = 3;
        }

        uint16_t getAddrFrom() { return  _getAddrFrom(this); };
        uint16_t getAddrTo() { return _getAddrTo(this); };

    private:
        bool checkAddress() override {
            bool ret;
            IR_FOX::checkaddressRuleApply(getAddrTo(), this->id, ret);
            return ret;
        }
    };

}

// class IOffsets {
// protected:
//     uint8_t msgOffset;
//     uint8_t addressFromOffset;
//     uint8_t addressToOffset;
//     uint8_t DataOffset;
// };

// class IPackInfo {
// public:
//     IR_FOX::PackInfo* packInfo;
// };

// class IBaseEmptyPack : virtual public IOffsets, virtual public IPackInfo {
// };

// class IR_Decoder;
// class IEmptyPack : virtual protected IBaseEmptyPack, virtual public IR_FOX {
//     friend IR_Decoder;
//     bool isAvailable;
//     bool isRawAvailable;
//     bool isNeedAccept;

// protected:
//     uint16_t id;

//     virtual bool checkAddress() {};

//     virtual void set(IR_FOX::PackInfo* packInfo, uint16_t id, bool isNeedAccept = false) {
//         IBaseEmptyPack::IPackInfo::packInfo = packInfo;
//         this->id = id;
//         this->isNeedAccept = isNeedAccept;

//         if (isAvailable = checkAddress()) {
//             isAvailable = true;
//             isRawAvailable = true;
//             Serial.print("  OK  ");
//         } else {
//             isRawAvailable = true;
//             Serial.print("  NOT-OK  ");
//         }
//     }

// public:
//     virtual bool available() { if (isAvailable) { isAvailable = false; isRawAvailable = false; return true; } else { return false; } };
//     virtual bool availableRaw() { if (isRawAvailable) { isRawAvailable = false; return true; } else { return false; } };
//     virtual uint8_t getMsgInfo() { return packInfo->buffer[0] & IR_MASK_MSG_INFO; };
//     virtual uint8_t getMsgType() { return (packInfo->buffer[0] >> 5) & IR_MASK_MSG_TYPE; };
//     virtual uint8_t getMsgRAW() { return packInfo->buffer[0]; };
//     virtual uint16_t getErrorCount() { return packInfo->err.all(); };
//     virtual uint8_t getErrorLowSignal() { return packInfo->err.lowSignal; };
//     virtual uint8_t getErrorHighSignal() { return packInfo->err.highSignal; };
//     virtual uint8_t getErrorOther() { return packInfo->err.other; };
//     virtual uint16_t getTunerTime() { return packInfo->rTime; };
// };

// class IHasAddresFrom : virtual protected IBaseEmptyPack {
// public:
//     virtual uint16_t getAddrFrom() { return (packInfo->buffer[addressFromOffset] << 8) | packInfo->buffer[addressFromOffset + 1]; };
// };

// class IHasAddresTo : virtual protected IBaseEmptyPack {
// public:
//     virtual uint16_t getAddrTo() { return (packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1]; };
// };

// class IHasAddresData : virtual protected IBaseEmptyPack {
// public:
//     virtual uint8_t getDataSize() { return packInfo->packSize - crcBytes - DataOffset; }; 
//     virtual uint8_t* getDataPrt() { return packInfo->buffer + DataOffset; };
//     virtual uint8_t getDataRawSize() { return packInfo->packSize; };
//     virtual uint8_t* getDataRawPtr() { return packInfo->buffer; };
// };

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

// class Data :
//     virtual public IEmptyPack,
//     virtual public IHasAddresFrom,
//     virtual public IHasAddresTo,
//     virtual public IHasAddresData {
// public:
//     Data() {
//         msgOffset = 0;
//         addressFromOffset = 1;
//         addressToOffset = 3;
//         DataOffset = 5;
//     }
// protected:
//     bool checkAddress() override {
//         bool ret;
//         checkaddressRuleApply(getAddrTo(), this->id, ret);
//         return ret;
//     }
// };

// class DataBack :
//     virtual public IEmptyPack,
//     virtual public IHasAddresFrom,
//     virtual public IHasAddresData {
// public:
//     DataBack() {
//         msgOffset = 0;
//         addressFromOffset = 1;
//         addressToOffset = 3;
//         DataOffset = 3;
//     }
// protected:
//     bool checkAddress() override {
//         bool ret;
//         if (getMsgType() == IR_MSG_BACK_TO) {
//             DataOffset = 5;
//             checkaddressRuleApply((packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1], this->id, ret);
//         } else {
//             DataOffset = 3;
//             ret = true;
//         }
//         return ret;
//     }
// };

// class Request :
//     virtual public IEmptyPack,
//     virtual public IHasAddresFrom,
//     virtual public IHasAddresTo {
// public:
//     Request() {
//         msgOffset = 0;
//         addressFromOffset = 1;
//         addressToOffset = 3;
//         DataOffset = 3;
//     }
// protected:
//     bool checkAddress() override {
//         bool ret;
//         checkaddressRuleApply(getAddrTo(), this->id, ret);
//         return ret;
//     }
// };

// class Accept :
//     virtual public IEmptyPack,
//     virtual public IHasAddresFrom {
// public:
//     Accept() {
//         msgOffset = 0;
//         addressFromOffset = 1;
//         DataOffset = 1;
//     }
// protected:
// };