/**
 * Copyright (c) 2005-2013 by Appcelerator, Inc. All Rights Reserved.
 * Licensed under the terms of the Eclipse Public License (EPL).
 * Please see the license.txt included with this distribution for details.
 * Any modifications to this file must keep this entire header intact.
 */
package com.python.pydev.analysis.scopeanalysis;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.python.pydev.core.ILocalScope;
import org.python.pydev.core.IModule;
import org.python.pydev.core.docutils.PySelection;
import org.python.pydev.core.log.Log;
import org.python.pydev.editor.codecompletion.revisited.modules.SourceModule;
import org.python.pydev.parser.jython.SimpleNode;
import org.python.pydev.parser.jython.ast.Attribute;
import org.python.pydev.parser.jython.ast.ClassDef;
import org.python.pydev.parser.jython.ast.FunctionDef;
import org.python.pydev.parser.jython.ast.Name;
import org.python.pydev.parser.jython.ast.Str;
import org.python.pydev.parser.jython.ast.commentType;
import org.python.pydev.parser.jython.ast.decoratorsType;
import org.python.pydev.parser.jython.ast.exprType;
import org.python.pydev.parser.jython.ast.stmtType;
import org.python.pydev.parser.visitors.NodeUtils;
import org.python.pydev.parser.visitors.scope.ASTEntry;
import org.python.pydev.parser.visitors.scope.SequencialASTIteratorVisitor;
import org.python.pydev.shared_core.structure.Tuple;

public class ScopeAnalysis {

    public static List<ASTEntry> getAttributeReferences(String occurencesFor, SimpleNode simpleNode) {
        //default is accepting all
        return getAttributeReferences(occurencesFor, simpleNode, AttributeReferencesVisitor.ACCEPT_ALL);
    }

    /**
     * @return the list of entries with the name parts of attributes (not taking into account its first
     * part) that are equal to the occurencesFor string. 
     */
    public static List<ASTEntry> getAttributeReferences(String occurencesFor, SimpleNode simpleNode, int accept) {
        List<ASTEntry> ret = new ArrayList<ASTEntry>();

        AttributeReferencesVisitor visitor = AttributeReferencesVisitor.create(simpleNode, accept);
        Iterator<ASTEntry> iterator = visitor.getNamesIterator();

        while (iterator.hasNext()) {
            ASTEntry entry = iterator.next();
            String rep = NodeUtils.getFullRepresentationString(entry.node);
            if (rep.equals(occurencesFor)) {
                ret.add(entry);
            }
        }
        return ret;
    }

    /**
     * @param occurencesFor the string we're looking for
     * @param module the module where we want to find the occurrences
     * @param scope the scope we're in
     * @return tuple with:
     * 1st element: the node where the local was found (may be null)
     * 2nd element: a list of entries with the occurrences
     */
    public static Tuple<SimpleNode, List<ASTEntry>> getLocalOccurrences(String occurencesFor, IModule module,
            ILocalScope scope) {
        SimpleNode simpleNode = null;

        if (scope.getScopeStack().size() > 0) {
            simpleNode = (SimpleNode) scope.getScopeStack().peek();

        } else if (module instanceof SourceModule) {
            SourceModule m = (SourceModule) module;
            simpleNode = m.getAst();
        }

        if (simpleNode == null) {
            return new Tuple<SimpleNode, List<ASTEntry>>(null, new ArrayList<ASTEntry>());
        }

        return new Tuple<SimpleNode, List<ASTEntry>>(simpleNode, ScopeAnalysis.getLocalOccurrences(occurencesFor,
                simpleNode));
    }

    /**
     * @param occurencesFor the string we're looking for
     * @param simpleNode we will want the occurences below this node
     * @return a list of entries with the occurrences
     */
    public static List<ASTEntry> getLocalOccurrences(String occurencesFor, SimpleNode simpleNode) {
        return ScopeAnalysis.getLocalOccurrences(occurencesFor, simpleNode, true);
    }

