#include <memory>
#include "Evaluator.hpp"
#include "EvaluationException.hpp"
#include "EvaluationScope/EvaluationScope.hpp"
#include "EvalValues/ScriptFunctionEvalValue.hpp"
#include "EvalValues/TableEvalValue.hpp"
#include "EvalValues/NilEvalValue.hpp"
#include "../Binder/BoundExpressions/BoundTableExpression.hpp"
#include "../Binder/BoundExpressions/BoundFunctionCallExpression.hpp"
#include "../Binder/BoundExpressions/BoundRequireExpression.hpp"
#include "../ScriptTypes/TableScriptType.hpp"
#include "../UserData/UserDataFunction.hpp"
#include "../UserData/UserDataValue.hpp"

using namespace std;
using namespace Porygon::Binder;

namespace Porygon::Evaluation {
    const EvalValue* Evaluator::Evaluate(const BoundScriptStatement *statement) {
        this->_evaluationScope = make_shared<EvaluationScope>(this->_scriptVariables);
        auto statements = statement->GetStatements();
        if (statements -> size() == 1 && statements->at(0)->GetKind() == BoundStatementKind::Expression){
            auto expStatement = (BoundExpressionStatement*) statements -> at(0);
            return this -> EvaluateExpression(expStatement -> GetExpression()).Clone();
        }
        EvaluateBlockStatement(statement);
        if (this->_returnValue.Get() == nullptr){
            return nullptr;
        }
        return this->_returnValue.Clone();
    }

    void Evaluator::EvaluateStatement(const BoundStatement *statement) {
        if (this->_hasReturned)
            return;
        switch (statement->GetKind()) {
            case BoundStatementKind::Script:
                throw; // Should never happen
            case BoundStatementKind::Block:
                return this->EvaluateBlockStatement((BoundBlockStatement*)statement);
            case BoundStatementKind::Expression:
                return this->EvaluateExpressionStatement((BoundExpressionStatement *) statement);
            case BoundStatementKind::Assignment:
                return this->EvaluateAssignmentStatement((BoundAssignmentStatement *) statement);
            case BoundStatementKind::IndexAssignment:
                return this->EvaluateIndexAssignmentStatement((BoundIndexAssignmentStatement *) statement);
            case BoundStatementKind::FunctionDeclaration:
                return this->EvaluateFunctionDeclarationStatement((BoundFunctionDeclarationStatement *) statement);
            case BoundStatementKind::Return:
                return this->EvaluateReturnStatement((BoundReturnStatement *) statement);
            case BoundStatementKind::Conditional:
                return this->EvaluateConditionalStatement((BoundConditionalStatement *) statement);
            case BoundStatementKind::NumericalFor:
                return this->EvaluateNumericalForStatement((BoundNumericalForStatement*)statement);
            case BoundStatementKind::GenericFor:
                return this-> EvaluateGenericForStatement((BoundGenericForStatement*)statement);
            case BoundStatementKind::While:
                return this-> EvaluateWhileStatement((BoundWhileStatement*)statement);

            case BoundStatementKind::Break:
                this -> _hasBroken = true;
                return;
            case BoundStatementKind::Next:
                this -> _hasContinued = true;
                return;
            case BoundStatementKind::Bad:
                throw;
        }
        throw EvaluationException("Evaluating this statement is not supported");
    }

    void Evaluator::EvaluateBlockStatement(const BoundBlockStatement *statement) {
        for (auto s: *statement->GetStatements()) {
            this->EvaluateStatement(s);
            if (this->_hasReturned)
                break;
        }
    }

    void Evaluator::EvaluateExpressionStatement(const BoundExpressionStatement *statement) {
        this->EvaluateExpression(statement->GetExpression());
    }

    void Evaluator::EvaluateAssignmentStatement(const BoundAssignmentStatement *statement) {
        auto value = this->EvaluateExpression(statement->GetExpression());
        auto key = statement->GetKey();
        if (key->IsCreation()) {
            this->_evaluationScope->CreateVariable(key, value.Clone());
        } else {
            this->_evaluationScope->SetVariable(key, value.Clone());
        }
    }

