#include "Binder.hpp"

BoundScriptStatement *Binder::Bind(Script* script, ParsedScriptStatement *s) {
    auto binder = Binder();
    binder.ScriptData = script;
    auto statements = s->GetStatements();
    vector<BoundStatement*> boundStatements (statements.size());
    for (int i = 0; i < statements.size(); i++){
        boundStatements[i] = binder.BindStatement(statements[i]);
    }
    return new BoundScriptStatement(boundStatements);
}

BoundStatement* Binder::BindStatement(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);
    }
}

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

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

BoundExpression* Binder::BindExpression(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 ::LiteralBool:
            return new BoundLiteralBoolExpression(((LiteralBoolExpression*)expression)->GetValue(), expression->GetStartPosition(), expression->GetLength());

        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 ::Bad:
            return new BoundBadExpression(expression->GetStartPosition(), expression-> GetLength());
    }
}

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

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

    switch (expression->GetOperatorKind()){
        case BinaryOperatorKind ::Addition:
            if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number){
                auto leftNumeric = (NumericScriptType*)boundLeftType;
                auto rightNumeric = (NumericScriptType*)boundRightType;
                if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()){
                    return new BoundBinaryExpression(boundLeft, boundRight,
                            BoundBinaryOperation::Addition, new NumericScriptType(true, leftNumeric->IsFloat() || rightNumeric->IsFloat()),
                            expression->GetStartPosition(), expression->GetLength());
                }
                else{
                    return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Addition, new NumericScriptType(false, false),
                                                     expression->GetStartPosition(), expression->GetLength());
                }
            }
            //TODO: String Concatenation
            break;
        case BinaryOperatorKind ::Subtraction:
            if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number){
                auto leftNumeric = (NumericScriptType*)boundLeftType;
                auto rightNumeric = (NumericScriptType*)boundRightType;
                if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()){
                    return new BoundBinaryExpression(boundLeft, boundRight,
                                                     BoundBinaryOperation::Subtraction,
                                                     new NumericScriptType(true, leftNumeric->IsFloat() || rightNumeric->IsFloat()),
                                                     expression->GetStartPosition(), expression->GetLength());
                }
                else{
                    return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Subtraction, new NumericScriptType(false, false),
                                                     expression->GetStartPosition(), expression->GetLength());
                }
            }
            break;
        case BinaryOperatorKind ::Multiplication:
            if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number){
                auto leftNumeric = (NumericScriptType*)boundLeftType;
                auto rightNumeric = (NumericScriptType*)boundRightType;
                if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()){
                    return new BoundBinaryExpression(boundLeft, boundRight,
                                                     BoundBinaryOperation::Multiplication,
                                                     new NumericScriptType(true, leftNumeric->IsFloat() || rightNumeric->IsFloat()),
                                                     expression->GetStartPosition(), expression->GetLength());
                }
                else{
                    return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Multiplication, new NumericScriptType(false, false),
                                                     expression->GetStartPosition(), expression->GetLength());
                }
            }
            break;
        case BinaryOperatorKind ::Division:
            if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number){
                auto leftNumeric = (NumericScriptType*)boundLeftType;
                auto rightNumeric = (NumericScriptType*)boundRightType;
                if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()){
                    return new BoundBinaryExpression(boundLeft, boundRight,
                                                     BoundBinaryOperation::Division,
                                                     new NumericScriptType(true, leftNumeric->IsFloat() || rightNumeric->IsFloat()),
                                                     expression->GetStartPosition(), expression->GetLength());
                }
                else{
                    return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Division, new NumericScriptType(false, false),
                                                     expression->GetStartPosition(), expression->GetLength());
                }
            }
            break;
        case BinaryOperatorKind ::Equality:
            return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Equality, new ScriptType(TypeClass::Bool),
                                             expression->GetStartPosition(), expression->GetLength());
        case BinaryOperatorKind ::LogicalAnd:
            if (boundLeftType->GetClass() == TypeClass::Bool && boundRightType->GetClass() == TypeClass::Bool)
                return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LogicalAnd, new ScriptType(TypeClass::Bool),
                                                 expression->GetStartPosition(), expression->GetLength());
            break;
        case BinaryOperatorKind ::LogicalOr:
            if (boundLeftType->GetClass() == TypeClass::Bool && boundRightType->GetClass() == TypeClass::Bool)
                return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LogicalOr, new ScriptType(TypeClass::Bool),
                                                 expression->GetStartPosition(), expression->GetLength());
            break;
        default:
            break;
    }
    this -> ScriptData -> Diagnostics->LogError(DiagnosticCode::NoBinaryOperationFound, expression->GetStartPosition(), expression->GetLength());
    return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
}

BoundExpression* Binder::BindUnaryOperator(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 = (NumericScriptType*)operandType;
                return new BoundUnaryExpression(operand, BoundUnaryOperation::Negation, new NumericScriptType(innerType->IsAwareOfFloat(),
                        innerType->IsFloat()), expression->GetStartPosition(), expression->GetLength());
            }
            break;
        case UnaryOperatorKind ::LogicalNegation:
            if (operandType->GetClass() == TypeClass::Bool){
                return new BoundUnaryExpression(operand, BoundUnaryOperation::LogicalNegation, new ScriptType(TypeClass::Bool),
                        expression->GetStartPosition(), expression->GetLength());
            }
            break;
        default:
            break;
    }
    this -> ScriptData -> Diagnostics->LogError(DiagnosticCode::NoUnaryOperationFound, expression->GetStartPosition(), expression->GetLength());
    return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());

}