/*
 * Created by yuuta on 7/20/22.
 */

#include "libac.h"

#include <stdio.h>
#ifdef WIN32
#include <winsock2.h>
#include <windef.h>
#endif

static const char *world_name(const enum ac_world world) {
    switch (world) {
        case overworld:
            return "overworld";
        case nether:
            return "nether";
        case end:
            return "end";
        default:
            return "unknown world";
    }
}

static void handle_event(const ac_event_t *event) {
    switch (event->type) {
        case AC_EVENT_LAGGING: {
            ac_event_lagging_t *o = (ac_event_lagging_t *) event;
            printf("Server lagging: running %ld milliseconds (%ld ticks) behind.\n",
                   o->ms,
                   o->ticks);
            break;
        }
        case AC_EVENT_ENTITY_DEATH: {
            ac_event_entity_death_t *o = (ac_event_entity_death_t *) event;
            printf("Entity '%s' died at %s(%.2f, %.2f, %.2f): %s.\n",
                   o->entity.name,
                   world_name(o->entity.world),
                   o->entity.pos.x,
                   o->entity.pos.y,
                   o->entity.pos.z,
                   o->message);
            break;
        }
        case AC_EVENT_PLAYER_MESSAGE: {
            ac_event_player_message_t *o = (ac_event_player_message_t *) event;
            printf("Player '%s' said at %s(%.2f, %.2f, %.2f): %s.\n",
                   o->player.name,
                   world_name(o->player.world),
                   o->player.pos.x,
                   o->player.pos.y,
                   o->player.pos.z,
                   o->text);
            break;
        }
        case AC_EVENT_PLAYER_DISCONNECT: {
            ac_event_player_disconnect_t *o = (ac_event_player_disconnect_t *) event;
            printf("Player '%s' disconnected at %s(%.2f, %.2f, %.2f): %s.\n",
                   o->player.name,
                   world_name(o->player.world),
                   o->player.pos.x,
                   o->player.pos.y,
                   o->player.pos.z,
                   o->reason);
            break;
        }
        case AC_EVENT_PLAYER_JOIN: {
            ac_event_player_join_t *o = (ac_event_player_join_t *) event;
            printf("Player '%s' joined at %s(%.2f, %.2f, %.2f).\n",
                   o->player.name,
                   world_name(o->player.world),
                   o->player.pos.x,
                   o->player.pos.y,
                   o->player.pos.z);
            break;
        }
        default: {
            printf("Received an unrecognized event of type '%u'.\n",
                   event->type);
        }
    }
}

static void handle_response(const ac_response_t *response) {
    switch (response->type) {
        case AC_RESPONSE_OK: {
            ac_response_ok_t *o = (ac_response_ok_t *) response;
            printf("Request %d OK.\n",
                   o->id);
            break;
        }
        case AC_RESPONSE_ERROR: {
            ac_response_error_t *o = (ac_response_error_t *) response;
            printf("Request %d failed: %s (%d).\n",
                   o->id,
                   o->message,
                   o->code);
            break;
        }
        case AC_RESPONSE_CMD_OUT: {
            ac_response_cmd_out_t *o = (ac_response_cmd_out_t *) response;
            printf("Request %d output by %s: %s.\n",
                   o->id,
                   o->sender,
                   o->out);
            break;
        }
        case AC_RESPONSE_CMD_RESULT: {
            ac_response_cmd_result_t *o = (ac_response_cmd_result_t *) response;
            printf("Request %d is done: %s (%d).\n",
                   o->id,
                   o->success ? "Success" : "Failed",
                   o->result);
            break;
        }
        default: {
            printf("Received an unrecognized response of type '%u'.\n",
                   response->type);
        }
    }
}

int main(int argc, char **argv) {
    int r;
#ifdef WIN32
    WORD wVersionRequested;
    WSADATA wsaData;
    wVersionRequested = MAKEWORD(2, 2);
    if ((r = WSAStartup(wVersionRequested, &wsaData))) {
        fprintf(stderr, "WSAStartup failed with error: %d\n", r);
        return r;
    }
    if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
        fprintf(stderr, "Could not find a usable version of Winsock.dll\n");
        WSACleanup();
        return 1;
    }
#endif
    libac_config_t config = {
#ifdef DEBUG
            .out = stderr,
#else
            .out = NULL,
#endif
            .tok = NULL
    };
    if ((r = ac_init(&config))) return r;
    void *connection;
    ac_connection_parameters_t parameters = {
            .host = "localhost",
            .port = 25575,
            .id = "1",
            .token = "123",
            .version = 0
    };
    if ((r = ac_connect(parameters, &connection))) {
        ac_free();
        return r;
    }
    ac_obj_t *obj;
    ac_config_t conf = {
            .name = "acronc"
    };
    ac_request_cmd_t req = {
            .type = AC_REQUEST_CMD,
            .id = 100,
            .config = &conf,
            .cmd = "say Hi"
    };
    if ((r = ac_request(connection, (ac_request_t *) &req))) {
        ac_disconnect(connection);
        ac_free();
        return r;
    }
    while (!(r = ac_receive(connection, &obj, 10))) {
        if (!obj) {
            continue;
        }
        if (AC_IS_EVENT(obj->type)) {
            handle_event((ac_event_t *) obj);
        } else if (AC_IS_RESPONSE(obj->type)) {
            handle_response((ac_response_t *) obj);
        }
        ac_object_free(obj);
    }
    ac_disconnect(connection);
    ac_free();
#ifdef WIN32
    WSACleanup();
#endif
    return r;
}