import copy
import inspect
import threading
import warnings
from collections import OrderedDict

from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from django.utils.module_loading import module_has_submodule

from haystack import constants
from haystack.exceptions import NotHandled, SearchFieldError
from haystack.utils import importlib
from haystack.utils.app_loading import haystack_get_app_modules


def import_class(path):
    path_bits = path.split(".")
    # Cut off the class name at the end.
    class_name = path_bits.pop()
    module_path = ".".join(path_bits)
    module_itself = importlib.import_module(module_path)

    if not hasattr(module_itself, class_name):
        raise ImportError(
            "The Python module '%s' has no '%s' class." % (module_path, class_name)
        )

    return getattr(module_itself, class_name)


# Load the search backend.
def load_backend(full_backend_path):
    """
    Loads a backend for interacting with the search engine.

    Requires a ``backend_path``. It should be a string resembling a Python
    import path, pointing to a ``BaseEngine`` subclass. The built-in options
    available include::

      * haystack.backends.solr.SolrEngine
      * haystack.backends.xapian.XapianEngine (third-party)
      * haystack.backends.whoosh.WhooshEngine
      * haystack.backends.simple.SimpleEngine

    If you've implemented a custom backend, you can provide the path to
    your backend & matching ``Engine`` class. For example::

      ``myapp.search_backends.CustomSolrEngine``

    """
    path_bits = full_backend_path.split(".")

    if len(path_bits) < 2:
        raise ImproperlyConfigured(
            "The provided backend '%s' is not a complete Python path to a BaseEngine subclass."
            % full_backend_path
        )

    return import_class(full_backend_path)


def load_router(full_router_path):
    """
    Loads a router for choosing which connection to use.

    Requires a ``full_router_path``. It should be a string resembling a Python
    import path, pointing to a ``BaseRouter`` subclass. The built-in options
    available include::

      * haystack.routers.DefaultRouter

    If you've implemented a custom backend, you can provide the path to
    your backend & matching ``Engine`` class. For example::

      ``myapp.search_routers.MasterSlaveRouter``

    """
    path_bits = full_router_path.split(".")

    if len(path_bits) < 2:
        raise ImproperlyConfigured(
            "The provided router '%s' is not a complete Python path to a BaseRouter subclass."
            % full_router_path
        )

    return import_class(full_router_path)


class ConnectionHandler:
    def __init__(self, connections_info):
        self.connections_info = connections_info
        self.thread_local = threading.local()
        self._index = None

    def ensure_defaults(self, alias):
        try:
            conn = self.connections_info[alias]
        except KeyError:
            raise ImproperlyConfigured(
                "The key '%s' isn't an available connection." % alias
            )

        if not conn.get("ENGINE"):
            conn["ENGINE"] = "haystack.backends.simple_backend.SimpleEngine"

    def __getitem__(self, key):
        if not hasattr(self.thread_local, "connections"):
            self.thread_local.connections = {}
        elif key in self.thread_local.connections:
            return self.thread_local.connections[key]

        self.ensure_defaults(key)
        self.thread_local.connections[key] = load_backend(
            self.connections_info[key]["ENGINE"]
        )(using=key)
        return self.thread_local.connections[key]

    def reload(self, key):
        if not hasattr(self.thread_local, "connections"):
            self.thread_local.connections = {}
        try:
            del self.thread_local.connections[key]
        except KeyError:
            pass

        return self.__getitem__(key)

    def all(self):  # noqa A003
        return [self[alias] for alias in self.connections_info]


class ConnectionRouter:
    def __init__(self):
        self._routers = None

    @property
    def routers(self):
        if self._routers is None:
            default_routers = ["haystack.routers.DefaultRouter"]
            router_list = getattr(settings, "HAYSTACK_ROUTERS", default_routers)
            # in case HAYSTACK_ROUTERS is empty, fallback to default routers
            if not len(router_list):
                router_list = default_routers

            self._routers = []
            for router_path in router_list:
                router_class = load_router(router_path)
                self._routers.append(router_class())
        return self._routers

    def _for_action(self, action, many, **hints):
        conns = []

        for router in self.routers:
            if hasattr(router, action):
                action_callable = getattr(router, action)
                connection_to_use = action_callable(**hints)

                if connection_to_use is not None:
                    if isinstance(connection_to_use, str):
                        conns.append(connection_to_use)
                    else:
                        conns.extend(connection_to_use)
                    if not many:
                        break

        return conns

    def for_write(self, **hints):
        return self._for_action("for_write", True, **hints)

    def for_read(self, **hints):
        return self._for_action("for_read", False, **hints)[0]


