#include "UpdateGameRuleProgressPacket.h"

#include <string.h>

#include "PacketListener.h"
#include "java/InputOutputStream/DataInputStream.h"
#include "java/InputOutputStream/DataOutputStream.h"

UpdateGameRuleProgressPacket::UpdateGameRuleProgressPacket() {
    m_messageId = "";
    m_icon = -1;
    m_auxValue = 0;
    m_definitionType = ConsoleGameRules::eGameRuleType_LevelRules;
    m_dataTag = 0;
}

UpdateGameRuleProgressPacket::UpdateGameRuleProgressPacket(
    ConsoleGameRules::EGameRuleType definitionType,
    const std::string& messageId, int icon, int auxValue, int dataTag,
    void* data, int dataLength) {
    m_definitionType = definitionType;
    m_messageId = messageId;
    m_icon = icon;
    m_auxValue = auxValue;
    m_dataTag = dataTag;

    if (dataLength > 0) {
        m_data = std::vector<uint8_t>(dataLength);
        memcpy(m_data.data(), data, dataLength);
    } else {
        m_data = std::vector<uint8_t>();
    }
}

void UpdateGameRuleProgressPacket::read(
    DataInputStream* dis)  // throws IOException
{
    m_definitionType = (ConsoleGameRules::EGameRuleType)dis->readInt();
    m_messageId = readUtf(dis, 64);
    m_icon = dis->readInt();
    m_auxValue = dis->readByte();
    m_dataTag = dis->readInt();
    int dataLength = dis->readInt();

    if (dataLength > 0) {
        m_data = std::vector<uint8_t>(dataLength);
        dis->readFully(m_data);
    } else {
        m_data = std::vector<uint8_t>();
    }
}

void UpdateGameRuleProgressPacket::write(
    DataOutputStream* dos)  // throws IOException
{
    dos->writeInt(m_definitionType);
    writeUtf(m_messageId, dos);
    dos->writeInt(m_icon);
    dos->writeByte(m_auxValue);
    dos->writeInt(m_dataTag);
    dos->writeInt(m_data.size());
    dos->write(m_data);
}

void UpdateGameRuleProgressPacket::handle(PacketListener* listener) {
    listener->handleUpdateGameRuleProgressPacket(shared_from_this());
}

int UpdateGameRuleProgressPacket::getEstimatedSize() {
    return (int)m_messageId.length() + 4 + m_data.size();
}