#pragma once
#include "defines.h"
#include <string>
#include <vector>
class DataPack
{
public:
    std::string Id;
    std::vector<uint8_t> Value;
    std::vector<DataPack> Child = std::vector<DataPack>();
    DataPack& operator[](int index);
    DataPack& operator[](std::string id);
    __declspec(property (put = SetCount, get = GetCount)) int Count;
    int GetCount();
    void SetCount(int value);
    void operator=(const std::initializer_list<uint8_t> data);
    void operator=(const std::initializer_list<uint8_t>* data);
    template<typename T>
    void operator=(T data)
    {
        this->Value.resize(sizeof(T));
        memcpy(this->Value.data(), &data, sizeof(T));
    }
    template<typename T>
    void operator=(std::vector<T> data)
    {
        this->Value.resize(data.size() * sizeof(T));
        memcpy(this->Value.data(), data.data(), data.size() * sizeof(T));
    }
    template<typename T>
    void operator=(std::initializer_list<T> data)
    {
        this->Value.resize(data.size());
        memcpy(this->Value.data(), data.begin(), data.size() * sizeof(T));
    }
    template<typename T>
    T operator=(DataPack data)
    {
        T result = T();
        memcpy(&result, data.Value.data(), sizeof(T));
        return result;
    }
    void operator=(const char* data);
    void operator=(const wchar_t* data);
    void operator=(char* data);
    void operator=(wchar_t* data);
    void operator=(std::string data);
    void operator=(std::wstring data);
    template<typename T>
    DataPack(T data)
    {
        this->Id = "";
        this->Value.resize(sizeof(T));
        memcpy(this->Value.data(), &data, sizeof(T));
    }
    template<typename T>
    DataPack(std::string id, T data)
    {
        this->Id = id;
        this->Value.resize(sizeof(T));
        memcpy(this->Value.data(), &data, sizeof(T));
    }
    DataPack();
    DataPack(const char* key);
    DataPack(const uint8_t* data, int data_len);
    DataPack(std::string id, uint8_t* data, int len);
    DataPack(std::vector<uint8_t> data);
    DataPack(std::initializer_list<uint8_t> data);
    DataPack(std::string id, std::string data);
    DataPack(std::string id, std::wstring data);
    DataPack(std::string id, char* data);
    DataPack(std::string id, const char* data);
    DataPack(std::string id, wchar_t* data);
    DataPack(std::string id, const wchar_t* data);

    void Add(DataPack val);
    template<typename T>
    DataPack& Add(std::string key, T val)
    {
        this->Child.push_back(DataPack(key, val));
        return this->Child[this->Child.size() - 1];
    }
    template<typename T>
    DataPack& Add(T val)
    {
        this->Child.push_back(DataPack("", val));
        return this->Child[this->Child.size() - 1];
    }
    template<typename T>
    T convert()
    {
        return *(T*)this->Value.data();
    }
    template<typename T>
    void convert(T& output)
    {
        output = *(T*)this->Value.data();
    }
    template<typename T>
    void convert(T* output)
    {
        *output = *(T*)this->Value.data();
    }
    bool ContainsKsy(std::string key)
    {
        for (auto child : this->Child)
        {
            if (child.Id == key)
                return true;
        }
        return false;
    }
    void RemoveAt(int index);
    std::vector<uint8_t> GetBytes();
    void clear();
    int size();
};