import os
import pkgutil
import imp

import builtin
import modules
import debug
import parsing
import evaluate


class ModuleNotFound(Exception):
    pass


class ImportPath(object):
    global_namespace = object()
    def __init__(self, import_stmt, is_like_search=False):
        """ replace """
        #print import_stmt
        self.import_path = []
        if import_stmt.from_ns:
            self.import_path += import_stmt.from_ns.names
        if import_stmt.namespace:
            self.import_path += import_stmt.namespace.names

        if is_like_search:
            # drop one path part, because that is used by the like search
            self.import_path.pop()

        self.file_path = os.path.dirname(import_stmt.get_parent_until().path)

    def get_defined_names(self):
        names = []
        for scope in self.follow():
            if scope is ImportPath.global_namespace:
                names += self.get_module_names()
                names += self.get_module_names([self.file_path])
            else:
                for s, n in evaluate.get_names_for_scope(scope,
                                                    include_builtin=False):
                    names += n
                if isinstance(scope, parsing.Module) \
                        and scope.path.endswith('__init__.py'):
                    names += \
                        self.get_module_names([os.path.dirname(scope.path)])
        return names

    def get_module_names(self, search_path=None):
        names = []
        for module_loader, name, is_pkg in pkgutil.iter_modules(search_path):
            names.append(parsing.Name([name], (float('inf'), float('inf')),
                                                (float('inf'), float('inf'))))
        return names

    def follow(self):
        """
        """
        if self.import_path:
            scope, rest = self.follow_file_system()
            if rest:
                scopes = evaluate.follow_path(iter(rest), scope)
            else:
                scopes = [scope]

            new = []
            for scope in scopes:
                new += remove_star_imports(scope)
            scopes += new
        else:
            scopes = [ImportPath.global_namespace]
        debug.dbg('after import', scopes)
        return scopes

    def follow_file_system(self):
        """
        Find a module with a path (of the module, like usb.backend.libusb10).
        TODO: relative imports
        """
        def follow_str(ns, string):
            debug.dbg('follow_module', ns, string)
            if ns:
                path = [ns[1]]
            else:
                path = None
                debug.dbg('search_module', string, path, self.file_path)
            try:
                i = imp.find_module(string, path)
            except ImportError:
                # find builtins (ommit path):
                i = imp.find_module(string, builtin.module_find_path)
            return i

        # TODO handle relative paths - they are included in the import object
        current_namespace = None
        builtin.module_find_path.insert(0, self.file_path)
        # now execute those paths
        rest = []
        for i, s in enumerate(self.import_path):
            try:
                current_namespace = follow_str(current_namespace, s)
            except ImportError:
                if current_namespace:
                    rest = self.import_path[i:]
                else:
                    raise ModuleNotFound(
                            'The module you searched has not been found')

        builtin.module_find_path.pop(0)
        path = current_namespace[1]
        is_package_directory = current_namespace[2][2] == imp.PKG_DIRECTORY

        f = None
        if is_package_directory or current_namespace[0]:
            # is a directory module
            if is_package_directory:
                path += '/__init__.py'
                with open(path) as f:
                    source = f.read()
            else:
                source = current_namespace[0].read()
            if path.endswith('.py'):
                f = modules.Module(path, source)
            else:
                f = builtin.Parser(path=path)
        else:
            f = builtin.Parser(name=path)

        return f.parser.top, rest

def strip_imports(scopes):
    """
    Here we strip the imports - they don't get resolved necessarily.
    Really used anymore?
    """
    result = []
    for s in scopes:
        if isinstance(s, parsing.Import):
            try:
                result += ImportPath(s).follow()
            except ModuleNotFound:
                debug.warning('Module not found: ' + str(s))
        else:
            result.append(s)
    return result

def remove_star_imports(scope):
    """
    """
    modules = strip_imports(i for i in scope.get_imports() if i.star)
    new = []
    for m in modules:
        new += remove_star_imports(m)
    modules += new

    # Filter duplicate modules.
    return set(modules)