#include "metrics/Host.h"

#include <stdexcept>
#include <cstring>
#include <arpa/inet.h>

#include "network/common/Buffer.h"

namespace metrics
{

    // ---- Вспомогательные функции для float <-> uint32_t ----
    static uint32_t floatToNetwork(float f)
    {
        uint32_t tmp;
        static_assert(sizeof(tmp) == sizeof(f), "Size mismatch");
        std::memcpy(&tmp, &f, sizeof(f));
        return htonl(tmp);
    }

    static float networkToFloat(uint32_t n)
    {
        uint32_t tmp = ntohl(n);
        float f;
        std::memcpy(&f, &tmp, sizeof(f));
        return f;
    }

    // ---- Сериализация ----
    std::vector<uint8_t> Host::serialize() const
    {
        network::Buffer buf;

        buf.writeUint8(1); // version
        buf.writeString(hostname);

        // CPU
        buf.writeFloat(cpu.totalLoad);
        buf.writeUint8(static_cast<uint8_t>(cpu.coreLoads.size()));
        for (float f : cpu.coreLoads)
            buf.writeFloat(f);
        for (const auto &f : cpu.coreTemps)
        {
            buf.writeFloat(f.current);
            buf.writeFloat(f.max);
        }

        // Memory
        buf.writeUint64(memory.memory.used);
        buf.writeUint64(memory.memory.available);
        buf.writeUint64(memory.memory.total);
        buf.writeUint64(memory.swap.used);
        buf.writeUint64(memory.swap.available);
        buf.writeUint64(memory.swap.total);
        buf.writeUint64(memory.hugepages.used);
        buf.writeUint64(memory.hugepages.available);
        buf.writeUint64(memory.hugepages.total);

        // Disks
        buf.writeUint8(static_cast<uint8_t>(disks.size()));
        for (const auto &d : disks)
        {
            buf.writeString(d.name);
            buf.writeString(d.path);
            buf.writeUint64(d.metrics.used);
            buf.writeUint64(d.metrics.available);
            buf.writeUint64(d.metrics.total);
        }

        return buf.data();
    }

    // ---- Десериализация ----
    Host Host::deserialize(const std::vector<uint8_t> &data)
    {
        Host h;
        network::Buffer buf(const_cast<std::vector<uint8_t> &>(data));

        uint8_t version = buf.readUint8();
        if (version != 1)
            throw std::runtime_error("Unsupported protocol version");

        h.hostname = buf.readString();

        // CPU
        h.cpu.totalLoad = buf.readFloat();
        uint8_t numCpu = buf.readUint8();
        h.cpu.coreLoads.clear();
        h.cpu.coreLoads.reserve(numCpu);
        for (uint8_t i = 0; i < numCpu; ++i)
            h.cpu.coreLoads.push_back(buf.readFloat());
        h.cpu.coreTemps.clear();
        h.cpu.coreTemps.reserve(numCpu);
        for (uint8_t i = 0; i < numCpu; ++i)
            h.cpu.coreTemps.push_back({buf.readFloat(), buf.readFloat()});

        // Memory
        h.memory.memory.used = buf.readUint64();
        h.memory.memory.available = buf.readUint64();
        h.memory.memory.total = buf.readUint64();
        h.memory.swap.used = buf.readUint64();
        h.memory.swap.available = buf.readUint64();
        h.memory.swap.total = buf.readUint64();
        h.memory.hugepages.used = buf.readUint64();
        h.memory.hugepages.available = buf.readUint64();
        h.memory.hugepages.total = buf.readUint64();

        // Disks
        uint8_t numDisks = buf.readUint8();
        h.disks.clear();
        h.disks.reserve(numDisks);
        for (uint8_t i = 0; i < numDisks; ++i)
        {
            Disk disk;
            disk.name = buf.readString();
            disk.path = buf.readString();
            disk.metrics.used = buf.readUint64();
            disk.metrics.available = buf.readUint64();
            disk.metrics.total = buf.readUint64();
            h.disks.push_back(disk);
        }

        return h;
    }
} // namespace metrics