#ifndef CORE_NETWORK_H
#define CORE_NETWORK_H

#include "core/Buffer.h"
#include "core/Types.h"

typedef enum {
    CORE_RELIABLE,
    CORE_SEQUENCED,
    CORE_UNSEQUENCED
} CorePacketSendMode;

typedef struct {
    const char* data;
    size_t size;
    size_t index;
} CoreInPacket;

void coreInitInPacket(CoreInPacket* in, const void* data, size_t n);
bool coreInPacketReadU8(CoreInPacket* in, u8* u);
bool coreInPacketReadU16(CoreInPacket* in, u16* u);
bool coreInPacketReadU32(CoreInPacket* in, u32* u);
bool coreInPacketReadI8(CoreInPacket* in, i8* i);
bool coreInPacketReadI16(CoreInPacket* in, i16* i);
bool coreInPacketReadI32(CoreInPacket* in, i32* i);
bool coreInPacketReadFloat(CoreInPacket* in, float* f);
size_t coreInPacketReadString(CoreInPacket* in, char* buffer, size_t n);
bool coreInPacketRead(CoreInPacket* in, void* buffer, size_t n);

typedef struct {
    CoreBuffer data;
} CoreOutPacket;

void coreInitOutPacket(CoreOutPacket* out);
void coreDestroyOutPacket(CoreOutPacket* out);
CoreOutPacket* coreOutPacketWriteU8(CoreOutPacket* out, u8 u);
CoreOutPacket* coreOutPacketWriteU16(CoreOutPacket* out, u16 u);
CoreOutPacket* coreOutPacketWriteU32(CoreOutPacket* out, u32 u);
CoreOutPacket* coreOutPacketWriteI8(CoreOutPacket* out, i8 i);
CoreOutPacket* coreOutPacketWriteI16(CoreOutPacket* out, i16 i);
CoreOutPacket* coreOutPacketWriteI32(CoreOutPacket* out, i32 i);
CoreOutPacket* coreOutPacketWriteFloat(CoreOutPacket* out, float f);
CoreOutPacket* coreOutPacketWriteString(CoreOutPacket* out, const char* buffer);
CoreOutPacket* coreOutPacketWrite(CoreOutPacket* out, const void* buffer,
                                  size_t n);

typedef u16 CorePort;
typedef void (*CoreClientOnConnect)(void);
typedef void (*CoreClientOnDisconnect)(void);
typedef void (*CoreClientOnPacket)(CoreInPacket*);

bool coreClientStart(void);
void coreClientStop(void);
bool coreClientConnect(const char* server, CorePort port, int timeoutTicks);
void coreClientTimeout(u32 timeout, u32 timeoutMin, u32 timeoutMax);
void coreClientDisconnect(int timeoutTicks);
void coreClientSend(const CoreOutPacket* p, CorePacketSendMode mode);
void coreClientTick(void);
void coreClientSetConnectHandler(CoreClientOnConnect oc);
void coreClientSetDisconnectHandler(CoreClientOnDisconnect od);
void coreClientSetPacketHandler(CoreClientOnPacket op);
void coreClientResetHandler(void);
bool coreClientIsConnecting(void);
bool coreClientIsConnected(void);

typedef int CoreClient;
typedef void (*CoreServerOnConnect)(CoreClient);
typedef void (*CoreServerOnDisconnect)(CoreClient);
typedef void (*CoreServerOnPacket)(CoreClient, CoreInPacket*);

bool coreServerStart(CorePort port, size_t maxClients);
void coreServerStop(void);
void coreServerTick(void);
void coreServerSendAll(const CoreOutPacket* p, CorePacketSendMode mode);
void coreServerSend(CoreClient client, const CoreOutPacket* p,
                    CorePacketSendMode mode);
void coreServerTimeout(CoreClient client, u32 timeout, u32 timeoutMin,
                       u32 timeoutMax);
void coreServerDisconnect(CoreClient client);
void coreServerSetConnectHandler(CoreServerOnConnect oc);
void coreServerSetDisconnectHandler(CoreServerOnDisconnect od);
void coreServerSetPacketHandler(CoreServerOnPacket op);
void coreServerResetHandler(void);

#endif