#include "stdafx.h"
#include "nsou.h"

#define addpacket(id, size, desc, ...) netencAddPacket(id, size, desc)

struct packet_data
{
    int size;
    char *desc;
};

#define RFIFOP(pos) (rdata + rdata_pos + (pos))
#define WFIFOP(pos) (wdata + wdata_size + (pos))

#define RFIFOB(pos) (*(unsigned char*)RFIFOP(pos))
#define WFIFOB(pos) (*(unsigned char*)WFIFOP(pos))
#define RFIFOW(pos) (*(unsigned short*)RFIFOP(pos))
#define WFIFOW(pos) (*(unsigned short*)WFIFOP(pos))
#define RFIFOL(pos) (*(unsigned long*)RFIFOP(pos))
#define WFIFOL(pos) (*(unsigned long*)WFIFOP(pos))
#define RFIFOQ(pos) (*(unsigned long long*)RFIFOP(pos))
#define WFIFOQ(pos) (*(unsigned long long*)WFIFOP(pos))

#define RFIFOSPACE() (max_rdata - rdata_size)
#define RFIFOREST()  (rdata_size - rdata_pos)
#define RFIFOSKIP(size) rdata_pos += size

typedef int (PASCAL *ConnectDelegate)(SOCKET s, const struct sockaddr FAR * name, int namelen);
typedef int (PASCAL *SendDelegate)(SOCKET s, char FAR * buf, int len, int flags);
typedef int (PASCAL *RecvDelegate)(SOCKET s, char FAR * buf, int len, int flags);

static ConnectDelegate origConnect;
static SendDelegate origSend;
static RecvDelegate origRecv;

static unsigned char rdata[16 * 1024];
static unsigned char wdata[16 * 1024];
static size_t max_rdata, max_wdata;
static size_t rdata_size, wdata_size;
static size_t rdata_pos;
static unsigned short last_pack;
static unsigned int my_acc_id;
static unsigned int sendonnext;

static struct packet_data packet_len[0x1000];

static bool netencProcessPack(unsigned short cmd, int size)
{
    switch(cmd)
    {
    case 0x69:
            my_acc_id = RFIFOL(8);
            break;
    }

    return true;
}

static int PASCAL newSend(SOCKET s, char FAR * buf, int len, int flags)
{
    return origSend(s, buf, len, flags);
}

static int PASCAL newRecv(SOCKET s, char FAR * buf, int readsize, int flags)
{
    if (sendonnext > 0)
    {
        int len = sendonnext;
        memcpy(buf, rdata, sendonnext);
        RFIFOSKIP(sendonnext);
        sendonnext = 0;
        return len;
    }

    int len = origRecv(s, (char *)rdata + rdata_size, (int)RFIFOSPACE(), 0);
    int tosend = 0;

    if (len <= 0)
        return len;

    rdata_size += len;

    while (RFIFOREST() >= 2)
    {
        unsigned short cmd = RFIFOW(0);

        if (RFIFOL(0) == my_acc_id)
        {
            RFIFOSKIP(4);
            tosend += 4;
            continue;
        }

        if (cmd >= 0x1000)
            return 0;

        int size = packet_len[cmd].size;

        if (size == -1)
        {
            if (RFIFOREST() < 4)
                break;
            else
                size = RFIFOW(2);
        }

        if (RFIFOREST() < size)
            break;

        if (netencProcessPack(cmd, size))
        {
            RFIFOSKIP(size);
            tosend += size;
        }
        else
        {
            int toMove = RFIFOREST() - size;

            memmove(RFIFOP(0), RFIFOP(size), size);

            rdata_size -= size;
        }

        last_pack = cmd;
    }

    if (tosend > readsize)
    {
        sendonnext = tosend - readsize;
        tosend = readsize;
        rdata_pos -= sendonnext;
    }

    memcpy(buf, rdata, tosend);

    if(rdata_size == rdata_pos)
    {
        rdata_size = rdata_pos = 0;
    }
    else
    {
        rdata_size -= rdata_pos;
        memmove(rdata, rdata + rdata_pos, rdata_size);
        rdata_pos = 0;
    }

    return tosend;
}

static void netencAddPacket(unsigned short id, int size, char *desc)
{
    if (id >= 0x1000)
        return;

    packet_len[id].size = size;
    packet_len[id].desc = desc;
}

static int PASCAL newConnect(SOCKET s, const struct sockaddr FAR * name, int namelen)
{
    return origConnect(s, name, namelen);
}

void netencInit()
{
#include "packetdb.ipp"

    max_rdata = 16 * 1024;
    max_wdata = 16 * 1024;

    rdata_size = wdata_size = 0;
    rdata_pos = 0;

    origConnect = Hooks.createHook<ConnectDelegate>((ConnectDelegate)connect, (ConnectDelegate)newConnect);
    origSend = Hooks.createHook<SendDelegate>((SendDelegate)send, (SendDelegate)newSend);
    origRecv = Hooks.createHook<RecvDelegate>((RecvDelegate)recv, (RecvDelegate)newRecv);
}