package Compiler;

import java.util.List;

//Class for possible expressions in the language
abstract class Expression {

    /**
     * Class for representing a binary expression, with two values between an operator
     */
    static class Binary extends Expression{

        final Expression left;
        final Expression right;
        final Token op;

        Binary(Expression left, Token op, Expression right){
            this.left=left;
            this.op=op;
            this.right = right;
        }

        @Override
        public String getExpressionType() {
            return "binary";
        }

    }

    /**
     * Class for representing a singlular expression, with one value and one operator
     */
    static class Singular extends Expression{

        final Expression right;
        final Token op;

        Singular(Token op, Expression right){
            this.op=op;
            this.right = right;
        }

        @Override
        public String getExpressionType() {
            return "singular";
        }

    }

    /**
     * Class for representing a literal value
     */
    static class Literal extends Expression{
        final Token value;
        final String type;

        Literal(Token value,String type){
            this.value=value;
            this.type=type;
        }
        

        @Override
        public String getExpressionType() {
            return "literal";
        }
        
    }

    /**
     * Class for representing an expression between brackets
     */
    static class BracketedExpression extends Expression{
        final Expression expr;

        BracketedExpression(Expression expr){
            this.expr=expr;
        }

        @Override
        public String getExpressionType() {
            return "bracket";
        }     
    }

    /**
     * Class for represening an assignment expression
     */
    static class AssignmentExpression extends Expression{
        final Expression variable;
        final Expression value;

        AssignmentExpression(Expression variable,Expression value){
            this.variable=variable;
            this.value=value;
        }


        @Override
        public String getExpressionType() {
            return "assign";
        }   
    }

    /**
     * Class for representing a single variable
     */
    static class Variable extends Expression{
        
        Variable(Token name){
            this.name=name;

        }
        @Override
        public String getExpressionType() {
            return "var";
        }
        final Token name;
        
    }

    /**
     * Class for representing an array variable
     */
    static class ArrayVariable extends Expression{
        ArrayVariable(Token name,List<Expression> positions){
            this.name=name;
            this.positions=positions;

        }
        @Override
        public String getExpressionType() {
            return "arrayvar";
        }
        final Token name;
        final List<Expression> positions;
    }

    /**
     * Class for representing a function call
     */
    static class FunctionCall extends Expression{
        FunctionCall(Token name, List<Token> arguments){
            this.arguments=arguments;
            this.name=name;
        }
        final List<Token> arguments;
        final Token name;

        @Override
        public String getExpressionType() {
            return "functCall";
        }
        
    }

    //Abstract method for getting an expression type
    public abstract String getExpressionType();
}