#include <memory>
#include "Binder.hpp"
#include "../ScriptTypes/TableScriptType.hpp"
#include "BoundExpressions/BoundTableExpression.hpp"
#include "BoundExpressions/BoundFunctionCallExpression.hpp"
#include "BoundExpressions/BoundRequireExpression.hpp"
#include "../UserData/UserDataScriptType.hpp"

using namespace Porygon::Parser;

namespace Porygon::Binder {
    BoundScriptStatement *Binder::Bind(Script *script, const ParsedScriptStatement *s, BoundScope *scriptScope) {
        auto binder = Binder();
        binder._scriptData = script;

        binder._scope = scriptScope;
        auto statements = s->GetStatements();
        vector<const BoundStatement *> boundStatements(statements->size());
        for (size_t i = 0; i < statements->size(); i++) {
            boundStatements[i] = binder.BindStatement(statements->at(i));
        }
        return new BoundScriptStatement(boundStatements, scriptScope->GetLocalVariableCount());
    }

    Binder::~Binder() {
        delete _scope;
    }

    BoundStatement *Binder::BindStatement(const ParsedStatement *statement) {
        switch (statement->GetKind()) {
            case ParsedStatementKind::Script:
                throw; // This shouldn't happen.
            case ParsedStatementKind::Block:
                return this->BindBlockStatement(statement);
            case ParsedStatementKind::Expression:
                return this->BindExpressionStatement(statement);
            case ParsedStatementKind::Assignment:
                return this->BindAssignmentStatement(statement);
            case ParsedStatementKind::IndexAssignment:
                return this->BindIndexAssignmentStatement(statement);
            case ParsedStatementKind::FunctionDeclaration:
                return this->BindFunctionDeclarationStatement(statement);
            case ParsedStatementKind::Return:
                return this->BindReturnStatement(statement);
            case ParsedStatementKind::Conditional:
                return this->BindConditionalStatement(statement);
            case ParsedStatementKind::NumericalFor:
                return this->BindNumericalForStatement(statement);
            case ParsedStatementKind::GenericFor:
                return this->BindGenericForStatement(statement);
            case ParsedStatementKind::While:
                return this->BindWhileStatement(statement);
            case ParsedStatementKind::Break:
                //TODO: Validate we're in a loop
                return new BoundBreakStatement();
            case ParsedStatementKind::Bad:
                return new BoundBadStatement();
        }
        throw "unreachable";
    }

    BoundStatement *Binder::BindBlockStatement(const ParsedStatement *statement) {
        auto statements = ((ParsedBlockStatement *) statement)->GetStatements();
        vector<const BoundStatement *> boundStatements(statements->size());
        this->_scope->GoInnerScope();
        for (size_t i = 0; i < statements->size(); i++) {
            boundStatements[i] = this->BindStatement(statements->at(i));
        }
        this->_scope->GoOuterScope();
        return new BoundBlockStatement(boundStatements);
    }

    BoundStatement *Binder::BindExpressionStatement(const ParsedStatement *statement) {
        auto exp = ((ParsedExpressionStatement *) statement)->GetExpression();
        return new BoundExpressionStatement(this->BindExpression(exp));
    }

