import org.eclipse.cdt.core.dom.ast.*;
import org.eclipse.cdt.internal.core.dom.parser.ASTAmbiguousNode;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTBinaryExpression;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTDeclarator;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTExpressionStatement;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;

public class MyVisitor extends ASTGenericVisitor {
    public MyVisitor(boolean visitNodes) {
        super(visitNodes);
    }

    @Override
    public int visit(IASTDeclaration declaration) {
        return super.visit(declaration);
    }

    private void printRaw(IASTNode node) {
        System.out.println("::::\n" + node.getRawSignature() + " <<< " + node.getClass().toString());
        for (IASTNode node1:node.getChildren()) {
            printRaw(node1);
        }
    }

//    @Override
//    public int visit(IASTStatement statement) {
//        //System.out.println("::::\n"+statement.getRawSignature());
//        return super.visit(statement);
//    }

    @Override
    public int visit(IASTName name) {
        //System.out.println("::::\n"+name.getRawSignature());
        return super.visit(name);
    }

    /*@Override
    public int visit(IASTToken token) {
        System.out.println("::::\n"+token.getRawSignature());
        return super.visit(token);
    }*/

    @Override
    public int visit(IASTTranslationUnit tu) {
        //System.out.println("::::\n"+tu.getRawSignature());
        return super.visit(tu);
    }

    @Override
    public int visit(IASTStatement statement) {
        HashMap<String, ArrayList<String>> nodeMap = new HashMap<String, ArrayList<String>>();
        for (IASTNode iastNode:statement.getChildren()) {
            if (iastNode instanceof CASTBinaryExpression) {
                ArrayList<String> nodeList = nodeMap.get(iastNode.getParent().getRawSignature());
                if (nodeList == null) {
                    ArrayList<String> list = new ArrayList<String>();
                    list.add(iastNode.getRawSignature());
                    nodeMap.put(iastNode.getParent().getRawSignature(), list);
                } else {
                    nodeList.add(iastNode.getRawSignature());
                }
            }
//            System.out.println("::::\n"+iastNode.getRawSignature() + " <<< " + iastNode.getClass().toString());
        }
        int i = 0;
        for (String parent : nodeMap.keySet()) {
            System.out.println("In position i = "+i+" we have the nodes: ");
            for (String s : nodeMap.get(parent)) {
                System.out.println("-> "+s);
            }
            i++;
        }
        return super.visit(statement);
    }

    @Override
    protected int genericVisit(IASTNode node) {
        for (IASTNode n:node.getChildren()) {
            if (n instanceof  IASTWhileStatement) {
                for (IASTNode whileNode:n.getChildren()) {
                    if (whileNode instanceof  IASTBinaryExpression) {
//                        System.out.println(whileNode.getRawSignature());
                    }
                }
            }
            if (n instanceof  IASTBinaryExpression) {
                if (n.getParent() instanceof IASTWhileStatement) {
//                    System.out.println(n.getRawSignature());
                }
            }
//            System.out.println("::::\n"+node.getRawSignature() + " <<< " + node.getClass().toString());
        }
        return super.genericVisit(node);
    }

}