#include "bbnow_priv.hpp"

#include <cassert>
#include <esp_log.h>

const static char TAG[] = "bbnow_priv";

size_t BBNowPrivPacket::serialize_size() const {
    switch (this->packet_type) {
        case BBNowPrivPacketType::NONE:
            return -1;

        case BBNowPrivPacketType::ACK:
            return BBNowPrivPacket::ACK_PACKET_SIZE;

        case BBNowPrivPacketType::DISCOVERY_RESPONSE:
            return BBNowPrivPacket::DISCOVERY_RESPONSE_PACKET_SIZE;

        case BBNowPrivPacketType::EXPANDER_MESSAGE: {
            const auto& data =
                std::get<BBNowPrivExpanderMessageData>(
                    this->packet_data
                );

            return sizeof(BBNowPrivPacketType) +
                   sizeof(uint16_t) +
                   data.data.size();
        }

        case BBNowPrivPacketType::INFO_QUERY:
            return BBNowPrivPacket::INFO_QUERY_PACKET_SIZE;
            
        default:
            return -1;
    }

    return -1;
}

std::vector<uint8_t> BBNowPrivPacket::serialize() const {
    auto buf = std::vector<uint8_t>();

    if (this->serialize_size() == static_cast<size_t>(-1)) {
        return buf;
    }

    this->serialize_into(buf);
    return buf;
}

size_t BBNowPrivPacket::serialize_into(
    std::vector<uint8_t>& buf
) const {
    size_t initial_size = buf.size();
    size_t size = this->serialize_size();

    if (size == static_cast<size_t>(-1)) {
        return 0;
    }

    buf.reserve(initial_size + size);

    // Push packet type.
    static_assert(
        sizeof(BBNowPrivPacketType) == 2,
        "expect packet type to be 2 bytes"
    );

    uint16_t packet_type =
        static_cast<uint16_t>(this->packet_type);

    buf.push_back((packet_type >> 8) & 0xFF);
    buf.push_back((packet_type >> 0) & 0xFF);

    // Push sequence number.
    static_assert(
        sizeof(this->sequence) == 2,
        "expect sequence number to be 2 bytes"
    );

    buf.push_back((this->sequence >> 8) & 0xFF);
    buf.push_back((this->sequence >> 0) & 0xFF);

    switch (this->packet_type) {
        case BBNowPrivPacketType::NONE:
            break;

        case BBNowPrivPacketType::ACK:
            break;

        case BBNowPrivPacketType::DISCOVERY_RESPONSE: {
            const auto& data =
                std::get<BBNowPrivDiscoveryResponseData>(
                    this->packet_data
                );

            static_assert(
                sizeof(data.expantion_type) == 2,
                "expect expansion type to be 2 bytes"
            );

            uint16_t expantion_type =
                static_cast<uint16_t>(data.expantion_type);

            buf.push_back((expantion_type >> 8) & 0xFF);
            buf.push_back((expantion_type >> 0) & 0xFF);

            break;
        }

        case BBNowPrivPacketType::EXPANDER_MESSAGE: {
            const auto& data =
                std::get<BBNowPrivExpanderMessageData>(
                    this->packet_data
                );

            buf.insert(
                buf.end(),
                data.data.begin(),
                data.data.end()
            );

            break;
        }

        case BBNowPrivPacketType::INFO_QUERY: {
            const auto& data =
                std::get<BBNowPrivInfoQueryData>(
                    this->packet_data
                );

            static_assert(
                sizeof(data) == 1,
                "expect info query type to be 1 byte"
            );
            buf.push_back(data.battery_percentage);

            break;
        }
    }

    assert(buf.size() - initial_size == size);
    return size;
}