    void Evaluator::EvaluateIndexAssignmentStatement(const BoundIndexAssignmentStatement *statement) {
        auto indexExpression = statement->GetIndexExpression();
        auto value = this->EvaluateExpression(statement->GetValueExpression());
        if (indexExpression->GetKind() == BoundExpressionKind::Index){
            auto index = dynamic_cast<const BoundIndexExpression*>(indexExpression);
            auto table = this->EvaluateExpression(index->GetIndexableExpression());
            auto key = this->EvaluateExpression(index->GetIndexExpression());
            table->SetIndexValue(key.Get(), value.Take());
        }
        else{
            auto index = dynamic_cast<const BoundPeriodIndexExpression*>(indexExpression);
            auto table = this->EvaluateExpression(index->GetIndexableExpression());
            auto key = index->GetIndex();
            table->SetIndexValue(key, value.Take());
        }
    }


    void Evaluator::EvaluateFunctionDeclarationStatement(const BoundFunctionDeclarationStatement *statement) {
        auto type = statement->GetType();
        auto key = statement->GetKey();
        auto block = statement->GetBlock();
        auto option = new Evaluation::EvaluationScriptFunctionOption(block, this->_evaluationScope);

        if (key->IsCreation()) {
            auto p = new GenericFunctionEvalValue(type, Utilities::Random::Get());
            p->RegisterOption(option);
            auto value = EvalValuePointer(p);
            this->_evaluationScope->CreateVariable(key, value);
        } else {
            auto var = (GenericFunctionEvalValue*)this -> _evaluationScope ->GetVariable(key).Take();
            var->RegisterOption(option);
            delete var;
        }
    }

    void Evaluator::EvaluateReturnStatement(const BoundReturnStatement *statement) {
        auto expression = statement->GetExpression();
        if (expression == nullptr) {
            this->_hasReturned = true;
            this -> _returnValue.ClearAssign(nullptr);
            return;
        }
        auto value = this->EvaluateExpression(expression).Take();
        this->_hasReturned = true;
        this->_returnValue.ClearAssign(value);
    }

    void Evaluator::EvaluateConditionalStatement(const BoundConditionalStatement *statement) {
        auto condition = statement->GetCondition();
        if (EvaluateExpression(condition)->EvaluateBool()) {
            this->EvaluateStatement(statement->GetBlock());
        } else {
            auto elseStatement = statement->GetElseStatement();
            if (elseStatement != nullptr) {
                this->EvaluateStatement(elseStatement);
            }
        }
    }

    void Evaluator::EvaluateNumericalForStatement(const BoundNumericalForStatement *statement) {
        int64_t start = this->EvaluateExpression(statement -> GetStart()) -> EvaluateInteger();
        int64_t end = this->EvaluateExpression(statement -> GetEnd()) -> EvaluateInteger();
        int64_t step = 1;
        auto stepExp = statement -> GetStep();
        if (stepExp != nullptr){
            step = this -> EvaluateExpression(stepExp) -> EvaluateInteger();
        }
        auto identifier = statement -> GetIdentifier();
        this -> _evaluationScope -> CreateVariable(identifier, nullptr);
        auto block = (BoundBlockStatement*)statement -> GetBlock();
        auto statements = *block -> GetStatements();
        if (step >= 0){
            for (int64_t i = start; i <= end; i += step){
                this -> _evaluationScope -> SetVariable(identifier, new NumericEvalValue(i));
                for (auto s: statements) {
                    this->EvaluateStatement(s);
                    if (this->_hasReturned || this -> _hasBroken || this -> _hasContinued)
                        break;
                }
                this -> _hasContinued = false;
                if (this->_hasReturned || this -> _hasBroken)
                    break;
            }
        } else{
            for (int64_t i = start; i >= end; i += step){
                this -> _evaluationScope -> SetVariable(identifier, new NumericEvalValue(i));
                for (auto s: statements) {
                    this->EvaluateStatement(s);
                    if (this->_hasReturned || this -> _hasBroken || this -> _hasContinued)
                        break;
                }
                this -> _hasContinued = false;
                if (this->_hasReturned || this -> _hasBroken)
                    break;
            }
        }
        this -> _hasBroken = false;
    }

