#pragma once

#include <cstdint>
#include <vector>
#include "ByteArrayProvider.h"
#include "EDeviceDataHeadTypes.h"

namespace Incart::DeviceComplexCommands
{

struct DeviceDataHead final
{
public:
   static const size_t fullSize = 10;
   static const size_t shortSize = 7; // wSignature + wLength + wVersion + btCount

   uint16_t length; // sizeof(from begin to begin of 'dwCRC')

private:
    static const uint16_t m_infoMapSignature = 0xE33E;

    //-----------------------------------------------------------
    uint16_t m_signature; // == 0xE33E
    uint16_t m_version; // version Head 0x203 / 0x304
    uint8_t m_count; // Count of data tags
    // wVersion >= 0x304
    EDeviceDataHeadTypes m_typeHead; // Type of Head
    uint16_t m_flags; // Flags of contents of Head

private:
    DeviceDataHead()
      : length(0), m_signature(0), m_version(0), m_count(0), m_typeHead(EDeviceDataHeadTypes::HeadUnknown), m_flags(0)
    {
    }

    DeviceDataHead(uint16_t signature_, uint16_t version_, uint8_t count_, EDeviceDataHeadTypes typeHead_, uint16_t flags_, uint16_t length_)
      : length(length_), m_signature(signature_), m_version(version_), m_count(count_), m_typeHead(typeHead_), m_flags(flags_)
    {
    }

public:
    size_t getHeadLength()
    {
        return (m_version > 0x203) ? fullSize : shortSize;
    }

    uint8_t getTagCount() { return m_count; }

    EDeviceDataHeadTypes getTypeHead() { return m_typeHead; }

    bool isEmpty() { return (m_signature == 0) && (m_version == 0); }

    static bool checkSignature(uint16_t signature_)
    {
        return m_infoMapSignature == signature_;
    }

    static uint16_t readLength(std::vector<uint8_t> data_)
    {
      if (data_.size() < shortSize)
      {
          return 0;
      }
      uint16_t signature = Common::ByteArrayProvider::getWordFromArray(data_, 0);
      if (signature != m_infoMapSignature)
      {
          return 0;
      }
      uint16_t dataLength = Common::ByteArrayProvider::getWordFromArray(data_, 2);
      return static_cast<uint16_t>(dataLength + 4); // + sizeof(dwCRC)
    }

    static DeviceDataHead create(std::vector<uint8_t> data_, int& offset_)
    {
      if (data_.size() < shortSize)
      {
          offset_ = 0;
          return DeviceDataHead{};
      }

      DeviceDataHead dataHead
      {
          Common::ByteArrayProvider::getWordFromArray(data_, 0),
          Common::ByteArrayProvider::getWordFromArray(data_, 4),
          data_[6],
          EDeviceDataHeadTypes::HeadUnknown,
          0,
          Common::ByteArrayProvider::getWordFromArray(data_, 2)
      };

      offset_ = 7;
      if (data_.size() < dataHead.getHeadLength())
      {
          return DeviceDataHead{};
      }
      if (dataHead.m_version > 0x203)
      {
          dataHead.m_typeHead = static_cast<EDeviceDataHeadTypes>(data_[7]);	//	Type of Head
          dataHead.m_flags = Common::ByteArrayProvider::getWordFromArray(data_, 8); //	Flags of contents of Head
      }
      offset_ = 10;
      return dataHead;
    }

    static DeviceDataHead create(uint8_t count_, EDeviceDataHeadTypes typeHead_, uint16_t version_)
    {
        return DeviceDataHead
        {
            m_infoMapSignature,
            version_,
            count_,
            typeHead_,
            0,
            0
        };
    }

    std::vector<uint8_t> toByteArray()
    {
        std::vector<uint8_t> bytes = {
            Common::ByteArrayProvider::lowByte(m_signature),
            Common::ByteArrayProvider::highByte(m_signature),
            Common::ByteArrayProvider::lowByte(length),
            Common::ByteArrayProvider::highByte(length),
            Common::ByteArrayProvider::lowByte(m_version),
            Common::ByteArrayProvider::highByte(m_version),
            m_count
        };

        if (m_version > 0x203)
        {
            bytes.push_back(static_cast<uint8_t>(m_typeHead));
            bytes.push_back(Common::ByteArrayProvider::lowByte(m_flags));
            bytes.push_back(Common::ByteArrayProvider::highByte(m_flags));
        }
        return bytes;
    }
};

} // namespace Incart::DeviceComplexCommands