"""
DSC message parser.

Parses DSC decoder JSON output and provides utility functions for
MMSI country resolution, distress nature text, etc.
"""

from __future__ import annotations

import json
import logging
import re
from datetime import datetime
from typing import Any

from .constants import (
    CATEGORY_PRIORITY,
    DISTRESS_NATURE_CODES,
    FORMAT_CODES,
    MID_COUNTRY_MAP,
    TELECOMMAND_CODES,
    VALID_EOS,
    VALID_FORMAT_SPECIFIERS,
)

logger = logging.getLogger("intercept.dsc.parser")


def get_country_from_mmsi(mmsi: str) -> str | None:
    """
    Derive country from MMSI using Maritime Identification Digits (MID).

    The first 3 digits of a 9-digit MMSI identify the country.

    Args:
        mmsi: The MMSI number as string

    Returns:
        Country name if found, None otherwise
    """
    if not mmsi or len(mmsi) < 3:
        return None

    # Normal ship MMSI: starts with MID (3 digits)
    mid = mmsi[:3]
    if mid in MID_COUNTRY_MAP:
        return MID_COUNTRY_MAP[mid]

    # Coast station MMSI: starts with 00 + MID
    if mmsi.startswith("00") and len(mmsi) >= 5:
        mid = mmsi[2:5]
        if mid in MID_COUNTRY_MAP:
            return MID_COUNTRY_MAP[mid]

    # Group ship station MMSI: starts with 0 + MID
    if mmsi.startswith("0") and len(mmsi) >= 4:
        mid = mmsi[1:4]
        if mid in MID_COUNTRY_MAP:
            return MID_COUNTRY_MAP[mid]

    return None


def get_distress_nature_text(code: int | str) -> str:
    """Get human-readable text for distress nature code."""
    if isinstance(code, str):
        try:
            code = int(code)
        except ValueError:
            return str(code)

    return DISTRESS_NATURE_CODES.get(code, f"UNKNOWN ({code})")


def get_format_text(code: int | str) -> str:
    """Get human-readable text for format code."""
    if isinstance(code, str):
        try:
            code = int(code)
        except ValueError:
            return str(code)

    return FORMAT_CODES.get(code, f"UNKNOWN ({code})")


def get_telecommand_text(code: int | str) -> str:
    """Get human-readable text for telecommand code."""
    if isinstance(code, str):
        try:
            code = int(code)
        except ValueError:
            return str(code)

    return TELECOMMAND_CODES.get(code, f"UNKNOWN ({code})")


def get_category_priority(category: str) -> int:
    """Get priority level for a category (lower = higher priority)."""
    return CATEGORY_PRIORITY.get(category.upper(), 10)


def parse_dsc_message(raw_line: str) -> dict[str, Any] | None:
    """
    Parse DSC decoder JSON output line.

    The decoder outputs JSON lines with fields like:
    {
        "type": "dsc",
        "format": 100,
        "source_mmsi": "123456789",
        "dest_mmsi": "000000000",
        "category": "DISTRESS",
        "nature": 101,
        "position": {"lat": 51.5, "lon": -0.1},
        "telecommand1": 100,
        "telecommand2": null,
        "channel": 16,
        "timestamp": "2025-01-15T12:00:00Z",
        "raw": "..."
    }

    Args:
        raw_line: Raw JSON line from decoder

    Returns:
        Parsed message dict or None if parsing fails
    """
    if not raw_line or not raw_line.strip():
        return None

    try:
        data = json.loads(raw_line.strip())
    except json.JSONDecodeError as e:
        logger.debug(f"Failed to parse DSC JSON: {e}")
        return None

    # Validate required fields
    if data.get("type") != "dsc":
        return None

    if "source_mmsi" not in data:
        return None

    # ITU-R M.493 validation: format specifier must be valid
    format_code = data.get("format")
    if format_code not in VALID_FORMAT_SPECIFIERS:
        logger.debug(f"Rejected DSC: invalid format specifier {format_code}")
        return None

    # Validate MMSIs
    source_mmsi = str(data.get("source_mmsi", ""))
    if not validate_mmsi(source_mmsi):
        logger.debug(f"Rejected DSC: invalid source MMSI {source_mmsi}")
        return None

    dest_mmsi_val = data.get("dest_mmsi")
    if dest_mmsi_val is not None:
        dest_mmsi_str = str(dest_mmsi_val)
        if not validate_mmsi(dest_mmsi_str):
            logger.debug(f"Rejected DSC: invalid dest MMSI {dest_mmsi_str}")
            return None

    # Validate raw field structure if present
    raw = data.get("raw")
    if raw is not None:
        raw_str = str(raw)
        if not re.match(r"^\d+$", raw_str):
            logger.debug("Rejected DSC: raw field contains non-digits")
            return None
        if len(raw_str) % 3 != 0:
            logger.debug("Rejected DSC: raw field length not divisible by 3")
            return None
        # Last 3-digit token must be a valid EOS symbol
        if len(raw_str) >= 3:
            last_token = int(raw_str[-3:])
            if last_token not in VALID_EOS:
                logger.debug(f"Rejected DSC: raw EOS token {last_token} not valid")
                return None

    # Validate telecommand values if present (must be 100-127)
    for tc_field in ("telecommand1", "telecommand2"):
        tc_val = data.get(tc_field)
        if tc_val is not None:
            try:
                tc_int = int(tc_val)
            except (ValueError, TypeError):
                logger.debug(f"Rejected DSC: invalid {tc_field} value {tc_val}")
                return None
            if tc_int < 100 or tc_int > 127:
                logger.debug(f"Rejected DSC: {tc_field} {tc_int} out of range 100-127")
                return None

    # Build parsed message
    msg = {
        "type": "dsc_message",
        "source_mmsi": source_mmsi,
        "dest_mmsi": str(data.get("dest_mmsi", "")) if data.get("dest_mmsi") is not None else None,
        "format_code": format_code,
        "format_text": get_format_text(format_code),
        "category": data.get("category", "UNKNOWN").upper(),
        "timestamp": data.get("timestamp") or datetime.utcnow().isoformat(),
    }

    # Add country from MMSI
    country = get_country_from_mmsi(msg["source_mmsi"])
    if country:
        msg["source_country"] = country

    # Add distress nature if present
    if data.get("nature") is not None:
        msg["nature_code"] = data["nature"]
        msg["nature_of_distress"] = get_distress_nature_text(data["nature"])

    # Add position if present
    position = data.get("position")
    if position and isinstance(position, dict):
        lat = position.get("lat")
        lon = position.get("lon")
        if lat is not None and lon is not None:
            try:
                msg["latitude"] = float(lat)
                msg["longitude"] = float(lon)
            except (ValueError, TypeError):
                pass

    # Add telecommand info
    if data.get("telecommand1") is not None:
        msg["telecommand1"] = data["telecommand1"]
        msg["telecommand1_text"] = get_telecommand_text(data["telecommand1"])

    if data.get("telecommand2") is not None:
        msg["telecommand2"] = data["telecommand2"]
        msg["telecommand2_text"] = get_telecommand_text(data["telecommand2"])

    # Add channel if present
    if data.get("channel") is not None:
        msg["channel"] = data["channel"]

    # Add EOS (End of Sequence) info
    if "eos" in data:
        msg["eos"] = data["eos"]

    # Add raw message for debugging
    if "raw" in data:
        msg["raw_message"] = data["raw"]

    # Calculate priority
    msg["priority"] = get_category_priority(msg["category"])

    # Mark if this is a critical alert
    msg["is_critical"] = msg["category"] in (
        "DISTRESS",
        "DISTRESS_ACK",
        "DISTRESS_RELAY",
        "URGENCY",
        "SAFETY",
        "ALL_SHIPS_URGENCY_SAFETY",
    )

    return msg