    void Evaluator::EvaluateGenericForStatement(const BoundGenericForStatement *statement) {
        auto iteratorVal = EvaluateExpression(statement -> GetIterator());
        auto iterator = iteratorVal -> GetKeyIterator();
        auto keyVariable = statement ->GetKeyIdentifier();
        auto valueVariable = statement ->GetValueIdentifier();

        this -> _evaluationScope -> CreateVariable(keyVariable, nullptr);
        if (valueVariable != nullptr)
            this -> _evaluationScope -> CreateVariable(valueVariable, nullptr);
        auto block = (BoundBlockStatement*)statement -> GetBlock();
        auto statements = *block -> GetStatements();
        while (iterator->MoveNext()){
            auto currentKey = EvalValuePointer(iterator->GetCurrent());
            this -> _evaluationScope -> SetVariable(keyVariable, currentKey);
            if (valueVariable != nullptr){
                auto currentValue = EvalValuePointer(iteratorVal -> IndexValue(currentKey.Get()));
                this -> _evaluationScope -> SetVariable(valueVariable, currentValue);
            }
            for (auto s: statements) {
                this->EvaluateStatement(s);
                if (this->_hasReturned || this -> _hasBroken || this -> _hasContinued)
                    break;
            }
            this -> _hasContinued = false;
            if (this->_hasReturned || this -> _hasBroken)
                break;
        }
        this -> _hasBroken = false;
        delete iterator;
    }

    void Evaluator::EvaluateWhileStatement(const BoundWhileStatement *statement) {
        auto condition = statement -> GetCondition();
        auto block = (BoundBlockStatement*)statement -> GetBlock();
        auto statements = *block -> GetStatements();
        while (this->EvaluateExpression(condition)->EvaluateBool()){
            for (auto s: statements) {
                this->EvaluateStatement(s);
                if (this->_hasReturned || this -> _hasBroken || this -> _hasContinued)
                    break;
            }
            this -> _hasContinued = false;
            if (this->_hasReturned || this -> _hasBroken)
                break;
        }
        this -> _hasBroken = false;
    }

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

    EvalValuePointer Evaluator::EvaluateExpression(const BoundExpression *expression) {
        switch (expression->GetKind()){

            case BoundExpressionKind::Bad: throw;
            case BoundExpressionKind::LiteralInteger:
                return new NumericEvalValue(((BoundLiteralIntegerExpression *) expression)->GetValue());
            case BoundExpressionKind::LiteralFloat:
                return new NumericEvalValue(((BoundLiteralFloatExpression *) expression)->GetValue());
            case BoundExpressionKind::LiteralString:
                return new StringEvalValue(*((BoundLiteralStringExpression *) expression)->GetValue());
            case BoundExpressionKind::LiteralBool:
                return new BooleanEvalValue(((BoundLiteralBoolExpression *) expression)->GetValue());
            case BoundExpressionKind::Nil:
                return new NilEvalValue();
            case BoundExpressionKind::Variable:
                return this -> GetVariable((BoundVariableExpression*)expression);
            case BoundExpressionKind::Unary:
                return this->EvaluateUnary((BoundUnaryExpression *) expression);
            case BoundExpressionKind::Binary:
                return this->EvaluateBinary((BoundBinaryExpression *) expression);
            case BoundExpressionKind ::UserdataBinary:
                return this->EvaluateUserDataBinary(dynamic_cast<const BoundUserdataBinaryExpression*>(expression));
            case BoundExpressionKind::FunctionCall:
                return this->EvaluateFunctionCallExpression(expression);
            case BoundExpressionKind::Index:
                return this->EvaluateIndexExpression(expression).Take();
            case BoundExpressionKind::PeriodIndex:
                return this->EvaluatePeriodIndexExpression(expression);
            case BoundExpressionKind::NumericalTable:
                return this->EvaluateNumericTableExpression(expression);
            case BoundExpressionKind::Table:
                return this->EvaluateComplexTableExpression(expression);
            case BoundExpressionKind::Require:
                return this -> EvaluateRequireExpression(expression);
            case BoundExpressionKind::Cast:
                return this -> EvaluateImplicitCastExpression(expression);
        }
        throw exception();
    }

