#include "../resources/resources.h"
#include "puzzle.h"
#include "../wren_inter/wren_inter.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wren.h>

static const char *USER_MODULE_NAME = "main";

/// Returns 1 test puzzle for the GetTestPuzzle segment
Test *getTestPuzzleTests() {
    Test *outp = malloc(sizeof(Test));
    outp->RecieverName = strdup("main");
    outp->MainMethodSignature = strdup("call(_)");

    outp->argc = 1;
    outp->argv = malloc(sizeof(PuzzleIO));
    outp->argv->type = WREN_TYPE_STRING;
    outp->argv->value = strdup("Hello");

    outp->ExpectedResult.type = WREN_TYPE_STRING;
    outp->ExpectedResult.value = strdup("Hello");
    return outp;
}

Puzzle *GetTestPuzzle() {
    Puzzle *outp = malloc(sizeof(Puzzle));
    if (outp == NULL) return NULL;

    outp->Name = strdup("Test puzzle");
    outp->Description = strdup("In this puzzle you will have to return the input string");
    outp->InitialCode = strdup( "var main = Fn.new { |name| \n    System.print(\"Hello, %(name)!\")\n}\n\nmain.call(\"world\")");
    outp->TestC = 1;
    outp->Tests = getTestPuzzleTests();

    return outp;
}

void FreeTests(Test *Tests, size_t TestC) {
    if (TestC == 0 || Tests == NULL) return;
    for (size_t i = 0; i < TestC; i++) {
        Test *t = &Tests[i];
        free(t->RecieverName);
        free(t->MainMethodSignature);
        free(t->argv);
    }
    free(Tests);
}

void FreePuzzle(Puzzle *self) {
    if (self == NULL) return;
    if (self->Name != NULL) free(self->Name);
    if (self->Description != NULL) free(self->Description);
    if (self->InitialCode != NULL) free(self->InitialCode);
    FreeTests(self->Tests, self->TestC);
    free(self);
}

// We are currenttly 
void PutIOIntoSlot(int slot, PuzzleIO *io, WrenVM *vm) {
    switch (io->type) {
        case (WREN_TYPE_BOOL):
            wrenSetSlotBool(vm, slot, *(bool *)io->value);
            break;
        case (WREN_TYPE_NUM):
            wrenSetSlotDouble(vm, slot, *(double *)io->value);
            break;
        case (WREN_TYPE_LIST):
            wrenSetSlotDouble(vm, slot, *(double *)io->value);
            break;
        case (WREN_TYPE_MAP):
            // TODO
            return;
        case (WREN_TYPE_NULL):
            wrenSetSlotNull(vm, slot);
            break;
        case (WREN_TYPE_STRING):
            wrenSetSlotString(vm, slot, io->value);
            break;
        default:
            return;
    }
}

// The cleanest way to do it is move this from the CheckResult enum
bool checkResultString(PuzzleIO *io, WrenVM *vm) {
    const char *res = wrenGetSlotString(vm, 0);
    if (res == NULL || io->value == NULL) return false;
    return strcmp(res, io->value) == 0;
}

bool CheckResult(PuzzleIO *io, WrenVM *vm) {
    WrenType actual_type = wrenGetSlotType(vm, 0);

    switch (io->type) {
        case (WREN_TYPE_BOOL):
            if (actual_type != WREN_TYPE_BOOL) return false;
            if (io->value == NULL) return false;
            return wrenGetSlotBool(vm, 0) == *((bool *)io->value); 

        case (WREN_TYPE_NUM):
            if (actual_type != WREN_TYPE_NUM) return false;
            if (io->value == NULL) return false;
            return wrenGetSlotDouble(vm, 0) == *((double *)io->value); 

        case (WREN_TYPE_NULL):
            return actual_type == WREN_TYPE_NULL;

        case (WREN_TYPE_STRING):
            if (actual_type != WREN_TYPE_STRING) return false;
            return checkResultString(io, vm);

        case (WREN_TYPE_LIST):
        case (WREN_TYPE_MAP):
        default:
            return false;
    }
}

