//
// Created by wolverindev on 06.01.18.
//

#include "TSClient.h"

using namespace std;
using namespace std::chrono;
using namespace ts::flood;
using namespace ts::protocol;

TSClient::TSClient(ProxiedClient* con) : connection(con) {
    this->cryptionHandler = new connection::CryptionHandler();
    this->cryptionHandler->reset();
}

TSClient::~TSClient() {}

void TSClient::handleMessageRead(const std::string& message) {
    if(message.length() < MAC_SIZE + SERVER_HEADER_SIZE) {
        cerr << "Invalid pkt length!" << endl;
        return;
    }

    shared_ptr<ServerPacket> packet = make_shared<ServerPacket>(message);
    cout << "Having packet " << packet->type().name() << endl;
}

void TSClient::sendPacket(ts::protocol::ClientPacket &packet, int32_t packetId) {
    size_t maxDataLength = 500 - packet.header().length();

    if(packet.data().length() > maxDataLength){
        cout << "Split packet" << endl;
        string error;


        /*
        if(!compressPacket(&packet, error)){
            cerr << "Compress error!" << endl;
            return;
        }
        packet.enableFlag(PacketFlag::Compressed);
        */
        if(packet.data().length() > maxDataLength){
            std::vector<ClientPacket*> siblings;

            ClientPacket* root = new ClientPacket(packet.type(), packet.flagMask(), packet.data());
            root->enableFlag(PacketFlag::Fragmented);
            //assert(root->hasFlag(PacketFlag::Compressed));
            siblings.push_back(root);

            //Max len - mac - header
            while(siblings.back()->data().length() > maxDataLength){
                auto overhead = siblings.back()->data().substr(maxDataLength);
                siblings.back()->data(siblings.back()->data().substr(0, maxDataLength));

                ClientPacket* sib = new ClientPacket(packet.type(), packet.flagMask(), overhead);
                sib->toggle(PacketFlag::Fragmented, false);
                siblings.push_back(sib);
            }
            siblings.back()->enableFlag(PacketFlag::Fragmented);
            for(auto elm : siblings){
                sendPacket(*elm);
                delete elm;
            }
            return;
        }
    }

    if (packetId == -1)
	    packet.applyPacketId(pktIdManager);
    else packet.applyPacketId((uint16_t) packetId, 0);
    packet.clientId(this->clientId);

    string error = "success";
    if (!this->cryptionHandler->progressPacketOut(&packet, error)) {
        cerr << "Invalid crypt -> " << error << endl;
        return;
    }

    this->connection->sendMessage(packet.mac() + packet.header() + packet.data());
}

const int InitVersionLength = 4;
const uint8_t InitVersion[InitVersionLength] = {0x06, 0x3b, 0xEC, 0xE9};

void TSClient::startConnect() {
    int maxBufferSize = 512;
    size_t bufferIndex = 0;
    uint8_t buffer[maxBufferSize];
    string error = "success";

    memcpy(buffer, InitVersion, InitVersionLength);
    bufferIndex += InitVersionLength;
    buffer[bufferIndex++] = 0x00; //Login state

    int64_t millis = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
    memcpy(&buffer[5], &millis, 4);
    bufferIndex += 4;
    //generate the alpha key
    for (int i = 0; i < 4; i++) buffer[bufferIndex++] = (uint8_t) std::rand();
    bufferIndex += 8; //Reserved bytes

    ClientPacket pkt(ts::protocol::PacketTypeInfo::Init1, string((char *) buffer, bufferIndex));
    pkt.clientId(0);
    pkt.toggle(ts::protocol::PacketFlag::Unencrypted, true);
    this->sendPacket(pkt, 101);
}