#include <sstream>

#include "types.h"

namespace types {
    int operator_precedence(BinOp& op) {
        switch (op) {
        case BinOp::Add:
        case BinOp::Sub:
            return 10;

        case BinOp::LessThan:
        case BinOp::GreaterThan:
            return 20;

        case BinOp::Assignment:
            return 1000;
        default:
            return 1000;
        }
    }

    std::string format_operator(BinOp& op) {
        switch (op) {
        case BinOp::Assignment:
            return "=";
        case BinOp::Add:
            return "+";
        case BinOp::Sub:
            return "-";
        case BinOp::LessThan:
            return "<";
        case BinOp::GreaterThan:
            return ">";
        default:
            return "??";
        }
    }

    std::string FundamentalType::formatted() {
        switch (this->m_ty) {
        case FundamentalTypeKind::Int:
            return "Int";
        case FundamentalTypeKind::Bool:
            return "Bool";
        case FundamentalTypeKind::Char:
            return "Char";
        case FundamentalTypeKind::Void:
            return "Void";
        default:
            return "Unknown";
        }
    }


    llvm::Value* Type::add(codegen::Builder&, llvm::Value*, llvm::Value*) {
        throw std::runtime_error("Invalid operation for this type");
    }

    llvm::Value* Type::sub(codegen::Builder&, llvm::Value*, llvm::Value*) {
        throw std::runtime_error("Invalid operation for this type");
    }

    llvm::Value* Type::lt(codegen::Builder&, llvm::Value*, llvm::Value*) {
        throw std::runtime_error("Invalid operation for this type");
    }

    llvm::Value* Type::gt(codegen::Builder&, llvm::Value*, llvm::Value*) {
        throw std::runtime_error("Invalid operation for this type");
    }

    std::optional<std::shared_ptr<Type>> Type::return_type() {
        return {};
    }

    std::pair<llvm::Value*, std::shared_ptr<Type>> FundamentalType::load(codegen::Builder&, llvm::Value* ptr) {
        auto self = std::make_shared<FundamentalType>(*this);
        return std::pair(ptr, self);
    }

    llvm::Value* FundamentalType::add(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs) {
        switch (this->m_ty) {
        case FundamentalTypeKind::Int:
        case FundamentalTypeKind::Bool:
        case FundamentalTypeKind::Char:
            return builder.builder->CreateAdd(lhs, rhs, "add");
        default:
            throw std::runtime_error("Invalid type for add");
        }
    }

    llvm::Value* FundamentalType::sub(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs) {
        switch (this->m_ty) {
        case FundamentalTypeKind::Int:
        case FundamentalTypeKind::Bool:
        case FundamentalTypeKind::Char:
            return builder.builder->CreateSub(lhs, rhs, "sub");
        default:
            throw std::runtime_error("Invalid type");
        }
    }

    llvm::Value* FundamentalType::lt(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs) {
        switch (this->m_ty) {
        case FundamentalTypeKind::Int:
        case FundamentalTypeKind::Bool:
        case FundamentalTypeKind::Char:
            return builder.builder->CreateCmp(llvm::CmpInst::Predicate::ICMP_SLT, lhs, rhs, "cmp");
        default:
            throw std::runtime_error("Invalid type");
        }
    }

    llvm::Value* FundamentalType::gt(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs) {
        switch (this->m_ty) {
        case FundamentalTypeKind::Int:
        case FundamentalTypeKind::Bool:
        case FundamentalTypeKind::Char:
            return builder.builder->CreateCmp(llvm::CmpInst::Predicate::ICMP_SGT, lhs, rhs);
        default:
            throw std::runtime_error("Invalid type");
        }
    }

    std::string FunctionType::formatted() {
        std::stringstream out{ "" };
        out << "(";

        int counter = 0;
        for (auto& param : this->m_param_tys) {
            if (counter++ > 0)
                out << ", ";
            out << param->formatted();
        }

        if (this->m_vararg) {
            if (counter > 0)
                out << ", ";
            out << "...";
        }

        out << ") -> " << this->m_ret_ty->formatted();
        return out.str();
    }

    std::optional<std::shared_ptr<Type>> FunctionType::return_type() {
        return this->m_ret_ty;
    }

    std::pair<llvm::Value*, std::shared_ptr<Type>> FunctionType::load(codegen::Builder&, llvm::Value* ptr) {
        auto self = std::make_shared<FunctionType>(*this);
        return std::pair(ptr, self);
    }

    std::string PointerType::formatted() {
        std::stringstream out{ "" };
        out << this->m_inner->formatted() << "*";
        return out.str();
    }

    std::pair<llvm::Value*, std::shared_ptr<Type>> PointerType::load(codegen::Builder& builder, llvm::Value* ptr) {
        return std::pair(
            builder.builder->CreateLoad(this->m_inner->codegen(builder), ptr),
            this->m_inner
        );
    }
}