#pragma once

#include "ByteArrayProvider.h"
#include "DateTimeObject.h"
#include "StringExtensions.h"
#include <codecvt>

namespace Incart::DeviceComplexCommands
{

struct IInfoMapItem
{
    virtual ~IInfoMapItem(){}

    std::vector<uint8_t> toBytes()
    {
        std::vector<uint8_t> bytes;
        std::vector<uint8_t> dataBytes = getDataBytes();
        bytes.push_back(static_cast<uint8_t>(dataBytes.size() + 1));
        bytes.push_back(getTag());
        bytes.insert(bytes.end(), dataBytes.begin(), dataBytes.end());
        return bytes;
    }

protected:
    virtual uint8_t getTag() const=0;
    virtual std::vector<uint8_t> getDataBytes() const=0;
};

template <typename T>
struct InfoMapItem : public IInfoMapItem
{
    T data;

    InfoMapItem(const T& data_) : data(data_)
    {
    }
};

struct InfoMapIntItem  final : public InfoMapItem<int32_t>
{
public:
    InfoMapIntItem(int32_t data_) : InfoMapItem<int32_t>(data_)
    {
    }

protected:
    uint8_t getTag() const override
    {
        return static_cast<uint8_t>('d');
    }

    std::vector<uint8_t> getDataBytes() const override
    {
        std::vector<uint8_t> bytes;
        Common::ByteArrayProvider::addDWord(static_cast<uint32_t>(data), bytes);
        return bytes;
    }
};

struct InfoMapDateTimeItem  final : public InfoMapItem<Common::DateTimeObject>
{
public:
    InfoMapDateTimeItem(const Common::DateTimeObject& data_) : InfoMapItem<Common::DateTimeObject>(data_)
    {
    }

protected:
    uint8_t getTag() const override
    {
        return static_cast<uint8_t>('Q');
    }

    std::vector<uint8_t> getDataBytes() const override
    {
        std::string dateTimeText(packDateTimeToString(data));
        std::vector<uint8_t> bytes(dateTimeText.begin(), dateTimeText.end());
        bytes.push_back('\0');
        return bytes;
    }

private:
    std::string packDateTimeToString(const Common::DateTimeObject& dateTime) const
    {
        std::string dateTimeText;
        dateTimeText += Common::StringExtensions::getZeroLeadNumberText(dateTime.date.getDay(), 2);
        dateTimeText += "-";
        dateTimeText += Common::StringExtensions::getZeroLeadNumberText(dateTime.date.getMonth(), 2);
        dateTimeText += "-";
        dateTimeText += Common::StringExtensions::getZeroLeadNumberText(dateTime.date.getYear(), 4);
        dateTimeText += " ";
        dateTimeText += Common::StringExtensions::getZeroLeadNumberText(dateTime.time.getHours(), 2);
        dateTimeText += ":";
        dateTimeText += Common::StringExtensions::getZeroLeadNumberText(dateTime.time.getMinutes(), 2);
        dateTimeText += ":";
        dateTimeText += Common::StringExtensions::getZeroLeadNumberText(dateTime.time.getSeconds(), 2);
        return dateTimeText;
    }
};

struct InfoMapStringItem  final : public InfoMapItem<std::string>
{
public:
    InfoMapStringItem(const std::string& data_) : InfoMapItem<std::string>(data_)
    {
    }

protected:
    uint8_t getTag() const override
    {
        return static_cast<uint8_t>('s');
    }

    std::vector<uint8_t> getDataBytes() const override
    {
        std::vector<uint8_t> bytes(data.begin(), data.end());
        bytes.push_back('\0');
        return bytes;
    }
};

struct InfoMapWideStringItem  final : public InfoMapItem<std::wstring>
{
public:
    InfoMapWideStringItem(const std::wstring& data_) : InfoMapItem<std::wstring>(data_)
    {
    }

protected:
    uint8_t getTag() const override
    {
        return static_cast<uint8_t>('w');
    }

    std::vector<uint8_t> getDataBytes() const override
    {
        std::wstring text(data + L'\0');
        uint8_t const* p = reinterpret_cast<uint8_t const*>(&text[0]);
        std::size_t byteCount = text.size() * sizeof(text.front());
        std::vector<uint8_t> bytes(p, p + byteCount);
        return bytes;
    }
};

} // namespace Incart::DeviceComplexCommands