std::optional<BBNowPrivPacket>
BBNowPrivPacket::deserialize(
    std::span<const uint8_t> bytes
) {
    // Packet type + sequence number.
    static_assert(
        sizeof(BBNowPrivPacketType) + sizeof(uint16_t) == 4,
        "expect packet type and sequence number to be 4 bytes"
    );

    if (bytes.size() < 4) {
        ESP_LOGW(
            TAG,
            "packet not long enough for priv packet"
        );
        return std::nullopt;
    }

    // Read packet type.
    uint16_t packet_type =
        ((uint16_t)bytes[0] << 8) |
        ((uint16_t)bytes[1] << 0);

    BBNowPrivPacket packet;

    packet.packet_type =
        static_cast<BBNowPrivPacketType>(packet_type);

    if (packet.packet_type == BBNowPrivPacketType::NONE) {
        ESP_LOGW(
            TAG,
            "BBNowPrivPacketType was NONE! discarding"
        );
        return std::nullopt;
    }

    if (packet.packet_type > BBNowPrivPacketType::MAX) {
        ESP_LOGW(
            TAG,
            "BBNowPrivPacketType not in range! discarding"
        );
        return std::nullopt;
    }

    // Read sequence number.
    packet.sequence =
        ((uint16_t)bytes[2] << 8) |
        ((uint16_t)bytes[3] << 0);

    switch (packet.packet_type) {
        case BBNowPrivPacketType::ACK: {
            if (bytes.size() < ACK_PACKET_SIZE) {
                ESP_LOGW(
                    TAG,
                    "ACK packet not long enough"
                );
                return std::nullopt;
            }

            if (bytes.size() > ACK_PACKET_SIZE) {
                ESP_LOGW(
                    TAG,
                    "ACK packet longer than expected, "
                    "decoding anyway"
                );
            }

            packet.packet_data = BBNowPrivAckData{};
            break;
        }

        case BBNowPrivPacketType::DISCOVERY_RESPONSE: {
            if (bytes.size() < DISCOVERY_RESPONSE_PACKET_SIZE) {
                ESP_LOGW(
                    TAG,
                    "discovery response packet not long enough"
                );
                return std::nullopt;
            }

            if (bytes.size() > DISCOVERY_RESPONSE_PACKET_SIZE) {
                ESP_LOGW(
                    TAG,
                    "discovery response packet longer than expected, "
                    "decoding anyway"
                );
            }

            uint16_t expantion_type =
                ((uint16_t)bytes[4] << 8) |
                ((uint16_t)bytes[5] << 0);

            auto data = BBNowPrivDiscoveryResponseData{
                .expantion_type =
                    static_cast<BlkBoxExpantion>(expantion_type)
            };

            if (data.expantion_type > BlkBoxExpantion::MAX) {
                ESP_LOGW(
                    TAG,
                    "BlkBoxExpantion not in range! discarding"
                );
                return std::nullopt;
            }

            packet.packet_data = std::move(data);
            break;
        }

        case BBNowPrivPacketType::EXPANDER_MESSAGE: {
            // Everything after the 4-byte header is the message.
            auto data = BBNowPrivExpanderMessageData{
                .data = std::vector<uint8_t>(
                    bytes.begin() + 4,
                    bytes.end()
                )
            };

            packet.packet_data = std::move(data);
            break;
        }

        case BBNowPrivPacketType::INFO_QUERY: {
            constexpr size_t INFO_QUERY_PACKET_SIZE =
                sizeof(BBNowPrivPacketType) +
                sizeof(uint16_t) +
                sizeof(BBNowPrivInfoQueryData);

            if (bytes.size() < INFO_QUERY_PACKET_SIZE) {
                ESP_LOGW(
                    TAG,
                    "info query packet not long enough"
                );
                return std::nullopt;
            }

            if (bytes.size() > INFO_QUERY_PACKET_SIZE) {
                ESP_LOGW(
                    TAG,
                    "info query packet longer than expected, "
                    "decoding anyway"
                );
            }

            BBNowPrivInfoQueryData data{
                .battery_percentage = bytes[4]
            };

            packet.packet_data = data;
            break;
        }

        case BBNowPrivPacketType::NONE:
            return std::nullopt;
    }

    return packet;
}

BBNowPrivPacket BBNowPrivPacket::new_ack(
    uint16_t sequence
) {
    BBNowPrivPacket packet;

    packet.packet_type = BBNowPrivPacketType::ACK;
    packet.sequence = sequence;
    packet.packet_data = BBNowPrivAckData{};

    return packet;
}

BBNowPrivPacket BBNowPrivPacket::new_discovery_response(
    uint16_t sequence,
    BBNowPrivDiscoveryResponseData data
) {
    BBNowPrivPacket packet;

    packet.packet_type =
        BBNowPrivPacketType::DISCOVERY_RESPONSE;

    packet.sequence = sequence;
    packet.packet_data = std::move(data);

    return packet;
}

BBNowPrivPacket BBNowPrivPacket::new_expander_message(
    uint16_t sequence,
    BBNowPrivExpanderMessageData data
) {
    BBNowPrivPacket packet;

    packet.packet_type =
        BBNowPrivPacketType::EXPANDER_MESSAGE;

    packet.sequence = sequence;
    packet.packet_data = std::move(data);

    return packet;
}

BBNowPrivPacket BBNowPrivPacket::new_info_query(
    uint16_t sequence,
    BBNowPrivInfoQueryData data
) {
    BBNowPrivPacket packet;

    packet.packet_type =
        BBNowPrivPacketType::INFO_QUERY;

    packet.sequence = sequence;
    packet.packet_data = std::move(data);

    return packet;
}