import logging
import re
from datetime import datetime
from threading import Event, Thread

import pytz
import telnetlib3

from core.config import SERVER_OWNER_CALLSIGN
from data.spot import Spot
from providers.spot.spot_provider import SpotProvider

logger = logging.getLogger(__name__)


class RBN(SpotProvider):
    """Spot provider for the Reverse Beacon Network. Connects to a single port, if you want both CW/RTTY (port 7000) and FT8
    (port 7001) you need to instantiate two copies of this. The port is provided as an argument to the constructor."""

    _LINE_PATTERN = re.compile(
        r"^DX de ([a-z0-9/]+)-.*:\s+([0-9.]+)\s+([a-z0-9/]+)\s+(.*)\s+(\d{4}Z)",
        re.IGNORECASE,
    )

    def __init__(self, provider_config):
        """Constructor requires port number."""

        name = provider_config.get("name", "RBN")
        super().__init__(name, provider_config)
        self._port = provider_config["port"]
        self._telnet = None
        self._thread = None
        self._stop_event = Event()

    def start(self):
        self._thread = Thread(target=self._handle, name=f"RBNSpotProvider-{self.name}", daemon=True)
        self._thread.start()

    def stop(self):
        self._stop_event.set()
        if self._telnet:
            self._telnet.close()
        if self._thread:
            self._thread.join(timeout=15)
            if self._thread.is_alive():
                logger.warning(f"RBN (port {self._port!s}) worker thread did not exit on time and will be killed.")

    def _handle(self):
        while not self._stop_event.is_set():
            connected = False
            while not connected and not self._stop_event.is_set():
                try:
                    self.status = "Connecting"
                    logger.info(f"RBN port {self._port!s} connecting...")
                    self._telnet = telnetlib3.Telnet("telnet.reversebeacon.net", self._port)
                    self._telnet.read_until("Please enter your call: ".encode("latin-1"))
                    self._telnet.write(f"{SERVER_OWNER_CALLSIGN}\n".encode("latin-1"))
                    connected = True
                    logger.info(f"RBN port {self._port!s} connected.")
                except Exception:
                    self.status = "Error"
                    logger.exception(f"Exception while connecting to RBN (port {self._port!s}).")
                    self._stop_event.wait(timeout=5)

            self.status = "Waiting for Data"
            while connected and not self._stop_event.is_set():
                try:
                    # Check new telnet info against regular expression
                    telnet_output = self._telnet.read_until("\n".encode("latin-1"))
                    match = self._LINE_PATTERN.match(telnet_output.decode("latin-1"))
                    if match:
                        spot_time = datetime.strptime(match.group(5), "%H%MZ").replace(tzinfo=pytz.UTC)
                        spot_datetime = datetime.combine(
                            datetime.now(pytz.UTC).date(),
                            spot_time.time(),
                            tzinfo=pytz.UTC,
                        )
                        spot = Spot(
                            source=self.name,
                            dx_call=match.group(3),
                            de_call=match.group(1),
                            freq=float(match.group(2)) * 1000,
                            comment=match.group(4).strip(),
                            time=spot_datetime.timestamp(),
                        )

                        # Add to our list
                        self._submit(spot)

                        self.status = "OK"
                        self.last_update_time = datetime.now(pytz.UTC)
                        logger.debug(f"Data received from RBN on port {self._port!s}.")

                except EOFError:
                    connected = False
                    if not self._stop_event.is_set():
                        self.status = "Restarting"
                        logger.warning(f"Disconnected from RBN provider (port {self._port!s}). Reconnecting...")
                        self._stop_event.wait(timeout=5)
                    else:
                        logger.info(f"RBN provider (port {self._port!s}) shutting down...")
                        self.status = "Shutting down"
                except Exception:
                    connected = False
                    if not self._stop_event.is_set():
                        self.status = "Error"
                        logger.exception(f"Exception in RBN provider (port {self._port!s})")
                        self._stop_event.wait(timeout=5)
                    else:
                        logger.info(f"RBN provider (port {self._port!s}) shutting down...")
                        self.status = "Shutting down"

            self.status = "Disconnected"