import copy
import inspect
import logging
from datetime import datetime
from typing import Any

import pytz
import tornado
import tornado_eventsource.handler
from tornado import httputil
from tornado.web import Application

from core.prometheus_metrics_handler import api_requests_counter
from core.utils import safe_json_dumps
from data.lookup_credentials import extract_credentials


class APIAlertsHandler(tornado.web.RequestHandler):
    """API request handler for /api/v2/alerts"""

    def __init__(self, application: "Application", request: httputil.HTTPServerRequest, **kwargs: Any):
        self._alerts = None
        self._web_server_metrics = None
        super().__init__(application, request, **kwargs)

    def initialize(self, alerts, web_server_metrics):
        self._alerts = alerts
        self._web_server_metrics = web_server_metrics

    @staticmethod
    def _enrich(alerts, credentials):
        enriched = []
        for alert in alerts:
            alert_copy = copy.deepcopy(alert)
            alert_copy.infer_missing(credentials)
            enriched.append(alert_copy)
        return enriched

    def get(self):
        try:
            # Metrics
            self._web_server_metrics["last_api_access_time"] = datetime.now(pytz.UTC)
            self._web_server_metrics["api_access_counter"] += 1
            self._web_server_metrics["status"] = "OK"
            api_requests_counter.inc()

            # request.arguments contains lists for each param key because technically the client can supply multiple,
            # reduce that to just the first entry, and convert bytes to string
            query_params = {k: v[0].decode("utf-8") for k, v in self.request.arguments.items()}

            # Fetch all alerts matching the query, then optionally enrich with online data
            credentials = extract_credentials(self.request.headers)
            data = get_alert_list_with_filters(self._alerts, query_params)
            if credentials:
                data = self._enrich(data, credentials)
            find_bad_values(data)
            self.write(safe_json_dumps(data))
            self.set_status(200)
        except ValueError as e:
            self.write(safe_json_dumps("Bad request - " + str(e)))
            self.set_status(400)
        except Exception as e:
            logging.error("Exception when handling client request to alerts API: %s", e, exc_info=True)
            self.write(safe_json_dumps("Error - an internal server error occurred."))
            self.set_status(500)
        self.set_header("Cache-Control", "no-store")
        self.set_header("Content-Type", "application/json")

def find_bad_values(obj, path="data"):
    if isinstance(obj, dict):
        for k, v in obj.items():
            find_bad_values(v, f"{path}[{k!r}]")
    elif isinstance(obj, (list, tuple)):
        for i, v in enumerate(obj):
            find_bad_values(v, f"{path}[{i}]")
    elif inspect.isbuiltin(obj) or inspect.ismethod(obj) or inspect.isfunction(obj):
        print(f"Found bad value at {path}: {obj!r}")

class APIAlertsStreamHandler(tornado_eventsource.handler.EventSourceHandler):
    """API request handler for /api/v2/alerts/stream"""

    def __init__(self, application, request, **kwargs: Any):
        self._sse_alert_broadcaster = None
        self._web_server_metrics = None
        self._query_params = None
        self._credentials = None
        super().__init__(application, request, **kwargs)

    def initialize(self, _sse_alert_broadcaster, web_server_metrics):
        self._sse_alert_broadcaster = _sse_alert_broadcaster
        self._web_server_metrics = web_server_metrics

    def custom_headers(self):
        """Custom headers to avoid e.g. nginx reverse proxy from buffering SSE data"""

        return {"Cache-Control": "no-store",
                "X-Accel-Buffering": "no"}

    def open(self):
        try:
            # Metrics
            self._web_server_metrics["last_api_access_time"] = datetime.now(pytz.UTC)
            self._web_server_metrics["api_access_counter"] += 1
            self._web_server_metrics["status"] = "OK"
            api_requests_counter.inc()

            # request.arguments contains lists for each param key because technically the client can supply multiple,
            # reduce that to just the first entry, and convert bytes to string
            self._query_params = {k: v[0].decode("utf-8") for k, v in self.request.arguments.items()}
            self._credentials = extract_credentials(self.request.headers)

            # Flush headers immediately so nginx doesn't time out waiting for a response
            self.write_message("keepalive", "")

            # Register to handle new alerts arriving. The callback() method will get called with the new alert as an
            # argument.
            self._sse_alert_broadcaster.register(self)

        except Exception as e:
            logging.warning("Exception when serving SSE socket: %s", e, exc_info=True)
            self.close()

    def close(self):
        """When the user closes the socket, deregister ourselves from the alert broadcaster"""

        self._sse_alert_broadcaster.unregister(self)
        super().close()

    def callback(self, alert):
        """Callback when a new alert arrives"""

        try:
            if alert_allowed_by_query(alert, self._query_params):
                if self._credentials:
                    alert = copy.deepcopy(alert)
                    alert.infer_missing(self._credentials)
                self.write_message(msg=safe_json_dumps(alert))
        except Exception as e:
            logging.warning("Exception in SSE callback, connection will be closed: %s", e, exc_info=True)
            self.close()


