import java.util.*;

import java.awt.*;



public class RobotProgram {

    private boolean validProgramLoaded;

    private ArrayList<ENode> roots = new ArrayList<ENode>();

    public boolean validProgramLoaded() {

        return this.validProgramLoaded;

    }



    public boolean parse(Scanner program) {

        //System.out.println("TODO: Load a progam from the Scanner " +

        //"provided using a Parse Tree representation of your own design.");

        this.validProgramLoaded = true;

        while(program.hasNext()) {

            ENode n = parseInstruction(program);





            if(n == null) {

                validProgramLoaded = false;

                break;

            }

            if(!program.hasNext()) {

                validProgramLoaded = false;

                break;

            }





        roots.add(n);

        }





        return this.validProgramLoaded;

    }



    public ENode parseInstruction(Scanner s) {

        if(!s.hasNext()) return null;

        String token = s.next();

        ENode n = null;

        System.out.println(token);

        ArrayList<ENode> children = new ArrayList<ENode>();

        children.add(new TerminalNode(token));

        if(token.equalsIgnoreCase("MOVE") || token.equalsIgnoreCase("TURN")) {

        children = parseN(s, children);


            if(!validVarName(name)) // If the variable contains special characters

                return null;

            children = parseN(s,children);

        }else if(varMap.containsKey(token)) {

            s.next(); // Skip Equals

            children = parseN(s, children);

        }



        if(children == null) return new TerminalNode(token);

        n = new ExpressionNode(children);

        return n;

    }

    public boolean execute(int robotID, World world, Graphics g) {

        if (this.validProgramLoaded) {

            System.out.println("TODO: Execute a program using your parse tree representation.");

            Scanner scan;

            for(ENode e: roots) {

                String str = e.toString();

                System.out.println(str);

                scan = new Scanner(str);

                String temp = scan.next();

                if(temp.equalsIgnoreCase("DROP"))

                    world.drop(robotID, g);

                else if(temp.equalsIgnoreCase("PICKUP"))

                    world.pickUp(robotID, g);

                else if(temp.equalsIgnoreCase("MOVE")) {

                    world.moveRobot(robotID, getNumber(e, world, robotID), g);

                }


                }else if(temp.equals("TURN_TOWARDS_FIRST_BOX")) {

                    world.turnTowardsFirstBox(robotID, g);

                }else if(temp.equalsIgnoreCase("TURN_TOWARDS_FIRST_THING")) {

                    world.turnTowardsFirstThing(robotID, g);

                }

                else {

                    ExpressionNode en = (ExpressionNode) e;

                    //TODO Deal with Var assignment;



                }

            }



            return true;

        } else {

            return false;

        }

    }

    private int getNumber(ENode n, World w, int robotID) {

        String str = n.toString();

        System.out.println(str);

        Scanner scan = new Scanner(str);

        scan.next(); // Skip Token

        if(scan.hasNextInt())

            return scan.nextInt();




            else {

                return varMap.get(scan.next());

            }





    }

    private boolean condParser(ENode a, ENode b) {

        return true;

    }

    private boolean condParser(ENode a) {

        return true;

    }

    public boolean validVarName(String var) {



        if(var.contains("`")||var.contains("~")||var.contains("!")||

                var.contains("@")||var.contains("#")||var.contains("$")

                || var.contains("%")||var.contains("^")|| var.contains("&")||

                var.contains("*")||var.contains("(")||var.contains(")")||var.contains("-")

                || var.contains("_")|| var.contains("=")||var.contains("+")||var.contains("[")

                || var.contains("]")||var.contains("{")||var.contains("}")||var.contains("\\")
                ||var.contains(".")||var.contains("?")||var.contains("/")||Character.isDigit(var.charAt(0)))

            return false;

        else

            return true;

    }

    public ArrayList<ENode> parseN(Scanner s, ArrayList<ENode> children) {

    if(s.hasNextInt()) {

            int i = s.nextInt();

        children.add(new TerminalNode(""+i));

        return children;

        }

    else if(s.hasNext()) {

        String token = s.next();

        if(token.equalsIgnoreCase("NUMBER_OF_THINGS_NOT_IN_BOXES")|| token.equalsIgnoreCase("DISTANCE_TO_FIRST_THING") ||

            token.equalsIgnoreCase("DISTANCE_TO_FIRST_BOX")) {

            children.add(new TerminalNode(token));

            return children;

    }

        else {

            if(validVarName(token) && varMap.containsKey(token)) {

                children.add(new TerminalNode(""+varMap.get(token)));

                }



        } }

        return null;







    }

    interface ENode {public String toString();}

    class ExpressionNode implements ENode {

        private ArrayList<ENode>children; // IN ORDER

        public ExpressionNode(ArrayList<ENode> children) {

            this.children = children;

        }

        public String toString() {

            String result = "";

            for(ENode n: children) {

                result+=n.toString() + " ";

            }

            return result;

        }

    }

    class TerminalNode implements ENode {

        private String value;

        public TerminalNode(String value) {

            this.value = value;

        }

        public String toString() {

            return this.value;

        }

    }

}