    EvalValuePointer Evaluator::EvaluateBinary(const BoundBinaryExpression *expression){
        auto operation = expression->GetOperation();
        auto leftValue = this -> EvaluateExpression(expression->GetLeft());
        if (operation == BoundBinaryOperation::LogicalAnd){
            if (!leftValue->EvaluateBool())
                return new BooleanEvalValue(false);
        }
        auto rightValue = this -> EvaluateExpression(expression->GetRight());
        if (operation == BoundBinaryOperation::Equality){
            return new BooleanEvalValue(leftValue->operator==(rightValue.Get()));
        } else if (operation == BoundBinaryOperation::Inequality){
            return new BooleanEvalValue(leftValue->operator!=(rightValue.Get()));
        }
        return leftValue->BinaryOperation(operation, rightValue.Get());
    }

    EvalValuePointer Evaluator::EvaluateUserDataBinary(const BoundUserdataBinaryExpression *expression) {
        auto leftValue = this->EvaluateExpression(expression->GetLeft());
        auto rightValue = this->EvaluateExpression(expression->GetRight());
        auto op = expression->GetOperation();
        auto o = dynamic_cast<const UserData::UserDataValue*>(leftValue.Get());
        auto val = op->Invoke(o->GetObjectPointer(), rightValue.Get());
        return val;
    }

    EvalValuePointer Evaluator::EvaluateUnary(const BoundUnaryExpression *expression) {
        auto exp = expression->GetOperand();
        auto val = EvaluateExpression(exp);
        return val->UnaryOperation(expression->GetOperation());
    }

    EvalValuePointer Evaluator::GetVariable(const BoundVariableExpression *expression) {
        auto variable = this->_evaluationScope->GetVariable(expression->GetKey());
        if (variable.Get() == nullptr) {
            throw EvaluationException("Variable not found");
        }
        return variable;
    }

    EvalValuePointer Evaluator::EvaluateFunctionCallExpression(const BoundExpression *expression) {
        auto functionCall = (BoundFunctionCallExpression *) expression;
        auto function = (GenericFunctionEvalValue*)this->EvaluateExpression(functionCall->GetFunctionExpression()).Clone();

        auto boundParameters = functionCall->GetParameters();
        auto parameters = vector<EvalValuePointer>(boundParameters->size());
        for (size_t i = 0; i < boundParameters->size(); i++) {
            parameters[i] = this->EvaluateExpression(boundParameters->at(i));
        }

        auto type = std::dynamic_pointer_cast<const GenericFunctionScriptType>(function->GetType());
        auto func = function;
        auto option = functionCall ->GetFunctionOption();
        auto opt = func->GetOption(option->GetOptionId());
        if (option -> IsScriptFunction()){
            auto parameterTypes = option->GetParameterTypes();
            auto scriptFunctionType = dynamic_cast<const ScriptFunctionOption*>(option);
            auto parameterKeys = scriptFunctionType->GetParameterKeys();
            auto originalScope = this->_evaluationScope;
            auto scriptOption = dynamic_pointer_cast<const EvaluationScriptFunctionOption>(opt);
            this->_evaluationScope = scriptOption->GetScope();

            for (int i = 0; i < parameterTypes.size() && i < parameterKeys.size() && i < parameters.size(); i++) {
                auto parameter = parameters[i];
                auto key = parameterKeys.at(i);
                this->_evaluationScope->CreateVariable(key.get(), parameter.Clone());
            }
            this->EvaluateBlockStatement(scriptOption->GetInnerBlock().get());
            this->_evaluationScope = originalScope;

            this->_hasReturned = false;
            auto r = this->_returnValue;
            this->_returnValue.ClearAssign(nullptr);
            delete function;
            return r;
        } else{
            auto scriptOption = dynamic_pointer_cast<const UserData::UserDataFunction>(opt);
            const EvalValue* arr[parameters.size()];
            for (size_t i = 0; i < parameters.size(); i++){
                arr[i] = parameters[i].Get();
            }
            delete function;
            return scriptOption -> Call(this -> _scriptOptions, arr, parameters.size());
        }
    }