    /**
     * @return a list of ast entries that are found inside strings.
     */
    public static List<ASTEntry> getStringOccurrences(final String occurencesFor, SimpleNode simpleNode) {
        final List<ASTEntry> ret = new ArrayList<ASTEntry>();

        SequencialASTIteratorVisitor visitor = new SequencialASTIteratorVisitor() {
            @Override
            public Object visitStr(Str node) throws Exception {
                String str = NodeUtils.getStringToPrint(node);
                List<Name> names = checkSimpleNodeForTokenMatch(occurencesFor, new ArrayList<Name>(), node, str);
                for (Name name : names) {
                    ASTEntry astEntryToAdd = atomic(name);
                    astEntryToAdd.setAdditionalInfo(AstEntryScopeAnalysisConstants.AST_ENTRY_FOUND_LOCATION,
                            AstEntryScopeAnalysisConstants.AST_ENTRY_FOUND_IN_STRING);
                    ret.add(astEntryToAdd);
                }
                return super.visitStr(node);
            }

        };
        try {
            simpleNode.accept(visitor);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return ret;
    }

    /**
     * @return a list of ast entries that are found inside comments.
     */
    public static List<ASTEntry> getCommentOccurrences(final String occurencesFor, SimpleNode simpleNode) {
        final List<ASTEntry> ret = new ArrayList<ASTEntry>();

        SequencialASTIteratorVisitor visitor = new SequencialASTIteratorVisitor() {
            @Override
            protected Object unhandled_node(SimpleNode node) throws Exception {
                Object r = super.unhandled_node(node);
                //now, we have to check it for occurrences in comments and strings too... (and create 
                //names for those)
                checkNode(occurencesFor, ret, node);
                return r;
            }

            @Override
            public Object visitClassDef(ClassDef node) throws Exception {
                Object r = super.visitClassDef(node);
                checkNode(occurencesFor, ret, node);
                return r;
            }

            @Override
            public Object visitFunctionDef(FunctionDef node) throws Exception {
                Object r = super.visitFunctionDef(node);
                checkNode(occurencesFor, ret, node);
                return r;
            }

            private void checkNode(final String occurencesFor, final List<ASTEntry> ret, SimpleNode node) {
                List<Name> names = checkComments(node.specialsBefore, occurencesFor);
                names.addAll(checkComments(node.specialsAfter, occurencesFor));
                for (Name name : names) {
                    ASTEntry astEntryToAdd = atomic(name);
                    astEntryToAdd.setAdditionalInfo(AstEntryScopeAnalysisConstants.AST_ENTRY_FOUND_LOCATION,
                            AstEntryScopeAnalysisConstants.AST_ENTRY_FOUND_IN_COMMENT);
                    ret.add(astEntryToAdd);
                }
            }

        };
        try {
            simpleNode.accept(visitor);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return ret;
    }

    /**
     * @return a list of occurrences with the matches we're looking for.
     * Does only return the first name in attributes if onlyFirstAttribPart is true (otherwise will check all attribute parts)
     */
    public static List<ASTEntry> getLocalOccurrences(final String occurencesFor, SimpleNode simpleNode,
            final boolean onlyFirstAttribPart) {
        List<ASTEntry> ret = new ArrayList<ASTEntry>();

        SequencialASTIteratorVisitor visitor = new SequencialASTIteratorVisitor() {

            @Override
            public Object visitAttribute(Attribute node) throws Exception {
                if (onlyFirstAttribPart) {
                    //this will visit the attribute parts if call, subscript, etc.
                    AbstractScopeAnalyzerVisitor.visitNeededAttributeParts(node, this);

                    List<SimpleNode> attributeParts = NodeUtils.getAttributeParts(node);
                    atomic(attributeParts.get(0)); //an attribute should always have many parts
                    traverse(attributeParts.get(0));
                    return null;
                } else {
                    return super.visitAttribute(node);
                }
            }
        };
        if (simpleNode instanceof FunctionDef) {
            //all that because we don't want to visit the name of the function if we've started in a function scope
            FunctionDef d = (FunctionDef) simpleNode;
            try {
                //decorators
                if (d.decs != null) {
                    for (decoratorsType dec : d.decs) {
                        if (dec != null) {
                            dec.accept(visitor);
                        }
                    }
                }

                //don't do d.args directly because we don't want to check the 'defaults'
                if (d.args != null) {
                    if (d.args.args != null) {
                        for (exprType arg : d.args.args) {
                            arg.accept(visitor);
                        }
                    }
                    if (d.args.vararg != null) {
                        d.args.vararg.accept(visitor);
                    }
                    if (d.args.kwarg != null) {
                        d.args.kwarg.accept(visitor);
                    }
                    //visit keyword only args
                    if (d.args.kwonlyargs != null) {
                        for (exprType expr : d.args.kwonlyargs) {
                            expr.accept(visitor);
                        }
                    }

                }

                //and at last... the body
                if (d.body != null) {
                    for (stmtType exp : d.body) {
                        if (exp != null) {
                            exp.accept(visitor);
                        }
                    }
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        } else {

            try {
                simpleNode.accept(visitor);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        Iterator<ASTEntry> iterator = visitor.getNamesIterator();
        while (iterator.hasNext()) {
            ASTEntry entry = iterator.next();
            //SimpleNode nameNode = entry.getNameNode();
            //if(!occurencesFor.isParamRename){
            //    if(nameNode instanceof NameTok){
            //        NameTok name = (NameTok) nameNode;
            //        if(name.ctx == NameTok.KeywordName){
            //            continue;
            //        }
            //   }
            //}
            if (occurencesFor.equals(entry.getName())) {
                ret.add(entry);
            }
        }
        return ret;
    }

    /**
     * @param specials a list that may contain comments
     * @param match a string to match in the comments
     * @return a list with names matching the gives token
     */
    public static List<Name> checkComments(List<Object> specials, String match) {
        List<Name> r = new ArrayList<Name>();

        if (specials != null) {
            for (Object s : specials) {
                if (s instanceof commentType) {
                    commentType comment = (commentType) s;
                    checkSimpleNodeForTokenMatch(match, r, comment, comment.id);
                }
            }
        }
        return r;
    }

    /**
     * Looks for a match in the given string and fills the List<Name> with Names according to those positions.
     * @return the list of names (same as ret)
     */
    public static List<Name> checkSimpleNodeForTokenMatch(String match, List<Name> ret, SimpleNode node,
            String fullString) {
        try {
            ArrayList<Integer> offsets = TokenMatching.getMatchOffsets(match, fullString);
            List<Integer> lineStartOffsets = PySelection.getLineStartOffsets(fullString);

            for (Integer offset : offsets) {
                int line = 0;
                Name name = new Name(match, Name.Artificial, false);

                for (Integer lineStartOffset : lineStartOffsets) {
                    if (line == 0 && lineStartOffset > 0) {
                        line = 1;//because it starts with a new line
                    }
                    if (lineStartOffset <= offset) {
                        name.beginLine = node.beginLine + line;
                        if (line == 0) {
                            name.beginColumn = node.beginColumn + offset - lineStartOffset;
                        } else {
                            name.beginColumn = offset - lineStartOffset + 1;
                        }
                    } else {
                        break;
                    }
                    line++;
                }
                ret.add(name);
            }
        } catch (CoreException e) {
            Log.log(e);
        }
        return ret;
    }

}