package kompilatory_cv2;
import com.sun.org.apache.xpath.internal.SourceTree;
import javafx.util.Pair;

import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Stack;

/**
 *
 * @author Gooogle
 */
public class LispInterpreter {

    private String[] tokens;
    private Stack<String> stack;
    private HashMap<String,String> macroList;
    private HashMap<String,String> variableList;

    public LispInterpreter(String[] intputCode) {
        printInputCode(intputCode);
        this.tokens = intputCode;
        this.macroList = new HashMap<>();
        this.variableList = new HashMap<>();
    }

    public void Work() {
        stack = new Stack<String>();
        for (int i = 0; i < tokens.length; i++) {
            stack.push(tokens[i]);
            if (tokens[i].equals(")")) {
                Interprete();
            }
        }

        System.out.println("Defined macros in code" + macroList.toString());
        System.out.println("Defined variables in code" + variableList.toString());
    }

    private void Interprete() {
        String tok;
        Stack<String> callStack = new Stack<String>();
        tok = stack.pop();
        /* This is the ) character */
        while (!stack.isEmpty() && !(tok = stack.pop()).equals("(")) {
            callStack.push(tok);
        }
        Call(callStack);
    }

    private void Call(Stack<String> callStack) {
        String func = callStack.pop();
        if (func.equals("+")) {
            double result = Plus(callStack);
            stack.push(String.valueOf(result));
        }

        if (func.equals("-")) {
            double result = Minus(callStack);
            stack.push(String.valueOf(result));
        }
        if (func.equals("List")) {
            String result = LispList(callStack);
            stack.push(String.valueOf(result));
        }

        if (func.equals("defmacro")) {
            Pair<String,String> macro = getMacro(callStack);
            macroList.put(macro.getKey(),macro.getValue());
            stack.push(String.valueOf(macro));
        }

        if (func.equals("defvar")) {
            Pair<String,String> var = getVariable(callStack);
            variableList.put(var.getKey(),var.getValue());
            stack.push(String.valueOf(var));
        }
    }

    private double Plus(Stack<String> callStack) {
        ArrayList<Double> list = new ArrayList<>();
        for (int i = 0; i < callStack.size(); i++) {
            i = addValueToProcessList(callStack, list, i);
        }
        double ret = 0;
        for (int i = 0; i < list.size(); i++) {
            ret += list.get(i);
        }
        System.out.println("Calculate from "+list.toString()+" with Operation plus value is " + ret);
        return ret;
    }

    private double Minus(Stack<String> callStack) {
        ArrayList<Double> list = new ArrayList<>();
        for (int i = 0; i < callStack.size(); i++) {
            i = addValueToProcessList(callStack, list, i);
        }
        double ret = 0;
        for (int i = 0; i < list.size(); i++) {
            if (i == 0) {
                ret = list.get(i);
            } else {
                ret -= list.get(i);
            }
        }
        System.out.println("Calculate from "+list.toString()+" with Operation minus value is " + ret);
        return ret;
    }

    private String getMacroValue(String pop) {
        if (macroList.containsKey(pop)) {
            pop = macroList.get(pop);
        }
        return pop;
    }

    private String getVariableValue(String pop) {
        if (variableList.containsKey(pop)) {
            pop = variableList.get(pop);
        }
        return pop;
    }

    private String LispList(Stack<String> callStack) {
        ArrayList<Double> list = new ArrayList<>();
        for (int i = 0; i < callStack.size(); i++) {
            i = addValueToProcessList(callStack, list, i);
        }
        System.out.println("Processed list with values " + list);
        return list.toString();
    }

    private int addValueToProcessList(Stack<String> callStack, ArrayList<Double> list, int i) {
        String pop = callStack.pop();
        pop = getMacroValue(pop);
        pop = getVariableValue(pop);
        list.add(Double.parseDouble(pop));
        i--;
        return i;
    }

    private Pair<String,String> getVariable(Stack<String> callStack) {
        return new Pair<String,String>(callStack.pop(),callStack.pop());
    }
    private Pair<String,String> getMacro(Stack<String> callStack) {
        String macroName = callStack.pop();
        String macroStart = callStack.pop();
        String macroExpression = "";
        while (!callStack.empty()) {
            macroExpression += callStack.pop();
        }
        return new Pair<String,String>(macroName,macroExpression);
    }



    private void printInputCode(String[] intputCode) {
        String print = "";
        for (String s : intputCode) {
            s=s.replace('\'','\0');
            print += " "+s;
        }
        System.out.println("Input code: " + print);
    }


}