IR-protocol/PacketTypes.h

#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() { return true; };
        void set(IR_FOX::PackInfo *packInfo, uint16_t id)
        {
            this->packInfo = packInfo;
            this->id = id;

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

        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:
// };