#include "types.h"
#include <inttypes.h>

GroundValue createIntGroundValue(int64_t in) {
    GroundValue gv;
    gv.data.intVal = in;
    gv.type = INT;
    return gv;
}

GroundValue createDoubleGroundValue(double in) {
    GroundValue gv;
    gv.data.doubleVal = in;
    gv.type = DOUBLE;
    return gv;
}

GroundValue createStringGroundValue(const char* in) {
    GroundValue gv;
    gv.data.stringVal = strdup(in);
    gv.type = STRING;
    return gv;
}

GroundValue createCharGroundValue(char in) {
    GroundValue gv;
    gv.data.charVal = in;
    gv.type = CHAR;
    return gv;
}

GroundValue createBoolGroundValue(bool in) {
    GroundValue gv;
    gv.data.boolVal = in;
    gv.type = BOOL;
    return gv;
}

void printGroundValue(GroundValue* gv) {
    switch (gv->type) {
        case INT: {
            printf("%" PRId64 "", gv->data.intVal);
            break;
        }
        case DOUBLE: {
            printf("%f", gv->data.doubleVal);
            break;
        }
        case STRING: {
            printf("%s", gv->data.stringVal);
            break;
        }
        case CHAR: {
            printf("%c", gv->data.charVal);
            break;
        }
        case BOOL: {
            if (gv->data.boolVal) {
                printf("true");
            } else {
                printf("false");
            }
            break;
        }
        default: {
            printf("FIXME");
            break;
        }
    }
}

void freeGroundValue(GroundValue* gv) {
    if (gv->type == STRING && gv->data.stringVal != NULL) {
        free(gv->data.stringVal);
    }
}

GroundArg createValueGroundArg(GroundValue value) {
    GroundArg ga;
    ga.value.value = value;
    ga.type = VALUE;
    return ga;
}

GroundArg createRefGroundArg(GroundArgType type, const char* refname) {
    GroundArg ga;
    ga.value.refName = strdup(refname);
    ga.type = type;
    return ga;
}

void freeGroundArg(GroundArg* ga) {
    if (ga->type == VALUE) {
        freeGroundValue(&ga->value.value);
    } else {
        free(ga->value.refName);
    }
}

void printGroundArg(GroundArg* ga) {
    switch (ga->type) {
        case VALUE: {
            printGroundValue(&ga->value.value);
            break;
        }
        case DIRREF: {
            printf("&%s", ga->value.refName);
            break;
        }
        case VALREF: {
            printf("$%s", ga->value.refName);
            break;
        }
        case LINEREF: {
            printf("%%%s", ga->value.refName);
            break;
        }
        case LABEL: {
            printf("@%s", ga->value.refName);
            break;
        }
        case FNREF: {
            printf("!%s", ga->value.refName);
            break;
        }
        case TYPEREF: {
            printf("-%s", ga->value.refName);
            break;
        }
    }
}

GroundInstruction createGroundInstruction(GroundInstType type) {
    GroundInstruction gi;
    gi.type = type;
    gi.args.args = NULL;
    gi.args.length = 0;
    return gi;
}

void freeGroundInstruction(GroundInstruction* gi) {
    for (size_t i = 0; i < gi-> args.length; i++) {
        freeGroundArg(&gi->args.args[i]);
    }
}

void addArgToInstruction(GroundInstruction* gi, GroundArg arg) {
    gi->args.length ++;
    GroundArg* newArgs = realloc(gi->args.args, gi->args.length * sizeof(GroundArg));
    if (newArgs == NULL) {
        perror("Failed to allocate memory for instruction argument");
        exit(EXIT_FAILURE);
    }
    gi->args.args = newArgs;
    gi->args.args[gi->args.length - 1] = arg;
}

void printGroundInstruction(GroundInstruction* gi) {
    switch (gi->type) {
        case IF:
            printf("if");
            break;
        case JUMP:
            printf("jump");
            break;
        case END:
            printf("end");
            break;
        case INPUT:
            printf("input");
            break;
        case PRINT:
            printf("print");
            break;
        case PRINTLN:
            printf("println");
            break;
        case SET:
            printf("set");
            break;
        case GETTYPE:
            printf("gettype");
            break;
        case EXISTS:
            printf("exists");
            break;
        case SETLIST:
            printf("setlist");
            break;
        case SETLISTAT:
            printf("setlistat");
            break;
        case GETLISTAT:
            printf("getlistat");
            break;
        case GETLISTSIZE:
            printf("getlistsize");
            break;
        case LISTAPPEND:
            printf("listappend");
            break;
        case GETSTRSIZE:
            printf("getstrsize");
            break;
        case GETSTRCHARAT:
            printf("getstrcharat");
            break;
        case ADD:
            printf("add");
            break;
        case SUBTRACT:
            printf("subtract");
            break;
        case MULTIPLY:
            printf("multiply");
            break;
        case DIVIDE:
            printf("divide");
            break;
        case EQUAL:
            printf("equal");
            break;
        case INEQUAL:
            printf("inequal");
            break;
        case NOT:
            printf("not");
            break;
        case GREATER:
            printf("greater");
            break;
        case LESSER:
            printf("lesser");
            break;
        case STOI:
            printf("stoi");
            break;
        case STOD:
            printf("stod");
            break;
        case TOSTRING:
            printf("tostring");
            break;
        case FUN:
            printf("fun");
            break;
        case RETURN:
            printf("return");
            break;
        case ENDFUN:
            printf("endfun");
            break;
        case PUSHARG:
            printf("pusharg");
            break;
        case CALL:
            printf("call");
            break;
        case STRUCT:
            printf("struct");
            break;
        case ENDSTRUCT:
            printf("endstruct");
            break;
        case INIT:
            printf("init");
            break;
        case USE:
            printf("use");
            break;
        case EXTERN:
            printf("extern");
            break;
        case CREATELABEL:
            printf("createlabel");
            break;
        default:
            printf("FIXME");
            break;
    }
    printf(" ");
    for (int i = 0; i < gi->args.length; i++) {
        printGroundArg(&gi->args.args[i]);
        printf(" ");
    }
}