class UnifiedIndex:
    # Used to collect all the indexes into a cohesive whole.
    def __init__(self, excluded_indexes=None):
        self._indexes = {}
        self.fields = OrderedDict()
        self._built = False
        self.excluded_indexes = excluded_indexes or []
        self.excluded_indexes_ids = {}
        self.document_field = constants.DOCUMENT_FIELD
        self._fieldnames = {}
        self._facet_fieldnames = {}

    @property
    def indexes(self):
        warnings.warn(
            "'UnifiedIndex.indexes' was deprecated in Haystack v2.3.0. Please use UnifiedIndex.get_indexes()."
        )
        return self._indexes

    def collect_indexes(self):
        indexes = []

        for app_mod in haystack_get_app_modules():
            try:
                search_index_module = importlib.import_module(
                    "%s.search_indexes" % app_mod.__name__
                )
            except ImportError:
                if module_has_submodule(app_mod, "search_indexes"):
                    raise

                continue

            for item_name, item in inspect.getmembers(
                search_index_module, inspect.isclass
            ):
                if getattr(item, "haystack_use_for_indexing", False) and getattr(
                    item, "get_model", None
                ):
                    # We've got an index. Check if we should be ignoring it.
                    class_path = "%s.search_indexes.%s" % (app_mod.__name__, item_name)

                    if (
                        class_path in self.excluded_indexes
                        or self.excluded_indexes_ids.get(item_name) == id(item)
                    ):
                        self.excluded_indexes_ids[str(item_name)] = id(item)
                        continue

                    indexes.append(item())

        return indexes

    def reset(self):
        self._indexes = {}
        self.fields = OrderedDict()
        self._built = False
        self._fieldnames = {}
        self._facet_fieldnames = {}

    def build(self, indexes=None):
        self.reset()

        if indexes is None:
            indexes = self.collect_indexes()

        for index in indexes:
            model = index.get_model()

            if model in self._indexes:
                raise ImproperlyConfigured(
                    "Model '%s' has more than one 'SearchIndex`` handling it. "
                    "Please exclude either '%s' or '%s' using the 'EXCLUDED_INDEXES' "
                    "setting defined in 'settings.HAYSTACK_CONNECTIONS'."
                    % (model, self._indexes[model], index)
                )

            self._indexes[model] = index
            self.collect_fields(index)

        self._built = True

    def collect_fields(self, index):
        for fieldname, field_object in index.fields.items():
            if field_object.document is True:
                if field_object.index_fieldname != self.document_field:
                    raise SearchFieldError(
                        "All 'SearchIndex' classes must use the same '%s' fieldname for the 'document=True' field. Offending index is '%s'."
                        % (self.document_field, index)
                    )

            # Stow the index_fieldname so we don't have to get it the hard way again.
            if (
                fieldname in self._fieldnames
                and field_object.index_fieldname != self._fieldnames[fieldname]
            ):
                # We've already seen this field in the list. Raise an exception if index_fieldname differs.
                raise SearchFieldError(
                    "All uses of the '%s' field need to use the same 'index_fieldname' attribute."
                    % fieldname
                )

            self._fieldnames[fieldname] = field_object.index_fieldname

            # Stow the facet_fieldname so we don't have to look that up either.
            if hasattr(field_object, "facet_for"):
                if field_object.facet_for:
                    self._facet_fieldnames[field_object.facet_for] = fieldname
                else:
                    self._facet_fieldnames[field_object.instance_name] = fieldname

            # Copy the field in so we've got a unified schema.
            if field_object.index_fieldname not in self.fields:
                self.fields[field_object.index_fieldname] = field_object
                self.fields[field_object.index_fieldname] = copy.copy(field_object)
            else:
                # If the field types are different, we can mostly
                # safely ignore this. The exception is ``MultiValueField``,
                # in which case we'll use it instead, copying over the
                # values.
                if field_object.is_multivalued:
                    old_field = self.fields[field_object.index_fieldname]
                    self.fields[field_object.index_fieldname] = field_object
                    self.fields[field_object.index_fieldname] = copy.copy(field_object)

                    # Switch it so we don't have to dupe the remaining
                    # checks.
                    field_object = old_field

                # We've already got this field in the list. Ensure that
                # what we hand back is a superset of all options that
                # affect the schema.
                if field_object.indexed is True:
                    self.fields[field_object.index_fieldname].indexed = True

                if field_object.stored is True:
                    self.fields[field_object.index_fieldname].stored = True

                if field_object.faceted is True:
                    self.fields[field_object.index_fieldname].faceted = True

                if field_object.use_template is True:
                    self.fields[field_object.index_fieldname].use_template = True

                if field_object.null is True:
                    self.fields[field_object.index_fieldname].null = True

    def get_indexes(self):
        if not self._built:
            self.build()

        return self._indexes

    def get_indexed_models(self):
        # Ensuring a list here since Python3 will give us an iterator
        return list(self.get_indexes().keys())

    def get_index_fieldname(self, field):
        if not self._built:
            self.build()

        return self._fieldnames.get(field) or field

    def get_index(self, model_klass):

        indexes = self.get_indexes()

        if model_klass not in indexes:
            raise NotHandled("The model %s is not registered" % model_klass)

        return indexes[model_klass]

    def get_facet_fieldname(self, field):
        if not self._built:
            self.build()

        for fieldname, field_object in self.fields.items():
            if fieldname != field:
                continue

            if hasattr(field_object, "facet_for"):
                if field_object.facet_for:
                    return field_object.facet_for
                else:
                    return field_object.instance_name
            else:
                return self._facet_fieldnames.get(field) or field

        return field

    def all_searchfields(self):
        if not self._built:
            self.build()

        return self.fields
