#include "Expression.h"

Expression::Expression(Kind kind, Token token, shared_ptr<Expression> left, shared_ptr<Expression> right): token(token) {
    switch (kind) {
        case LITERAL:
            setupLiteral(token);
            break;
        case GROUPING:
            setupGrouping(token, left);
            break;
        case BINARY:
            setupBinary(token, left, right);
            break;
        case INVALID:
            break;
    }
}

void Expression::setupLiteral(Token token) {
    bool isKindValid = token.isOfKind({Token::Kind::INTEGER});
    if (!isKindValid)
        return;

    kind = LITERAL;
    integer = stoi(token.getLexme());
}

void Expression::setupGrouping(Token token, shared_ptr<Expression> expression) {
    bool isKindValid = token.getKind() == Token::Kind::LEFT_PAREN;
    bool isExpressionValid = expression != nullptr && expression->getKind() != Kind::INVALID;

    if (!isKindValid || !isExpressionValid)
        return;
    
    kind = GROUPING;
    left = expression;
}

void Expression::setupBinary(Token token, shared_ptr<Expression> left, shared_ptr<Expression> right) {
    bool isKindValid = token.isOfKind({Token::Kind::PLUS, Token::Kind::MINUS, Token::Kind::STAR, Token::Kind::SLASH, Token::Kind::PERCENT});
    bool isLeftValid = left != nullptr && left->getKind() != Kind::INVALID;
    bool isRightValid = right != nullptr && right->getKind() != Kind::INVALID;

    if (!isKindValid || !isLeftValid || !isRightValid)
        return;

    kind = BINARY;

    switch (token.getKind()) {
        case Token::Kind::PLUS:
            operation = ADD;
            break;
        case Token::Kind::MINUS:
            operation = SUB;
            break;
        case Token::Kind::STAR:
            operation = MUL;
            break;
        case Token::Kind::SLASH:
            operation = DIV;
            break;
        case Token::Kind::PERCENT:
            operation = MOD;
            break;
        case Token::Kind::INVALID:
            break;
        default:
            exit(1);
    }

    this->left = left;
    this->right = right;
}

Expression::Kind Expression::getKind() {
    return kind;
}

Token Expression::getToken() {
    return token;
}

int64_t Expression::getInteger() {
    return integer;
}

Expression::Operator Expression::getOperator() {
    return operation;
}

shared_ptr<Expression> Expression::getLeft() {
    return left;
}

shared_ptr<Expression> Expression::getRight() {
    return right;
}

bool Expression::isValid() {
    return kind != Expression::Kind::INVALID;
}

string Expression::toString() {
    switch (kind) {
        case LITERAL:
            return to_string(integer);
        case GROUPING:
            return "<( " + left->toString() + " )>";
        case BINARY:
            switch (operation) {
                case ADD:
                    return "<+ " + left->toString() + " " + right->toString() + ">";
                case SUB:
                    return "<- " + left->toString() + " " + right->toString() + ">";
                case MUL:
                    return "<* " + left->toString() + " " + right->toString() + ">";
                case DIV:
                    return "</ " + left->toString() + " " + right->toString() + ">";
                case MOD:
                    return "<% " + left->toString() + " " + right->toString() + ">";
                case NONE:
                    return "NONE";
            }
        case INVALID:
            return "INVALID";
    }
}