enum PUZZLE_TEST_RESULT RunTest(Test *test, WrenVM *vm, size_t max_op) {
    wrenEnsureSlots(vm, test->argc + 1); // finction handle + arguments
    wrenGetVariable(vm, USER_MODULE_NAME, test->RecieverName, 0);

    WrenHandle *obj_handle = wrenGetSlotHandle(vm, 0);
    if (obj_handle == NULL) {
        return RESULT_COMPTIME_NO_ENTRY;
    }

    WrenHandle *fn_handle = wrenMakeCallHandle(vm, test->MainMethodSignature);
    if (fn_handle == NULL) {
        wrenReleaseHandle(vm, obj_handle);
        return RESULT_COMPTIME_NO_ENTRY;
    }

    wrenSetSlotHandle(vm, 0, obj_handle);
    for (int i = 0; i < test->argc; ++i) {
        PutIOIntoSlot(i+1, &test->argv[i], vm);
    }

    WrenInterpretResult call_result = wrenCallLim(vm, fn_handle, max_op);

    switch (call_result) {
        case WREN_RESULT_COMPILE_ERROR: 
            return RESULT_COMPTIME_ERR;
        case WREN_RESULT_RUNTIME_ERROR: 
            return RESULT_RUNTIME_ERR;
        case WREN_RESULT_RUNTIME_LIMIT:
            return RESULT_TIMEOUT;
        default: break;
    }

    bool result = CheckResult(&test->ExpectedResult, vm);

    wrenReleaseHandle(vm, fn_handle);
    wrenReleaseHandle(vm, obj_handle);

    if (result) {
        return RESULT_OK;
    } else {
        return RESULT_WRONG_ANSWER;
    }
}

// Returns the res ptr. Does not modify the address
SubmitionResult *TryEvaluateUserCode(WrenVM *vm, char *script, SubmitionResult *res, size_t max_op) {
    WrenInterpretResult result = wrenInterpretLim(vm, "main", script, max_op);
    res->result = RESULT_OK;
    switch (result) {
        case WREN_RESULT_COMPILE_ERROR: 
            res->result = RESULT_COMPTIME_ERR;
            return res;
        case WREN_RESULT_RUNTIME_ERROR:
            res->result = RESULT_RUNTIME_ERR;
            return res;
        case WREN_RESULT_RUNTIME_LIMIT:
            res->result = RESULT_TIMEOUT;
            printf("Timeout with max_op %zu\n", max_op);
            return res;
        default: break;
    }
    return res;
}

// Frees the vm. Does not modify the self address.
SubmitionResult *PrepareResult(SubmitionResult *self, 
        WrenVM *vm, 
        enum PUZZLE_TEST_RESULT result) {
    if (vm == NULL || self == NULL) return self;
    self->result = result;
    self->stdout_sb = GetMachineOutput(vm);
    InterpreterFreeMachine(vm);
    return self;
}

SubmitionResult *SubmitSolution(Puzzle *self, char *script) {
    Config *cfg = GetConfig();
    if (self == NULL || script == NULL) return NULL;
    SubmitionResult *res = malloc(sizeof(SubmitionResult));
    
    WrenVM *vm = InterpreterPrepareMachine();
    if (vm == NULL) {
        res->result = RESULT_INIT_ERROR;
        return res;
    }
    
    res = TryEvaluateUserCode(vm, script, res, cfg->MaxOperations);
    if (res->result != RESULT_OK) {
        return PrepareResult(res, vm, res->result);
    }

    for (size_t i = 0; i < self->TestC; i++) {
        enum PUZZLE_TEST_RESULT test_res = RunTest(&self->Tests[i], vm, cfg->MaxOperations);
        switch (test_res) {
            case WREN_RESULT_COMPILE_ERROR:
                return PrepareResult(res, vm, RESULT_COMPTIME_ERR);
            case WREN_RESULT_RUNTIME_ERROR:
                return PrepareResult(res, vm, RESULT_RUNTIME_ERR);
            default: break;
        }
    }

    return PrepareResult(res, vm, RESULT_OK);
}

void FreeSunmitionResult(SubmitionResult *res) {
    if (res->stdout_sb != NULL) free(res->stdout_sb);
    free(res);
}