#ifndef SHARED_H
#define SHARED_H

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <unistd.h>
#include <time.h>
#include <arpa/inet.h>
#include <queue>
#include <fstream>
#include <iostream>
#include <string.h>
#include <string>
#include <arpa/inet.h>
#include <netdb.h>
#include <unordered_map>
#include <vector>
#include <sys/select.h>
#include <sys/time.h>


#define PORT_MIN 0
#define PORT_MAX 65535
#define PACKET_SIZE 524
#define MAXBUFFER 524
#define INITIAL_SEQ 4321
#define INITIAL_SEQ_C 12345
#define MAX_SEQ 102400
#define MAX_ACK 102400
#define MAX_NUM 102400
#define MIN_CWND 512
#define MAX_CWND 51200
#define RWND 51200
#define INIT_SSTHRESH 10000

//Common flag settings for sending responses
#define FIN 1
#define SYN 2
#define ACK 4
#define FIN_ACK 5
#define SYN_ACK 6

#define SEND "SEND"
#define DROP "DROP"
#define RECV "RECV"

typedef struct Header Header;
typedef struct FinCheck FinCheck;

#define DEFAULT_ACK 0
#define FIXED_RTO 0.5
#define FIN_WAIT 2
#define HEAD_SIZE 12

#pragma pack(1)
struct Header
{
    unsigned int mSeqNum;
    unsigned int mAckNum;
    unsigned short mID;
    unsigned short mFlags;
};
#pragma pack(1)

#pragma pack(1)
struct CPacket
{
    unsigned int mSeqNum;
    unsigned int mAckNum;
    unsigned short mID;
    unsigned short flags;
    char data[512];
};
#pragma pack(1)
//cleaner way to make Header struct using func and args
Header makeHeader(unsigned int seq, unsigned int ack, unsigned short ID, unsigned short flags);
//Converts header from network byte to host byte order and vice versa
Header convertHeaderHost(Header header);
Header convertHeaderNetwork(Header header);
CPacket convertCPacketToNetwork(CPacket pc);
CPacket convertCPacketToHost(CPacket pc);

class Packet
{
    public:
        Packet(Header init, std::vector<char> data={});
        Packet();
        unsigned int getAck(); 
        unsigned int getSeq();
        unsigned short getID();
        bool isACK();
        bool isSYN();
        bool isFIN();
        Header getHeader(); 
        std::vector<char> getData();
        void changeHeader(Header init);
    private:
        Header mHeader;
        bool mAckFlag;
        bool mSynFlag;
        bool mFinFlag;
        std::vector<char> mData;
};

class PacketManager
{
    public:
        PacketManager(Packet packet, std::string filePath, int CID);
        void writeFileBuffer();
        void writeFileCurr(std::vector<char> data);
        void writeError();
        void updateACK(unsigned int ack);
        void updateSEQ(unsigned int seq);
        void addBuffer(unsigned int seq, Packet packet);
        //Helper functions
        socklen_t getSinSize() { return sizeof(struct sockaddr_storage);}
        unsigned int getSeq() { return mCurrentSeq;}
        unsigned int getACK() { return mCurrentAck;}
        int getID() { return mConnectionID;}
        bool getFINACKED() { return mFINACKED;}
        void recvFINACKED() { mFINACKED = true;}
        bool getFIN() { return mFIN;}
        void recvFIN() { mFIN = true;}
        void updateTime() { mTimer = time(0);}
        time_t getTime() { return mTimer;}
        std::string getPath() { return mPath;}
    private:
        unsigned int mCurrentSeq;
        unsigned int mCurrentAck;
        int mConnectionID;
        time_t mTimer;
        std::string mPath;
        std::unordered_map<unsigned int, Packet> mStorage;
        bool mFINACKED;
        bool mFIN;
};

struct FinCheck 
{
    time_t mTimer;
    Header mHeader;
    PacketManager* mManager;
    sockaddr_in mClientAddr;
};
#endif