from django.conf import settings
from opensearchpy import OpenSearch
from opensearchpy.exceptions import RequestError

from core.lib.threshold import annotate_num_chans, annotate_num_users, annotate_online


def initialise_opensearch():
    """
    Inititialise the OpenSearch API endpoint.
    """
    auth = (settings.OPENSEARCH_USERNAME, settings.OPENSEARCH_PASSWORD)
    client = OpenSearch(
        # fmt: off
        hosts=[{"host": settings.OPENSEARCH_URL,
                "port": settings.OPENSEARCH_PORT}],
        http_compress=False,  # enables gzip compression for request bodies
        http_auth=auth,
        # client_cert = client_cert_path,
        # client_key = client_key_path,
        use_ssl=settings.OPENSEARCH_TLS,
        verify_certs=False,
        ssl_assert_hostname=False,
        ssl_show_warn=False,
        # a_certs=ca_certs_path,
    )
    return client


client = initialise_opensearch()


def annotate_results(results_parsed):
    """
    Accept a list of dict objects, search for the number of channels and users.
    Add them to the object.
    Mutate it in place. Does not return anything.
    """
    # Figure out items with net (not discord)
    nets = set()
    for x in results_parsed:
        if "net" in x:
            nets.add(x["net"])

    for net in nets:
        # Annotate the online attribute from Threshold
        online_info = annotate_online(
            net, [x["nick"] for x in results_parsed if x["src"] == "irc"]
        )
        # Annotate the number of users in the channel
        num_users = annotate_num_users(
            net, [x["channel"] for x in results_parsed if x["src"] == "irc"]
        )
        # Annotate the number channels the user is on
        num_chans = annotate_num_chans(
            net, [x["nick"] for x in results_parsed if x["src"] == "irc"]
        )
        for item in results_parsed:
            if item["nick"] in online_info:
                item["online"] = online_info[item["nick"]]
            if item["channel"] in num_users:
                item["num_users"] = num_users[item["channel"]]
            if item["nick"] in num_chans:
                item["num_chans"] = num_chans[item["nick"]]


def filter_blacklisted(user, response):
    """
    Low level filter to take the raw OpenSearch response and remove
    objects from it we want to keep secret.
    Does not return, the object is mutated in place.
    """
    response["redacted"] = 0
    response["exemption"] = None
    # For every hit from ES
    for item in list(response["hits"]["hits"]):
        # For every blacklisted type
        for blacklisted_type in settings.OPENSEARCH_BLACKLISTED.keys():
            # Check this field we are matching exists
            if blacklisted_type in item["_source"].keys():
                content = item["_source"][blacklisted_type]
                # For every item in the blacklisted array for the type
                for blacklisted_item in settings.OPENSEARCH_BLACKLISTED[
                    blacklisted_type
                ]:
                    if blacklisted_item in str(content):
                        # Remove the item
                        if item in response["hits"]["hits"]:
                            if not user.is_superuser:
                                response["hits"]["hits"].remove(item)
                            # Let the UI know something was redacted
                            response["redacted"] += 1
                            response["exemption"] = True


def run_main_query(client, user, query, custom_query=False, size=None):
    """
    Low level helper to run an ES query.
    Accept a user to pass it to the filter, so we can
    avoid filtering for superusers.
    Accept fields and size, for the fields we want to match and the
    number of results to return.
    """
    if custom_query:
        search_query = query
    else:
        search_query = construct_query(query, size)
    try:
        response = client.search(
            body=search_query, index=settings.OPENSEARCH_INDEX_MAIN
        )
    except RequestError:
        print("REQUEST ERROR")
        return False
    filter_blacklisted(user, response)
    return response


def query_results(request, size=None):
    """
    API helper to alter the OpenSearch return format into something
    a bit better to parse.
    Accept a HTTP request object. Run the query, and annotate the
    results with the other data we have.
    """
    if not size:
        if "size" in request.POST:
            size = request.POST["size"]
            if size not in settings.OPENSEARCH_MAIN_SIZES:
                return False
    if "query" in request.POST:
        query = request.POST["query"]
        results = run_main_query(
            client,
            request.user,
            query,
            size=size,
        )
        if not results:
            return False
        results_parsed = []
        if "hits" in results.keys():
            if "hits" in results["hits"]:
                for item in results["hits"]["hits"]:
                    element = item["_source"]
                    element["id"] = item["_id"]

                    # Split the timestamp into date and time
                    ts = element["ts"]
                    ts_spl = ts.split("T")
                    date = ts_spl[0]
                    time = ts_spl[1]
                    element["date"] = date
                    element["time"] = time
                    results_parsed.append(element)

        annotate_results(results_parsed)

        context = {
            "query": query,
            "results": results_parsed,
            "card": results["hits"]["total"]["value"],
            "took": results["took"],
            "redacted": results["redacted"],
            "exemption": results["exemption"],
        }
        return context


def query_single_result(request):
    context = query_results(request, 1)
    dedup_set = {item["nick"] for item in context["results"]}
    if len(dedup_set) == 1:
        context["item"] = context["results"][0]
    else:
        return (len(dedup_set), context)
    return (1, context)


def construct_query(query, size):
    """
    Accept some query parameters and construct an OpenSearch query.
    """
    if not size:
        size = 5
    query = {
        "size": size,
        "query": {
            "query_string": {
                "query": query,
                # "fields": fields,
                # "default_field": "msg",
                # "type": "best_fields",
                "fuzziness": "AUTO",
                "fuzzy_transpositions": True,
                "fuzzy_max_expansions": 50,
                "fuzzy_prefix_length": 0,
                # "minimum_should_match": 1,
                "default_operator": "or",
                "analyzer": "standard",
                "lenient": True,
                "boost": 1,
                "allow_leading_wildcard": True,
                # "enable_position_increments": False,
                "phrase_slop": 3,
                # "max_determinized_states": 10000,
                "quote_field_suffix": "",
                "quote_analyzer": "standard",
                "analyze_wildcard": False,
                "auto_generate_synonyms_phrase_query": True,
            }
        },
        "sort": [
            {
                "ts": {
                    "order": "desc",
                }
            }
        ],
    }
    return query