    BoundStatement *Binder::BindAssignmentStatement(const ParsedStatement *statement) {
        auto s = (ParsedAssignmentStatement *) statement;
        auto boundExpression = this->BindExpression(s->GetExpression());
        VariableAssignment assignment =
                s->IsLocal() ?
                this->_scope->CreateExplicitLocal(s->GetIdentifier(), boundExpression->GetType())
                             : this->_scope->AssignVariable(s->GetIdentifier(), boundExpression->GetType());
        if (assignment.GetResult() == VariableAssignmentResult::Ok) {
            auto key = assignment.GetKey();
            return new BoundAssignmentStatement(key, boundExpression);
        } else {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::CantAssignVariable,
                                                     statement->GetStartPosition(),
                                                     statement->GetLength());
            return new BoundBadStatement();
        }
    }

    BoundStatement *Binder::BindIndexAssignmentStatement(const ParsedStatement *statement) {
        auto s = (ParsedIndexAssignmentStatement *) statement;
        auto indexExp = s->GetIndexExpression();
        const BoundExpression *indexable;
        if (indexExp->GetKind() == ParsedExpressionKind::Indexer) {
            indexable = this->BindIndexExpression((IndexExpression *) indexExp, true);
        } else {
            indexable = this->BindPeriodIndexExpression((PeriodIndexExpression *) indexExp, true);
        }
        auto valueExpression = this->BindExpression(s->GetValueExpression());
        auto boundIndexType = indexable->GetType();
        if (boundIndexType->GetClass() != TypeClass::Error &&
            boundIndexType->operator!=(valueExpression->GetType())) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::InvalidTableValueType,
                                                     statement->GetStartPosition(), statement->GetLength());
            return new BoundBadStatement();
        }

        return new BoundIndexAssignmentStatement(indexable, valueExpression);
    }

    std::shared_ptr<const ScriptType> ParseTypeIdentifier(const HashedString *s) {
        auto hash = s->GetHash();
        switch (hash) {
            case HashedString::ConstHash("number"):
                return NumericScriptType::Unaware;
            case HashedString::ConstHash("bool"):
                return ScriptType::BoolType;
            case HashedString::ConstHash("string"):
                return StringScriptType::Dynamic;
            case HashedString::ConstHash(("any")):
                return ScriptType::AnyType;
            case HashedString::ConstHash("table"):
                return make_shared<TableScriptType>();
            default:
                if (!UserData::UserDataStorage::HasUserDataType(hash)) {
                    return nullptr;
                }
                return std::make_shared<UserData::UserDataScriptType>(hash);
        }
    }

    BoundStatement *Binder::BindFunctionDeclarationStatement(const ParsedStatement *statement) {
        auto functionStatement = (ParsedFunctionDeclarationStatement *) statement;
        auto parameters = functionStatement->GetParameters();
        auto parameterTypes = vector<shared_ptr<const ScriptType>>(parameters->size());
        auto parameterKeys = vector<shared_ptr<const BoundVariableKey>>(parameters->size());

        this->_scope->GoInnerScope();
        for (size_t i = 0; i < parameters->size(); i++) {
            auto var = parameters->at(i);
            auto parsedType = ParseTypeIdentifier(var->GetType());
            if (parsedType == nullptr) {
                this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::InvalidTypeName,
                                                         statement->GetStartPosition(),
                                                         statement->GetLength());
                return new BoundBadStatement();
            }
            parameterTypes.at(i) = parsedType;
            auto parameterAssignment = this->_scope->CreateExplicitLocal(*var->GetIdentifier(), parsedType);
            if (parameterAssignment.GetResult() == VariableAssignmentResult::Ok) {
                parameterKeys.at(i) = std::shared_ptr<const BoundVariableKey>(parameterAssignment.GetKey());
            } else {
                //TODO: log error
                continue;
            }
        }

        auto identifier = functionStatement->GetIdentifier();
        auto returnType = ScriptType::NilType;
        auto option = new ScriptFunctionOption(returnType, parameterTypes, parameterKeys);
        this->_currentFunction = option;

        shared_ptr<const GenericFunctionScriptType> type;
        auto scope = this->_scope->Exists(identifier);
        const BoundVariableKey *assignmentKey;
        if (scope >= 0) {
            auto var = this->_scope->GetVariable(scope, identifier);
            auto varType = var->GetType();
            if (varType->GetClass() != TypeClass::Function) {
                this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::CantAssignVariable,
                                                         statement->GetStartPosition(),
                                                         statement->GetLength());
            }
            type = dynamic_pointer_cast<const GenericFunctionScriptType>(varType);
            type->RegisterFunctionOption(option);
            assignmentKey = new BoundVariableKey(identifier, scope, false, type);
        } else {
            type = make_shared<const GenericFunctionScriptType>();
            type->RegisterFunctionOption(option);
            auto assignment = this->_scope->AssignVariable(identifier, type);
            if (assignment.GetResult() != VariableAssignmentResult::Ok) {
                this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::CantAssignVariable,
                                                         statement->GetStartPosition(),
                                                         statement->GetLength());
                return new BoundBadStatement();
            }
            assignmentKey = assignment.GetKey();
        }

        auto boundBlock = dynamic_cast<BoundBlockStatement *>(this->BindBlockStatement(functionStatement->GetBlock()));
        this->_scope->GoOuterScope();
        this->_currentFunction = nullptr;
        return new BoundFunctionDeclarationStatement(type, assignmentKey, boundBlock);
    }

    BoundStatement *Binder::BindReturnStatement(const ParsedStatement *statement) {
        auto expression = ((ParsedReturnStatement *) statement)->GetExpression();
        shared_ptr<const ScriptType> currentReturnType;
        if (this->_currentFunction == nullptr) {
            currentReturnType = this->_scriptData->GetReturnType();
        } else {
            currentReturnType = this->_currentFunction->GetReturnType();
        }
        if (expression == nullptr &&
            (currentReturnType != nullptr && currentReturnType->GetClass() != TypeClass::Nil)) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::InvalidReturnType,
                                                     statement->GetStartPosition(),
                                                     statement->GetLength());
            return new BoundBadStatement();
        } else if (expression == nullptr) {
            currentReturnType = ScriptType::NilType;
            return new BoundReturnStatement(nullptr);
        }
        auto boundExpression = this->BindExpression(expression);
        auto expresionType = boundExpression->GetType();
        if (currentReturnType == nullptr || currentReturnType->GetClass() == TypeClass::Nil) {
            if (this->_currentFunction == nullptr) {
                this->_scriptData->SetReturnType(expresionType);
            } else {
                this->_currentFunction->SetReturnType(expresionType);
            }
            return new BoundReturnStatement(boundExpression);
        }
        if (currentReturnType.get()->operator!=(expresionType)) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::InvalidReturnType,
                                                     statement->GetStartPosition(),
                                                     statement->GetLength());
            return new BoundBadStatement();
        }
        return new BoundReturnStatement(boundExpression);
    }

    BoundStatement *Binder::BindConditionalStatement(const ParsedStatement *statement) {
        auto conditionalStatement = (ParsedConditionalStatement *) statement;
        auto boundCondition = this->BindExpression(conditionalStatement->GetCondition());
        if (boundCondition->GetType()->GetClass() != TypeClass::Bool) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::ConditionNotABool,
                                                     statement->GetStartPosition(),
                                                     statement->GetLength());
            return new BoundBadStatement();
        }
        auto boundBlock = this->BindStatement(conditionalStatement->GetBlock());
        BoundStatement *elseStatement = nullptr;
        if (conditionalStatement->GetElseStatement() != nullptr) {
            elseStatement = this->BindStatement(conditionalStatement->GetElseStatement());
        }
        return new BoundConditionalStatement(boundCondition, boundBlock, elseStatement);
    }

    BoundStatement *Binder::BindNumericalForStatement(const ParsedStatement *statement) {
        auto forStatement = (ParsedNumericalForStatement *) statement;
        auto identifier = forStatement->GetIdentifier();
        auto start = this->BindExpression(forStatement->GetStart());
        auto end = this->BindExpression(forStatement->GetEnd());
        auto parsedStep = forStatement->GetStep();
        BoundExpression *step = nullptr;
        if (parsedStep != nullptr) {
            step = this->BindExpression(parsedStep);
        }
        if (start->GetType()->GetClass() != TypeClass::Number) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::NumericalForArgumentNotANumber,
                                                     start->GetStartPosition(),
                                                     start->GetLength());
            return new BoundBadStatement();
        }
        if (end->GetType()->GetClass() != TypeClass::Number) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::NumericalForArgumentNotANumber,
                                                     end->GetStartPosition(),
                                                     end->GetLength());
            return new BoundBadStatement();
        }
        if (step != nullptr && step->GetType()->GetClass() != TypeClass::Number) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::NumericalForArgumentNotANumber,
                                                     step->GetStartPosition(),
                                                     step->GetLength());
            return new BoundBadStatement();
        }

        this->_scope->GoInnerScope();
        auto variableKey = this->_scope->CreateExplicitLocal(identifier, NumericScriptType::AwareInt);
        if (variableKey.GetResult() != VariableAssignmentResult::Ok) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::CantAssignVariable,
                                                     statement->GetStartPosition(),
                                                     statement->GetLength());
            return new BoundBadStatement();
        }
        auto block = this->BindBlockStatement(forStatement->GetBlock());
        this->_scope->GoOuterScope();
        return new BoundNumericalForStatement(variableKey.GetKey(), start, end, step, block);
    }

    BoundStatement *Binder::BindGenericForStatement(const ParsedStatement *statement) {
        auto genericFor = (ParsedGenericForStatement *) statement;
        auto boundIterator = BindExpression(genericFor->GetIteratorExpression());
        const auto &itType = boundIterator->GetType();
        if (!itType->CanBeIterated()) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::CantIterateExpression,
                                                     statement->GetStartPosition(),
                                                     statement->GetLength());
            return new BoundBadStatement();
        }
        auto keyType = itType->GetIteratorKeyType();
        auto keyIdentifier = genericFor->GetKeyIdentifier();
        this->_scope->GoInnerScope();
        auto keyVariableAssignment = this->_scope->CreateExplicitLocal(keyIdentifier, keyType);
        if (keyVariableAssignment.GetResult() != VariableAssignmentResult::Ok) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::CantAssignVariable,
                                                     statement->GetStartPosition(),
                                                     statement->GetLength());
            return new BoundBadStatement();
        }
        auto keyVariable = keyVariableAssignment.GetKey();

        auto valueIdentifier = genericFor->GetValueIdentifier();
        auto isValueVariableDefined = valueIdentifier.GetHash() != 0;
        const BoundVariableKey *valueVariable = nullptr;
        if (isValueVariableDefined) {
            auto valueType = itType->GetIndexedType(keyType.get());
            auto valueVariableAssignment = this->_scope->CreateExplicitLocal(valueIdentifier, valueType);
            if (valueVariableAssignment.GetResult() != VariableAssignmentResult::Ok) {
                this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::CantAssignVariable,
                                                         statement->GetStartPosition(),
                                                         statement->GetLength());
                return new BoundBadStatement();
            }
            valueVariable = valueVariableAssignment.GetKey();
        }
        auto boundBlock = this->BindBlockStatement(genericFor->GetBlock());

        this->_scope->GoOuterScope();

        return new BoundGenericForStatement(keyVariable, valueVariable, boundIterator, boundBlock);
    }

    BoundStatement *Binder::BindWhileStatement(const ParsedStatement *statement) {
        auto whileStatement = (ParsedWhileStatement *) statement;
        auto boundCondition = this->BindExpression(whileStatement->GetCondition());
        if (boundCondition->GetType()->GetClass() != TypeClass::Bool) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::ConditionNotABool,
                                                     statement->GetStartPosition(),
                                                     statement->GetLength());
            return new BoundBadStatement();
        }
        auto boundBlock = this->BindBlockStatement(whileStatement->GetBlock());
        return new BoundWhileStatement(boundCondition, boundBlock);
    }

    /////////////////
    // Expressions //
    /////////////////

    BoundExpression *Binder::BindExpression(const ParsedExpression *expression) {
        switch (expression->GetKind()) {
            case ParsedExpressionKind::LiteralInteger:
                return new BoundLiteralIntegerExpression(((LiteralIntegerExpression *) expression)->GetValue(),
                                                         expression->GetStartPosition(), expression->GetLength());
            case ParsedExpressionKind::LiteralFloat:
                return new BoundLiteralFloatExpression(((LiteralFloatExpression *) expression)->GetValue(),
                                                       expression->GetStartPosition(), expression->GetLength());
            case ParsedExpressionKind::LiteralString:
                return new BoundLiteralStringExpression(((LiteralStringExpression *) expression)->GetValue(),
                                                        expression->GetStartPosition(), expression->GetLength());
            case ParsedExpressionKind::LiteralBool:
                return new BoundLiteralBoolExpression(((LiteralBoolExpression *) expression)->GetValue(),
                                                      expression->GetStartPosition(), expression->GetLength());
            case ParsedExpressionKind ::Nil:
                return new BoundNilExpression(expression->GetStartPosition(), expression->GetLength());
            case ParsedExpressionKind::Variable:
                return this->BindVariableExpression((VariableExpression *) expression);

            case ParsedExpressionKind::Binary:
                return this->BindBinaryOperator((BinaryExpression *) expression);
            case ParsedExpressionKind::Unary:
                return this->BindUnaryOperator((UnaryExpression *) expression);

            case ParsedExpressionKind::Parenthesized:
                return BindExpression(((ParenthesizedExpression *) expression)->GetInnerExpression());
            case ParsedExpressionKind::FunctionCall:
                return this->BindFunctionCall((FunctionCallExpression *) expression);

            case ParsedExpressionKind::Indexer:
                return this->BindIndexExpression((IndexExpression *) expression, false);
            case ParsedExpressionKind::PeriodIndexer:
                return this->BindPeriodIndexExpression((PeriodIndexExpression *) expression, false);
            case ParsedExpressionKind::NumericalTable:
                return this->BindNumericalTableExpression((ParsedNumericalTableExpression *) expression);
            case ParsedExpressionKind::Table:
                return this->BindTableExpression((ParsedTableExpression *) expression);

            case ParsedExpressionKind::Bad:
                return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
        }
        throw;
    }

    BoundExpression *Binder::BindVariableExpression(const VariableExpression *expression) {
        auto key = expression->GetValue();
        auto scope = this->_scope->Exists(key);
        if (scope == -1) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::VariableNotFound,
                                                     expression->GetStartPosition(),
                                                     expression->GetLength());
            return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
        }
        auto var = this->_scope->GetVariable(scope, key);
        auto type = var->GetType();
        return new BoundVariableExpression(new BoundVariableKey(key, scope, false, type), type,
                                           expression->GetStartPosition(), expression->GetLength());
    }

    BoundExpression *Binder::BindBinaryOperator(const BinaryExpression *expression) {
        auto boundLeft = this->BindExpression(expression->GetLeft());
        auto boundRight = this->BindExpression(expression->GetRight());

        auto boundLeftType = boundLeft->GetType();
        auto boundRightType = boundRight->GetType();
        auto kind = expression->GetOperatorKind();

        if (boundLeftType->GetClass() == TypeClass::UserData){
            auto ud = dynamic_pointer_cast<const UserData::UserDataScriptType>(boundLeftType);
            auto op = ud->GetUserData()->Get()->GetBinaryOperation(kind, boundRightType);
            if (op == nullptr){
                if (kind != BinaryOperatorKind::Equality && kind != BinaryOperatorKind::Inequality){
                    this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::NoBinaryOperationFound,
                                                             expression->GetStartPosition(),
                                                             expression->GetLength());
                    return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
                }
            }
            else{
                return new BoundUserdataBinaryExpression(boundLeft, boundRight, op, op->GetReturnType(),
                                                         expression->GetStartPosition(), expression->GetLength());
            }
        }

        switch (kind) {
            case BinaryOperatorKind::Addition:
                if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number) {
                    auto leftNumeric = std::static_pointer_cast<const NumericScriptType>(boundLeftType);
                    auto rightNumeric = std::static_pointer_cast<const NumericScriptType>(boundRightType);
                    if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()) {
                        return new BoundBinaryExpression(boundLeft, boundRight,
                                                         BoundBinaryOperation::Addition,
                                                         NumericScriptType::ResolveType(true,
                                                                                             leftNumeric->IsFloat() ||
                                                                                             rightNumeric->IsFloat()),
                                                         expression->GetStartPosition(), expression->GetLength());
                    } else {
                        return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Addition,
                                                         NumericScriptType::Unaware,
                                                         expression->GetStartPosition(), expression->GetLength());
                    }
                } else if (boundLeftType->GetClass() == TypeClass::String) {
                    return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Concatenation,
                                                     StringScriptType::Dynamic,
                                                     expression->GetStartPosition(), expression->GetLength());
                }
                break;
            case BinaryOperatorKind::Subtraction:
                if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number) {
                    auto leftNumeric = std::dynamic_pointer_cast<const NumericScriptType>(boundLeftType);
                    auto rightNumeric = std::dynamic_pointer_cast<const NumericScriptType>(boundRightType);
                    if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()) {
                        return new BoundBinaryExpression(boundLeft, boundRight,
                                                         BoundBinaryOperation::Subtraction,
                                                         NumericScriptType::ResolveType(true,
                                                                                             leftNumeric->IsFloat() ||
                                                                                             rightNumeric->IsFloat()),
                                                         expression->GetStartPosition(), expression->GetLength());
                    } else {
                        return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Subtraction,
                                                         NumericScriptType::Unaware,
                                                         expression->GetStartPosition(), expression->GetLength());
                    }
                }
                break;
            case BinaryOperatorKind::Multiplication:
                if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number) {
                    auto leftNumeric = std::dynamic_pointer_cast<const NumericScriptType>(boundLeftType);
                    auto rightNumeric = std::dynamic_pointer_cast<const NumericScriptType>(boundRightType);
                    if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()) {
                        return new BoundBinaryExpression(boundLeft, boundRight,
                                                         BoundBinaryOperation::Multiplication,
                                                         NumericScriptType::ResolveType(true,
                                                                                             leftNumeric->IsFloat() ||
                                                                                             rightNumeric->IsFloat()),
                                                         expression->GetStartPosition(), expression->GetLength());
                    } else {
                        return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Multiplication,
                                                         NumericScriptType::Unaware,
                                                         expression->GetStartPosition(), expression->GetLength());
                    }
                }
                break;
            case BinaryOperatorKind::Division:
                if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number) {
                    auto leftNumeric = std::dynamic_pointer_cast<const NumericScriptType>(boundLeftType);
                    auto rightNumeric = std::dynamic_pointer_cast<const NumericScriptType>(boundRightType);
                    if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()) {
                        return new BoundBinaryExpression(boundLeft, boundRight,
                                                         BoundBinaryOperation::Division,
                                                         NumericScriptType::ResolveType(true,
                                                                                             leftNumeric->IsFloat() ||
                                                                                             rightNumeric->IsFloat()),
                                                         expression->GetStartPosition(), expression->GetLength());
                    } else {
                        return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Division,
                                                         NumericScriptType::Unaware,
                                                         expression->GetStartPosition(), expression->GetLength());
                    }
                }
                break;
            case BinaryOperatorKind::Equality:
                return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Equality,
                                                 ScriptType::BoolType,
                                                 expression->GetStartPosition(), expression->GetLength());
            case BinaryOperatorKind::Inequality:
                return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Inequality,
                                                 ScriptType::BoolType,
                                                 expression->GetStartPosition(), expression->GetLength());
            case BinaryOperatorKind::Less:
                if (boundLeft->GetType()->GetClass() == TypeClass::Number &&
                    boundRight->GetType()->GetClass() == TypeClass::Number) {
                    return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LessThan,
                                                     ScriptType::BoolType,
                                                     expression->GetStartPosition(), expression->GetLength());
                }
            case BinaryOperatorKind::LessOrEquals:
                if (boundLeft->GetType()->GetClass() == TypeClass::Number &&
                    boundRight->GetType()->GetClass() == TypeClass::Number) {
                    return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LessThanEquals,
                                                     ScriptType::BoolType,
                                                     expression->GetStartPosition(), expression->GetLength());
                }
            case BinaryOperatorKind::Greater:
                if (boundLeft->GetType()->GetClass() == TypeClass::Number &&
                    boundRight->GetType()->GetClass() == TypeClass::Number) {
                    return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::GreaterThan,
                                                     ScriptType::BoolType,
                                                     expression->GetStartPosition(), expression->GetLength());
                }
            case BinaryOperatorKind::GreaterOrEquals:
                if (boundLeft->GetType()->GetClass() == TypeClass::Number &&
                    boundRight->GetType()->GetClass() == TypeClass::Number) {
                    return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::GreaterThanEquals,
                                                     ScriptType::BoolType,
                                                     expression->GetStartPosition(), expression->GetLength());
                }
            case BinaryOperatorKind::LogicalAnd:
                if (boundLeftType->GetClass() == TypeClass::Bool && boundRightType->GetClass() == TypeClass::Bool)
                    return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LogicalAnd,
                                                     ScriptType::BoolType,
                                                     expression->GetStartPosition(), expression->GetLength());
                break;
            case BinaryOperatorKind::LogicalOr:
                if (boundLeftType->GetClass() == TypeClass::Bool && boundRightType->GetClass() == TypeClass::Bool)
                    return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LogicalOr,
                                                     ScriptType::BoolType,
                                                     expression->GetStartPosition(), expression->GetLength());
                break;
        }
        this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::NoBinaryOperationFound,
                                                 expression->GetStartPosition(),
                                                 expression->GetLength());
        return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
    }

    BoundExpression *Binder::BindUnaryOperator(const UnaryExpression *expression) {
        auto operand = this->BindExpression(expression->GetOperand());
        auto operandType = operand->GetType();
        switch (expression->GetOperatorKind()) {
            case UnaryOperatorKind::Identity:
                if (operandType->GetClass() == TypeClass::Number) {
                    // Identity won't change anything during evaluation, so just return the inner operand.
                    return operand;
                }
                break;
            case UnaryOperatorKind::Negation:
                if (operandType->GetClass() == TypeClass::Number) {
                    auto innerType = std::dynamic_pointer_cast<const NumericScriptType>(operandType);
                    return new BoundUnaryExpression(operand, BoundUnaryOperation::Negation,
                                                    NumericScriptType::ResolveType(
                                                            innerType.get()->IsAwareOfFloat(),
                                                            innerType.get()->IsFloat()),
                                                    expression->GetStartPosition(), expression->GetLength());
                }
                break;
            case UnaryOperatorKind::LogicalNegation:
                if (operandType->GetClass() == TypeClass::Bool) {
                    return new BoundUnaryExpression(operand, BoundUnaryOperation::LogicalNegation,
                                                    ScriptType::BoolType,
                                                    expression->GetStartPosition(), expression->GetLength());
                }
                break;
            default:
                break;
        }
        this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::NoUnaryOperationFound,
                                                 expression->GetStartPosition(),
                                                 expression->GetLength());
        return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());

    }

    BoundExpression *Binder::BindFunctionCall(const FunctionCallExpression *expression) {
        auto func = expression->GetFunction();
        if (func->GetKind() == ParsedExpressionKind::Variable) {
            auto variable = dynamic_cast<const VariableExpression *>(func);
            auto hash = variable->GetValue().GetHash();
            if (hash == HashedString::ConstHash("require")) {
                return this->BindRequire(expression);
            } else if (hash == HashedString::ConstHash("cast")) {
                return this->BindCast(expression);
            }
        }
        auto functionExpression = BindExpression(func);
        auto type = functionExpression->GetType();
        if (type->GetClass() != TypeClass::Function) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::ExpressionIsNotAFunction,
                                                     expression->GetStartPosition(),
                                                     expression->GetLength());
            return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
        }
        auto functionType = std::dynamic_pointer_cast<const GenericFunctionScriptType>(type);
        auto givenParameters = expression->GetParameters();
        vector<BoundExpression *> boundParameters = vector<BoundExpression *>(givenParameters->size());
        for (size_t i = 0; i < givenParameters->size(); i++) {
            boundParameters[i] = this->BindExpression(givenParameters->at(i));
        }

        auto functionOption = functionType->GetFunctionOption(this->_scriptData->Diagnostics, &boundParameters);
        if (functionOption == nullptr) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::InvalidFunctionParameters,
                                                     expression->GetStartPosition(),
                                                     expression->GetLength());
            return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
        }

        return new BoundFunctionCallExpression(functionExpression, boundParameters, functionOption,
                                               functionOption->GetReturnType(),
                                               expression->GetStartPosition(), expression->GetLength());
    }

    BoundExpression *Binder::BindRequire(const FunctionCallExpression *exp) {
        auto parameters = exp->GetParameters();
        if (parameters->size() != 1) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::InvalidFunctionParameters,
                                                     exp->GetStartPosition(),
                                                     exp->GetLength());
            return new BoundBadExpression(exp->GetStartPosition(), exp->GetLength());
        }
        auto parameter = parameters->at(0);
        auto boundParameter = this->BindExpression(parameter);
        if (boundParameter->GetKind() != BoundExpressionKind::LiteralString) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::InvalidFunctionParameters,
                                                     exp->GetStartPosition(),
                                                     exp->GetLength());
            return new BoundBadExpression(exp->GetStartPosition(), exp->GetLength());
        }
        auto key = *dynamic_cast<BoundLiteralStringExpression *>(boundParameter)->GetValue();
        auto opt = this->_scriptData->GetScriptOptions();
        auto transformedKey = Utilities::StringUtils::FromUTF8(key);
        delete boundParameter;
        if (!opt->DoesModuleExist(transformedKey.c_str(), transformedKey.size())) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::ModuleDoesntExist,
                                                     exp->GetStartPosition(),
                                                     exp->GetLength());
            return new BoundBadExpression(exp->GetStartPosition(), exp->GetLength());
        }
        auto module = Script::Clone(opt->ResolveModule(transformedKey.c_str(), transformedKey.size()));
        if (module->GetReturnType() == nullptr) {
            for (const auto &v: *module->GetScriptVariables()) {
                auto type = module->GetVariableType(v.first);
                auto result = this->_scope->AssignVariable(v.first, type);
                delete result.GetKey();
            }

        }
        return new BoundRequireExpression(module, exp->GetStartPosition(), exp->GetLength());
    }

    BoundExpression *Binder::BindCast(const FunctionCallExpression* exp){
        auto parameters = exp->GetParameters();
        if (parameters->size() != 2) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::InvalidFunctionParameters,
                                                     exp->GetStartPosition(),
                                                     exp->GetLength());
            return new BoundBadExpression(exp->GetStartPosition(), exp->GetLength());
        }
        auto toCastParameter = this ->BindExpression(parameters->at(0));
        const auto& toCastParameterType = toCastParameter->GetType();

        auto destinationTypeParameter = parameters -> at(1);
        if (destinationTypeParameter ->GetKind() != ParsedExpressionKind::Variable){
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::InvalidFunctionParameters,
                                                     exp->GetStartPosition(),
                                                     exp->GetLength());
            return new BoundBadExpression(exp->GetStartPosition(), exp->GetLength());
        }
        auto destinationTypeContent = dynamic_cast<const VariableExpression*>(destinationTypeParameter)->GetValue();
        auto destinationType = ParseTypeIdentifier(&destinationTypeContent);
        auto castResult = toCastParameterType->CastableTo(destinationType, true);
        if (castResult == CastResult::InvalidCast){
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::InvalidCast, exp->GetStartPosition(),
                                                       exp->GetLength());
            return new BoundBadExpression(exp->GetStartPosition(), exp->GetLength());
        }
        else if (castResult == CastResult::DataLoss){
            this->_scriptData->Diagnostics->LogWarning(Diagnostics::DiagnosticCode::DataLossOnCast, exp->GetStartPosition(),
                                                       exp->GetLength());
        }
        else if (castResult == CastResult::UncheckedCast){
            this->_scriptData->Diagnostics->LogInfo(Diagnostics::DiagnosticCode::UnvalidatedCast, exp->GetStartPosition(),
                                                       exp->GetLength());
        }
        return new BoundCastExpression(toCastParameter, destinationType);
    }

    BoundExpression *Binder::BindIndexExpression(const IndexExpression *expression, bool setter) {
        auto indexer = this->BindExpression(expression->GetIndexer());
        auto index = this->BindExpression(expression->GetIndex());

        auto indexerType = indexer->GetType();
        if (!indexerType->CanBeIndexedWith(index->GetType().get())) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::CantIndex, index->GetStartPosition(),
                                                     index->GetLength());
            return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
        }
        if (indexerType->GetClass() == TypeClass::UserData) {
            auto stringKey = dynamic_pointer_cast<const StringScriptType>(index->GetType());
            auto field = dynamic_pointer_cast<const UserData::UserDataScriptType>(indexerType)->GetField(stringKey->GetHashValue());
            if (!setter) {
                if (!field->HasGetter()) {
                    this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::UserDataFieldNoGetter,
                                                             index->GetStartPosition(),
                                                             index->GetLength());
                    return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
                }
            } else {
                if (!field->HasSetter()) {
                    this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::UserDataFieldNoSetter,
                                                             index->GetStartPosition(),
                                                             index->GetLength());
                    return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
                }
            }
        }

        auto resultType = indexer->GetType()->GetIndexedType(index->GetType().get());
        return new BoundIndexExpression(indexer, index, resultType, expression->GetStartPosition(),
                                        expression->GetLength());
    }

    BoundExpression *Binder::BindPeriodIndexExpression(const PeriodIndexExpression *expression, bool setter) {
        auto indexer = this->BindExpression(expression->GetIndexer());
        const auto &identifier = expression->GetIndex();
        const auto &indexerType = indexer->GetType();
        if (!indexerType->CanBeIndexedWithIdentifier(identifier.GetHash())) {
            this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::CantIndex, expression->GetStartPosition(),
                                                     expression->GetLength());
            return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
        }
        if (indexerType->GetClass() == TypeClass::UserData) {
            auto field = dynamic_pointer_cast<const UserData::UserDataScriptType>(indexerType)->GetField(identifier.GetHash());
            if (!setter) {
                if (!field->HasGetter()) {
                    this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::UserDataFieldNoGetter,
                                                             expression->GetStartPosition(),
                                                             expression->GetLength());
                    return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
                }
            } else {
                if (!field->HasSetter()) {
                    this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::UserDataFieldNoSetter,
                                                             expression->GetStartPosition(),
                                                             expression->GetLength());
                    return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
                }
            }
        }

        auto resultType = indexer->GetType()->GetIndexedType(identifier.GetHash());
        return new BoundPeriodIndexExpression(indexer, identifier, resultType, expression->GetStartPosition(),
                                              expression->GetLength());

    }

    BoundExpression *Binder::BindNumericalTableExpression(const ParsedNumericalTableExpression *expression) {
        auto expressions = expression->GetExpressions();
        auto boundExpressions = vector<const BoundExpression *>(expressions->size());
        shared_ptr<const ScriptType> valueType = nullptr;
        if (!boundExpressions.empty()) {
            boundExpressions[0] = this->BindExpression(expressions->at(0));
            valueType = boundExpressions[0]->GetType();
            for (size_t i = 1; i < expressions->size(); i++) {
                boundExpressions[i] = this->BindExpression(expressions->at(i));
                if (boundExpressions[i]->GetType()->operator!=(valueType)) {
                    this->_scriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::InvalidTableValueType,
                                                             boundExpressions[i]->GetStartPosition(),
                                                             boundExpressions[i]->GetLength());
                }
            }
        }
        if (valueType == nullptr) {
            valueType = ScriptType::NilType;
        }
        auto tableType = std::make_shared<const NumericalTableScriptType>(valueType);
        return new BoundNumericalTableExpression(boundExpressions, tableType, expression->GetStartPosition(),
                                                 expression->GetLength());
    }

    BoundExpression *Binder::BindTableExpression(const ParsedTableExpression *expression) {
        auto tableScope = new map<Utilities::HashedString, BoundVariable *>();
        auto innerScope = new BoundScope(tableScope, nullptr);
        auto currentScope = this->_scope;
        this->_scope = innerScope;
        auto block = dynamic_cast<BoundBlockStatement*>(this->BindBlockStatement(expression->GetBlock()));
        this->_scope = currentScope;

        auto tableType = std::make_shared<TableScriptType>(tableScope, innerScope->GetLocalVariableCount());
        delete innerScope;

        return new BoundTableExpression(block, tableType, expression->GetStartPosition(), expression->GetLength());
    }

}