package main;

import tp6.analysis.Analysis;
import tp6.node.*;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Stack;


public class Interpreter extends AbstractInterpreter implements Analysis {
    private static Map<String, Integer> variables = new HashMap<>();
    private static Stack<Integer> stack = new Stack<>();

    @Override
    public void caseAAssignment(AAssignment node) {
        node.getRhs().apply(this);
        variables.put(node.getVar().toString().trim(), stack.pop());
    }

    @Override
    public void caseABinexpression(ABinexpression node) {
        String op = node.getOperator().toString().trim();
        node.getLExp().apply(this);
        int var1 = stack.pop();

        if((node.getRExp() instanceof ABinexpressionExpression) && (op.equals("/") || op.equals("*") || op.equals("%"))) {
            ABinexpression node2 = (ABinexpression) ((ABinexpressionExpression) node.getRExp()).getBinexpression();
            node2.getLExp().apply(this);
            int var2 = stack.pop();
            doCalcul(op, var1, var2);
            node2.setLExp(new AIntegervalueUniexpression(new AIntegervalue(new TNumber(stack.pop() + ""))));
            node2.apply(this);
        }
        else {
            node.getRExp().apply(this);
            int var2 = stack.pop();
            doCalcul(op, var1, var2);
        }
    }

    private void doCalcul(String op, int var1, int var2) {
        switch (op) {
            case "+":
                stack.push(var1 + var2);
                break;
            case "-":
                stack.push(var1 - var2);
                break;
            case "*":
                stack.push(var1 * var2);
                break;
            case "/":
                stack.push(var1 / var2);
                break;
            case "%":
                stack.push(var1 % var2);
                break;
            case "==":
                stack.push(var1 == var2 ? 1 : 0);
                break;
            case ">":
                stack.push(var1 > var2 ? 1 : 0);
                break;
            case "<":
                stack.push(var1 < var2 ? 1 : 0);
                break;
            default:
                System.err.println("Operation not allowed : " + var1 + " " + op + " " + var2);
                System.exit(1);
        }
    }

    @Override
    public void caseAVariableref(AVariableref node) {
        if(!variables.containsKey(node.getIdentifier().toString().trim())) {
            System.err.println("Variable " + node.getIdentifier().toString().trim() + " doesn't exist.");
            System.exit(1);
        }
        else {
            stack.push(variables.get(node.getIdentifier().toString().trim()));
        }
    }

    @Override
    public void caseAIntegervalue(AIntegervalue node) {
        stack.push(Integer.parseInt(node.getNumber().toString().trim()));
    }

    @Override
    public void caseABlock(ABlock node) {
        for(PStatement s : node.getStatement()) {
            s.apply(this);
        }
    }

    @Override
    public void caseAConditional(AConditional node) {
        node.getCond().apply(this);
        int cond = stack.pop();
        if(cond == 1) {
            node.getThenpart().apply(this);
        }
        else if(!node.getElse().toString().isEmpty()) {
            node.getElsepart().apply(this);
        }
    }

    @Override
    public void caseAWhileS(AWhileS node) {
        while (true) {
            node.getCond().apply(this);
            int cond = stack.pop();
            if(cond == 1) {
                node.getBody().apply(this);
            }
            else {
                break;
            }
        }
    }

    @Override
    public void caseAPrintS(APrintS node) {
        if(variables.containsKey(node.getValue().toString().trim())) {
            System.out.println(variables.get(node.getValue().toString().trim()));
        }
        else {
            System.out.println(node.getValue().toString().trim());
        }
    }


    @Override
    public void caseAReadS(AReadS node) {
        Scanner input = new Scanner(System.in);
        System.out.print(node.getVar() + " ? ");
        Integer read = input.nextInt();
        variables.putIfAbsent(node.getVar().toString().trim(), read);
    }

    /*
     * ignored
     */

    @Override
    public void caseAMinusOperatorarith(AMinusOperatorarith node) {}

    @Override
    public void caseAMultiplierOperatorarith(AMultiplierOperatorarith node) {}

    @Override
    public void caseAPlusOperatorarith(APlusOperatorarith node) {}

    @Override
    public void caseADiviserOperatorarith(ADiviserOperatorarith node) {}

    @Override
    public void caseAModuloOperatorarith(AModuloOperatorarith node) {}

    @Override
    public void caseASupOperatorlogique(ASupOperatorlogique node) {}

    @Override
    public void caseAEqualOperatorlogique(AEqualOperatorlogique node) {}

    @Override
    public void caseAInfOperatorlogique(AInfOperatorlogique node) {}

}