#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 coreReadInPacketU8(CoreInPacket* in, u8* u);
bool coreReadInPacketU16(CoreInPacket* in, u16* u);
bool coreReadInPacketU32(CoreInPacket* in, u32* u);
bool coreReadInPacketI8(CoreInPacket* in, i8* i);
bool coreReadInPacketI16(CoreInPacket* in, i16* i);
bool coreReadInPacketI32(CoreInPacket* in, i32* i);
bool coreReadInPacketFloat(CoreInPacket* in, float* f);
size_t coreReadInPacketString(CoreInPacket* in, char* buffer, size_t n);
bool coreReadInPacket(CoreInPacket* in, void* buffer, size_t n);

typedef struct {
    CoreBuffer data;
} CoreOutPacket;

void coreInitOutPacket(CoreOutPacket* out);
void coreDestroyOutPacket(CoreOutPacket* out);
void coreWriteOutPacketU8(CoreOutPacket* out, u8 u);
void coreWriteOutPacketU16(CoreOutPacket* out, u16 u);
void coreWriteOutPacketU32(CoreOutPacket* out, u32 u);
void coreWriteOutPacketI8(CoreOutPacket* out, i8 i);
void coreWriteOutPacketI16(CoreOutPacket* out, i16 i);
void coreWriteOutPacketI32(CoreOutPacket* out, i32 i);
void coreWriteOutPacketFloat(CoreOutPacket* out, float f);
void coreWriteOutPacketString(CoreOutPacket* out, const char* buffer);
void coreWriteOutPacket(CoreOutPacket* out, const void* buffer, size_t n);

typedef u16 CorePort;
typedef void (*CoreOnServerConnect)(void);
typedef void (*CoreOnServerDisconnect)(void);
typedef void (*CoreOnServerPacket)(CoreInPacket*);

bool coreStartClient(void);
void coreStopClient(void);
bool coreConnectClient(const char* server, CorePort port, int timeoutTicks);
void coreSetClientTimeout(u32 timeout, u32 timeoutMin, u32 timeoutMax);
void coreDisconnectClient(int timeoutTicks);
void coreSendClientPacket(const CoreOutPacket* p, CorePacketSendMode mode);
void coreTickClient(void);
void coreSetClientConnectHandler(CoreOnServerConnect oc);
void coreSetClientDisconnectHandler(CoreOnServerDisconnect od);
void coreSetClientPacketHandler(CoreOnServerPacket op);
void coreResetClientHandler(void);
bool coreIsClientConnecting(void);
bool coreIsClientConnected(void);

typedef int CoreClient;
typedef void (*CoreOnClientConnect)(CoreClient);
typedef void (*CoreOnClientDisconnect)(CoreClient);
typedef void (*CoreOnClientPacket)(CoreClient, CoreInPacket*);

bool coreStartServer(CorePort port, size_t maxClients);
void coreStopServer(void);
void coreTickServer(void);
void coreSendServerPacketBroadcast(const CoreOutPacket* p,
                                   CorePacketSendMode mode);
void coreSendServerPacket(CoreClient client, const CoreOutPacket* p,
                          CorePacketSendMode mode);
void coreServerTimeout(CoreClient client, u32 timeout, u32 timeoutMin,
                       u32 timeoutMax);
void coreDisconnectServerClient(CoreClient client);
void coreSetServerConnectHandler(CoreOnClientConnect oc);
void coreSetServerDisconnectHandler(CoreOnClientDisconnect od);
void coreSetServerPacketHandler(CoreOnClientPacket op);
void coreResetServerHandler(void);

#endif