#include "internal.h"
#include "../log.h"
#include <stdlib.h>

bool parse_primitive_type_expression(Parser* p, TypeExpression* expr) {
    if (parser_accept(p, TOKEN_U8)) {
        expr->tag = TYPE_EXPRESSION_BUILTIN;
        expr->builtin.bitSize = 8;
        expr->builtin.isSigned = false;
        return true;
    } else if (parser_accept(p, TOKEN_U16)) {
        expr->tag = TYPE_EXPRESSION_BUILTIN;
        expr->builtin.bitSize = 16;
        expr->builtin.isSigned = false;
        return true;
    } else if (parser_accept(p, TOKEN_U32)) {
        expr->tag = TYPE_EXPRESSION_BUILTIN;
        expr->builtin.bitSize = 32;
        expr->builtin.isSigned = false;
        return true;
    } else if (parser_accept(p, TOKEN_U64)) {
        expr->tag = TYPE_EXPRESSION_BUILTIN;
        expr->builtin.bitSize = 64;
        expr->builtin.isSigned = false;
        return true;
    } else if (parser_accept(p, TOKEN_I8)) {
        expr->tag = TYPE_EXPRESSION_BUILTIN;
        expr->builtin.bitSize = 8;
        expr->builtin.isSigned = true;
        return true;
    } else if (parser_accept(p, TOKEN_I16)) {
        expr->tag = TYPE_EXPRESSION_BUILTIN;
        expr->builtin.bitSize = 16;
        expr->builtin.isSigned = true;
        return true;
    } else if (parser_accept(p, TOKEN_I32)) {
        expr->tag = TYPE_EXPRESSION_BUILTIN;
        expr->builtin.bitSize = 32;
        expr->builtin.isSigned = true;
        return true;
    } else if (parser_accept(p, TOKEN_I64)) {
        expr->tag = TYPE_EXPRESSION_BUILTIN;
        expr->builtin.bitSize = 64;
        expr->builtin.isSigned = true;
        return true;
    } else {
        log_on_line(&p->token.location, "expected type expression");
        return false;
    }
}

bool parse_array_type_expression(Parser* p, TypeExpression* expr) {
    TypeExpression elementType;
    if (!parse_primitive_type_expression(p, &elementType)) {
        return false;
    }

    if (parser_accept(p, TOKEN_BRACKET_OPEN)) {
        expr->tag = TYPE_EXPRESSION_ARRAY;
        expr->array.array = malloc(sizeof(TypeExpression));
        *expr->array.array = elementType;

        if (!parser_expect(p, TOKEN_BRACKET_CLOSE, "expected ']' to end array type")) {
            return false;
        }
    } else {
         *expr = elementType;
         return true;
    }
    return true;
}

bool parse_type_expression(Parser* p, TypeExpression* expr) {
    return parse_array_type_expression(p, expr);
}

bool parse_expression(Parser* p, Expression* expr) {
    if (parser_peek(p, TOKEN_INTEGER)) {
        expr->tag = EXPRESSION_INTEGER;
        expr->integer = atoi(p->token.text.data);
        parser_next_token(p);
        return true;
    } else if (parser_peek(p, TOKEN_STRING)) {
        expr->tag = EXPRESSION_STRING;
        expr->string = parser_to_text(p);
        return true;
    } else if (parser_accept(p, TOKEN_TRUE)) {
        expr->tag = EXPRESSION_BOOLEAN;
        expr->boolean = true;
        return true;
    } else if (parser_accept(p, TOKEN_FALSE)) {
        expr->tag = EXPRESSION_BOOLEAN;
        expr->boolean = false;
        return true;
    }
    log_on_line(&p->token.location, "expected expression");
    return false;
}

void free_type_expression(TypeExpression* expr) {
    if (expr->tag == TYPE_EXPRESSION_ARRAY) {
        free_type_expression(expr->array.array);
        free(expr->array.array);
    }
}