#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <uv.h>
#include "mcp.h"

typedef struct {
    int state;
    uv_buf_t buf;
    int32_t read_len;
    uv_tcp_t tcp;
    uv_connect_t connect_req;
    uv_shudown_t shutdown_req;
} client_t;

static mcp_hs00_t handshake = {
    .protocol_version = 5,
    .addr_len         = strlen("127.0.0.1"),
    .server_addr      = "127.0.0.1",
    .server_port      = 25565,
    .next_state       = 2
};

static mcp_ss00_t ping_req;

void buf_alloc(uv_handle_t *tcp, size_t size, uv_buf_t *buf) {
    *buf = uv_buf_init(malloc(size), size);
}

void pinger_close_cb(uv_handle_t* handle) {
    //ToDo: Implement
}

void client_write_cb(uv_write_t *req, int status) {
    free(req->data);
    free(req)
}

void client_read_cb(uv_stream_t *tcp, ssize_t nread, const uv_buf_t *buf) {
    client_t *client = (client_t*)tcp->data;

    if(nread<0) {
        if (buf->base) {
            free(buf->base);
        }
        free(base);
        uv_close((uv_handle_t*)tcp, client_close_cb);
        return;
    }

    if(client->read_len < 0) {

    }
}

void client_write_handshake(client_t *client) {
    uv_write_t *req;
    uv_buf_t buf;
    uint8_t pbuf[4096];
    int ret = mcp_encode_hs00(pbuf, &handshake, 4096);
    buf = uv_buf_init(memcpy(malloc(ret), pbuf, ret), ret);
    req = malloc(sizeof(*req));
    req->data = buf.base;
    client->state = 0x02;
    uv_write(req, (uv_stream_t*)&client->tcp, &buf, 1, client_write_cb);
}

void client_write_pingreq(client_t *client) {
    uv_write_t *req;
    uv_buf_t buf;
    uint8_t pbuf[4096];
    int ret = mcp_encode_ss00(pbuf, &ping_req, 4096);
    buf = uv_buf_init(memcpy(malloc(ret), pbuf, ret), ret);
    req = malloc(sizeof(*req));
    req->data = buf.base;
    uv_write(req, (uv_stream_t*)&client->tcp, &buf, 1, client_write_cb);
}

void client_connect_cb(uv_connect_t *req, int status) {
    client_t *client = (client_t*)req->handle->data;
    client_write_handshake(client);
    client_write_pingreq(client);
    uv_read_start(req->handle, buf_alloc, client_read_cb);
}

int main(int argc, char *argv[]) {
    struct sockaddr_in server_addr;
    uv_loop_t *loop = uv_default_loop();
    client_t myclient;
    uv_ip4_addr("127.0.0.1", 25565, &server_addr);
    uv_tcp_init(loop, &myclient.tcp);
    myclient.state = 0;
    myclient.buf.len = 4096;
    myclient.buf.base = malloc(4096);
    myclient.tcp.data = &myclient;
    uv_tcp_connect(
        &myclient.connect_req,
        &myclient.tcp,
        (struct sockaddr*)&server_addr,
        client_connect_cb
    );
    return uv_run(loop, UV_RUN_DEFAULT);
}