def format_dsc_for_display(msg: dict) -> str:
    """
    Format a DSC message for human-readable display.

    Args:
        msg: Parsed DSC message dict

    Returns:
        Formatted string for display
    """
    lines = []

    # Header with category and MMSI
    category = msg.get("category", "UNKNOWN")
    mmsi = msg.get("source_mmsi", "UNKNOWN")
    country = msg.get("source_country", "")

    header = f"[{category}] MMSI: {mmsi}"
    if country:
        header += f" ({country})"
    lines.append(header)

    # Destination if present
    if msg.get("dest_mmsi"):
        lines.append(f"  To: {msg['dest_mmsi']}")

    # Distress nature
    if msg.get("nature_of_distress"):
        lines.append(f"  Nature: {msg['nature_of_distress']}")

    # Position
    if msg.get("latitude") is not None and msg.get("longitude") is not None:
        lat = msg["latitude"]
        lon = msg["longitude"]
        lat_dir = "N" if lat >= 0 else "S"
        lon_dir = "E" if lon >= 0 else "W"
        lines.append(f"  Position: {abs(lat):.4f}{lat_dir} {abs(lon):.4f}{lon_dir}")

    # Telecommand
    if msg.get("telecommand1_text"):
        lines.append(f"  Request: {msg['telecommand1_text']}")

    # Channel
    if msg.get("channel"):
        lines.append(f"  Channel: {msg['channel']}")

    # Timestamp
    if msg.get("timestamp"):
        lines.append(f"  Time: {msg['timestamp']}")

    return "\n".join(lines)


def validate_mmsi(mmsi: str) -> bool:
    """
    Validate MMSI format.

    MMSI is a 9-digit number. Ship stations start with non-zero digit.
    Coast stations start with 00. Group stations start with 0.

    Args:
        mmsi: MMSI string to validate

    Returns:
        True if valid MMSI format
    """
    if not mmsi:
        return False

    # Must be 9 digits
    if not re.match(r"^\d{9}$", mmsi):
        return False

    # All zeros is invalid
    return mmsi != "000000000"


def classify_mmsi(mmsi: str) -> str:
    """
    Classify MMSI type.

    Args:
        mmsi: MMSI string

    Returns:
        Classification: 'ship', 'coast', 'group', 'sar', 'aton', or 'unknown'
    """
    if not validate_mmsi(mmsi):
        return "unknown"

    first_digit = mmsi[0]
    first_two = mmsi[:2]
    first_three = mmsi[:3]

    # Coast station: starts with 00
    if first_two == "00":
        return "coast"

    # Group call: starts with 0
    if first_digit == "0":
        return "group"

    # SAR aircraft: starts with 111
    if first_three == "111":
        return "sar"

    # Aids to Navigation: starts with 99
    if first_two == "99":
        return "aton"

    # Ship station: starts with MID (2-7)
    if first_digit in "234567":
        return "ship"

    return "unknown"