#include "shared.h"


Packet::Packet(Header init, std::vector<char> data) {
    changeHeader(init);
    mData = data;
}
Packet::Packet(){

}
unsigned int Packet::getAck() {
    return mHeader.mAckNum;
}
unsigned int Packet::getSeq() {
    return mHeader.mSeqNum;
}
unsigned short Packet::getID() {
    return mHeader.mID;
}
bool Packet::isACK() {
    return mAckFlag;
}
bool Packet::isSYN() {
    return mSynFlag;
}
bool Packet::isFIN() {
    return mFinFlag;
}
std::vector<char> Packet::getData() {
    return mData;
}

Header Packet::getHeader() {
    return mHeader;
}
void Packet::changeHeader(Header init) {
    mHeader = init;
    mAckFlag = (bool) ((init.mFlags & 4) >> 2);
    mSynFlag = (bool) ((init.mFlags & 2) >> 1);
    mFinFlag = (bool) ((init.mFlags & 1));
}

/*
PacketHanager holds all the data received
*/
PacketManager::PacketManager(Packet packet, std::string filePath, int CID) {
    mConnectionID = CID;
    mPath = filePath;
    mCurrentSeq = INITIAL_SEQ;
    mCurrentAck = packet.getSeq() % (MAX_NUM+1);
    mTimer = time(0);
    mFINACKED = false;
    mFIN = false;
}

void PacketManager::addBuffer(unsigned int seq, Packet packet) {
    if(mStorage.find(seq) == mStorage.end()) {
        mStorage.insert(std::pair<unsigned int, Packet>(seq,packet));
    } else {
        //For some reason dup exists, replace
        mStorage[seq] = packet;
    }
}

void PacketManager::writeFileCurr(std::vector<char> data) {
    std::fstream fs(mPath, std::fstream::app);
    if(!fs.is_open()) {
        exit(EXIT_FAILURE);
    }
    for(char x: data) {
        fs << x;
    }
    fs.close();
    writeFileBuffer();
}

void PacketManager::writeFileBuffer() {
    std::fstream fs(mPath, std::fstream::app);
    if(!fs.is_open()) {
        exit(EXIT_FAILURE);
    }
    while(mStorage.find(mCurrentAck % (MAX_NUM + 1)) != mStorage.end()) {
        Packet temp = mStorage.find(mCurrentAck % (MAX_NUM + 1))->second;
        std::vector<char> curr = temp.getData();
        if(temp.getAck() != 0) {
            mCurrentSeq = temp.getAck() % (MAX_NUM + 1);
        }
        mCurrentAck += curr.size() % (MAX_NUM + 1);
        for(char x: curr) {
        fs << x;
        }
    }
    fs.close();
}

void PacketManager::writeError() {
    std::fstream fs(mPath, std::fstream::out);
    if(!fs.is_open()) {
        exit(EXIT_FAILURE);
    }
    fs.write("ERROR", 5);
    fs.close();
}

void PacketManager::updateACK(unsigned int ack) {
    mCurrentAck = ack % (MAX_NUM+1);
}

void PacketManager::updateSEQ(unsigned int seq) {
    mCurrentSeq = seq % (MAX_NUM+1);
}

Header makeHeader(unsigned int seq, unsigned int ack, unsigned short ID, unsigned short flags) {
    Header result = {0};
    result.mSeqNum = seq;
    result.mAckNum = ack;
    result.mID = ID;
    result.mFlags = flags;
    return result;
}

Header convertHeaderHost(Header header) {
    header.mSeqNum = ntohl(header.mSeqNum);
    header.mAckNum = ntohl(header.mAckNum);
    header.mID = ntohs(header.mID);
    header.mFlags = ntohs(header.mFlags);
    return header;
}

Header convertHeaderNetwork(Header header) {
    header.mSeqNum = htonl(header.mSeqNum);
    header.mAckNum = htonl(header.mAckNum);
    header.mID = htons(header.mID);
    header.mFlags = htons(header.mFlags);
    return header;
}
CPacket convertCPacketToNetwork(CPacket pc){
    pc.mSeqNum = htonl(pc.mSeqNum);
    pc.mAckNum = htonl(pc.mAckNum);
    pc.mID = htons(pc.mID);
    pc.flags = htons(pc.flags);
    return pc;
}

CPacket convertCPacketToHost(CPacket pc){
    pc.mSeqNum = ntohl(pc.mSeqNum);
    pc.mAckNum = ntohl(pc.mAckNum);
    pc.mID = ntohs(pc.mID);
    pc.flags = ntohs(pc.flags);
    return pc;
}