def get_alert_list_with_filters(all_alerts, query):
    """Utility method to apply filters to the overall alert list and return only a subset. Enables query parameters in
    the main "alerts" GET call."""

    # Create a shallow copy of the alert list ordered by start time, then filter the list to reduce it only to alerts
    # that match the filter parameters in the query string. Finally, apply a limit to the number of alerts returned.
    # The list of query string filters is defined in the API docs.
    alert_ids = all_alerts.keys()
    alerts = []
    for k in alert_ids:
        a = all_alerts.get(k)
        if a is not None:
            alerts.append(a)
    alerts = sorted(alerts, key=lambda alert: (alert.start_time if alert and alert.start_time else 0))
    alerts = list(filter(lambda alert: alert_allowed_by_query(alert, query), alerts))
    if "limit" in query.keys():
        alerts = alerts[:int(query.get("limit"))]
    return alerts


def alert_allowed_by_query(alert, query):
    """Given URL query params and an alert, figure out if the alert "passes" the requested filters or is rejected. The list
    of query parameters and their function is defined in the API docs."""

    for k in query.keys():
        match k:
            case "received_since":
                since = datetime.fromtimestamp(float(query.get(k)), pytz.UTC)
                if not alert.received_time or alert.received_time <= since:
                    return False
            case "max_duration":
                max_duration = int(query.get(k))
                # Check the duration if end_time is provided. If end_time is not provided, assume the activation is
                # "short", i.e. it always passes this check. If dxpeditions_skip_max_duration_check is true and
                # the alert is a dxpedition, it also always passes the check.
                if alert.is_dxpedition and (query.get(
                        "dxpeditions_skip_max_duration_check").upper() == "TRUE" if "dxpeditions_skip_max_duration_check" in query.keys() else False):
                    continue
                if alert.end_time and alert.start_time and alert.end_time - alert.start_time > max_duration:
                    return False
            case "source":
                sources = query.get(k).split(",")
                if not alert.source or alert.source not in sources:
                    return False
            case "sig":
                # If a list of sigs is provided, the alert must have a sig and it must match one of them.
                # The special "sig" "NO_SIG", when supplied in the list, mathches alerts with no sig.
                sigs = query.get(k).split(",")
                include_no_sig = "NO_SIG" in sigs
                if not alert.sig and not include_no_sig:
                    return False
                if alert.sig and alert.sig not in sigs:
                    return False
            case "dx_continent":
                dxconts = query.get(k).split(",")
                if not alert.dx_continent or alert.dx_continent not in dxconts:
                    return False
            case "dx_call_includes":
                dx_call_includes = query.get(k).strip()
                if not alert.dx_call or dx_call_includes.upper() not in alert.dx_call.upper():
                    return False
            case "text_includes":
                text_includes = query.get(k).strip()
                if (not alert.dx_call or text_includes.upper() not in alert.dx_call.upper()) \
                        and (not alert.comment or text_includes.upper() not in alert.comment.upper()) \
                        and (not alert.freqs_modes or text_includes.upper() not in alert.freqs_modes.upper()):
                    return False
    return True