    const EvalValue* Evaluator::EvaluateFunction(const GenericFunctionEvalValue *function,
                                                            const vector<EvalValue *> &parameters) {
        auto type = function->GetType();
        auto option = dynamic_cast<const ScriptFunctionOption*>(type->GetFirstOption());

        auto parameterTypes = option->GetParameterTypes();
        auto parameterKeys = option->GetParameterKeys();

        auto originalScope = this->_evaluationScope;
        auto scriptOption = dynamic_pointer_cast<const EvaluationScriptFunctionOption>(function->GetOption(0));
        this->_evaluationScope = scriptOption->GetScope();

        for (int i = 0; i < parameterTypes.size() && i < parameterKeys.size() && i < parameters.size(); i++) {
            auto parameter = parameters[i];
            auto key = parameterKeys.at(i);
            this->_evaluationScope->CreateVariable(key.get(), parameter->Clone());
        }
        this->EvaluateBlockStatement(scriptOption->GetInnerBlock().get());
        this->_evaluationScope = originalScope;
        this->_hasReturned = false;
        auto r = this->_returnValue.Take();
        delete function;
        return r;
    }

    EvalValuePointer Evaluator::EvaluateIndexExpression(const BoundExpression *expression) {
        auto indexExpression = (BoundIndexExpression *) expression;
        auto index = this->EvaluateExpression(indexExpression->GetIndexExpression());
        auto indexable = this->EvaluateExpression(indexExpression->GetIndexableExpression());
        return indexable->IndexValue(index.Get());
    }

    EvalValuePointer Evaluator::EvaluatePeriodIndexExpression(const BoundExpression *expression) {
        auto indexExpression = (BoundPeriodIndexExpression *) expression;
        auto index = indexExpression->GetIndex();
        auto indexable = this->EvaluateExpression(indexExpression->GetIndexableExpression());
        return indexable->IndexValue(index);
    }

    EvalValuePointer Evaluator::EvaluateNumericTableExpression(const BoundExpression *expression) {
        auto tableExpression = (BoundNumericalTableExpression *) expression;
        auto valueExpressions = tableExpression->GetExpressions();
        auto values = new map<Utilities::HashedString, EvalValuePointer>();
        for (size_t i = 0; i < valueExpressions->size(); i++) {
            auto val = this->EvaluateExpression(valueExpressions->at(i));
            auto s = Utilities::HashedString::CreateLookup(i + 1);
            values->insert({s, val});
        }
        auto valuesPointer = shared_ptr<map<Utilities::HashedString, EvalValuePointer>>(values);
        return new NumericTableEvalValue(valuesPointer);
    }

    EvalValuePointer Evaluator::EvaluateComplexTableExpression(const BoundExpression *expression) {
        auto tableExpression = (BoundTableExpression *) expression;
        const auto& baseType = tableExpression -> GetType();
        auto type = dynamic_pointer_cast<const TableScriptType>(baseType);
        auto declaredVars = type->GetContentTypes();
        auto variables = make_shared<map<Utilities::HashedString, EvalValuePointer>>();
        for (const auto& i : *declaredVars) {
            variables->insert({i.first, nullptr});
        }
        auto evaluator = make_shared<EvaluationScope>(variables.get());
        auto currentEvaluator = this->_evaluationScope;
        this->_evaluationScope = evaluator;
        this->EvaluateBlockStatement(tableExpression->GetBlock());
        this->_evaluationScope = currentEvaluator;
        return new TableEvalValue(variables);
    }

    EvalValuePointer Evaluator::EvaluateRequireExpression(const BoundExpression* expression) {
        auto module = dynamic_cast<const BoundRequireExpression*>(expression)->GetModule();
        auto result = module->Evaluate();
        if (module ->GetReturnType() == nullptr){
            for (const auto& v: *module->GetScriptVariables()){
                this->_scriptVariables->at(v.first) = v.second.Clone();
            }
            return nullptr;
        } else{
            return result.Take();
        }
    }

    EvalValuePointer Evaluator::EvaluateImplicitCastExpression(const BoundExpression *pExpression) {
        auto iCExpression = dynamic_cast<const BoundCastExpression*>(pExpression);
        auto val = EvaluateExpression(iCExpression->GetExpression());
        return val->Cast(iCExpression->GetType());
    }
}