"""ACARS message translator — label lookup, classification, and field parsers."""

from __future__ import annotations

import re

# Common ACARS label codes → human-readable descriptions
# Sources: ARINC 618, ARINC 620, airline implementations
ACARS_LABELS: dict[str, str] = {
    # Position & navigation
    'H1': 'Position report (HF data link)',
    'H2': 'Weather report',
    '5Z': 'OOOI (gate times)',
    '15': 'Departure report',
    '16': 'Arrival report',
    '20': 'Position report',
    '22': 'Fuel report',
    '2Z': 'Off-gate report',
    '30': 'Progress report',
    '44': 'Weather request',
    '80': 'Free text (3-char header)',
    '83': 'Free text',
    '8E': 'ATIS request',

    # Engine & performance
    'DF': 'Engine data / DFDR',
    'D3': 'Engine exceedance',
    'D6': 'Engine trend data',

    # ATS / air traffic services
    'B1': 'ATC request',
    'B2': 'ATC clearance',
    'B3': 'ATC comm test',
    'B6': 'ATC departure clearance',
    'B9': 'ATC message',
    'BA': 'ATC advisory',
    'BB': 'ATC response',

    # CPDLC (Controller-Pilot Data Link Communications)
    'AA': 'CPDLC message',
    'AB': 'CPDLC response',
    'A0': 'CPDLC uplink',
    'A1': 'CPDLC downlink',
    'A2': 'CPDLC connection request',
    'A3': 'CPDLC logon/logoff',
    'A6': 'CPDLC message',
    'A7': 'CPDLC response',
    'AT': 'CPDLC transfer',

    # Handshake & link management
    '_d': 'Demand mode (link test)',
    'Q0': 'Link test',
    'QA': 'Link test reply',
    'QB': 'Acknowledgement',
    'QC': 'Link request',
    'QD': 'Link accept',
    'QE': 'Link reject',
    'QF': 'Squitter / heartbeat',
    'QG': 'Abort',
    'QH': 'Version request',
    'QK': 'Mode change',
    'QM': 'Link verification',
    'QN': 'Media advisory',
    'QP': 'Polling',
    'QQ': 'Status',
    'QR': 'General response',
    'QS': 'System table request',
    'QT': 'System table',
    'QX': 'Frequency change',

    # Squawk & surveillance
    'SQ': 'Squawk assignment',
    'SA': 'Surveillance data',
    'S1': 'ADS-C report',

    # Airline operations
    'C1': 'Crew scheduling',
    'C2': 'Crew response',
    'C3': 'Crew message',
    'C4': 'Crew query',
    '10': 'Delay message',
    '12': 'Clearance request',
    '17': 'Cargo/load data',
    '4T': 'TWIP (terminal weather)',
    '4X': 'Connectivity test',
    '50': 'Weather observation',
    '51': 'METAR/TAF request',
    '52': 'METAR/TAF response',
    '54': 'SIGMET / AIRMET',
    '70': 'Maintenance report',
    '7A': 'Fault message',
    '7B': 'Fault clear',
    'F3': 'Flight plan',
    'F5': 'Flight plan amendment',
    'F6': 'Route request',
    'F7': 'Route clearance',
    'RA': 'ATIS report',
    'RB': 'ATIS request',
}

# Message type classification for UI colour coding
MESSAGE_TYPES = {
    'position', 'engine_data', 'weather', 'ats', 'handshake',
    'oooi', 'squawk', 'link_test', 'cpdlc', 'other',
}


def translate_label(label: str | None) -> str:
    """Return human-readable description for an ACARS label code."""
    if not label:
        return 'Unknown label'
    label = label.strip()
    if label in ACARS_LABELS:
        return ACARS_LABELS[label]
    # Check for Q-prefix group
    if len(label) == 2 and label.startswith('Q'):
        return f'Link management ({label})'
    return f'Label {label}'


def classify_message_type(label: str | None, text: str | None = None) -> str:
    """Classify an ACARS message into a canonical type for UI display."""
    if not label:
        return 'other'
    label = label.strip()

    # Position reports
    if label in ('H1', '20', '15', '16', '30', 'S1'):
        return 'position'
    if text and '#M1BPOS' in text:
        return 'position'

    # Engine / DFDR data
    if label in ('DF', 'D3', 'D6'):
        return 'engine_data'

    # Weather
    if label in ('H2', '44', '50', '51', '52', '54', '4T'):
        return 'weather'

    # ATS / ATC
    if label.startswith('B') and len(label) == 2:
        return 'ats'

    # CPDLC
    if label in ('AA', 'AB', 'A0', 'A1', 'A2', 'A3', 'A6', 'A7', 'AT'):
        return 'cpdlc'

    # OOOI (Out/Off/On/In gate times)
    if label in ('5Z', '2Z'):
        return 'oooi'

    # Squawk
    if label in ('SQ', 'SA'):
        return 'squawk'

    # Link test / handshake
    if label in ('Q0', 'QA', 'QB', 'QC', 'QD', 'QE', 'QF', 'QG',
                 'QH', 'QK', 'QM', 'QN', 'QP', 'QQ', 'QR', 'QS', 'QT', 'QX',
                 '4X'):
        return 'link_test'

    # Handshake (_d is demand mode)
    if label == '_d':
        return 'handshake'

    return 'other'


def parse_position_report(text: str | None) -> dict | None:
    """Parse H1 / #M1BPOS position report fields.

    Example format:
        #M1BPOSN42411W086034,CSG,070852,340,N42441W087074,DTW,0757,224A8C
        Lat/Lon: N42411W086034 (N42.411 W086.034)
        Waypoint: CSG
        Time: 070852Z
        FL: 340
        Next waypoint coords, destination, ETA
    """
    if not text:
        return None

    result: dict = {}

    # Look for BPOS block
    bpos_match = re.search(
        r'#M\d[A-Z]*POS'
        r'([NS])(\d{2,5})([EW])(\d{3,6})'
        r',([^,]*),(\d{4,6})'
        r',(\d{2,3})'
        r'(?:,([NS]\d{2,5}[EW]\d{3,6}))?'
        r'(?:,([A-Z]{3,4}))?',
        text
    )
    if bpos_match:
        lat_dir, lat_val, lon_dir, lon_val = bpos_match.group(1, 2, 3, 4)
        # Convert to decimal degrees
        if len(lat_val) >= 4:
            lat_deg = int(lat_val[:2])
            lat_min = int(lat_val[2:]) / (10 ** (len(lat_val) - 2)) * 60
            lat = lat_deg + lat_min / 60
        else:
            lat = float(lat_val)
        if lat_dir == 'S':
            lat = -lat

        if len(lon_val) >= 5:
            lon_deg = int(lon_val[:3])
            lon_min = int(lon_val[3:]) / (10 ** (len(lon_val) - 3)) * 60
            lon = lon_deg + lon_min / 60
        else:
            lon = float(lon_val)
        if lon_dir == 'W':
            lon = -lon

        result['lat'] = round(lat, 4)
        result['lon'] = round(lon, 4)
        result['waypoint'] = bpos_match.group(5).strip() if bpos_match.group(5) else None
        result['time'] = bpos_match.group(6)
        result['flight_level'] = f"FL{bpos_match.group(7)}"
        if bpos_match.group(9):
            result['destination'] = bpos_match.group(9)

    # Look for temperature (e.g., /TS-045 or M045)
    temp_match = re.search(r'/TS([MP]?)(\d{2,3})', text)
    if temp_match:
        sign = '-' if temp_match.group(1) == 'M' else ''
        result['temperature'] = f"{sign}{temp_match.group(2)} C"

    return result if result else None


def parse_engine_data(text: str | None) -> dict | None:
    """Parse DF (engine/DFDR) messages.

    Common format: #DFB followed by KEY/VALUE pairs.
    Keys: SM (source mode), AC0/AC1 (engine 1/2 N2), FL (flight level),
          FU (fuel used), ES (EGT spread), BA (bleed air), CO (config), AO (auto)
    """
    if not text:
        return None

    result: dict = {}
    engine_keys = {
        'SM': 'Source mode',
        'AC0': 'Eng 1 N2 (%)',
        'AC1': 'Eng 2 N2 (%)',
        'FL': 'Flight level',
        'FU': 'Fuel used (lbs)',
        'ES': 'EGT spread',
        'BA': 'Bleed air',
        'CO': 'Config',
        'AO': 'Auto',
        'EGT': 'Exhaust gas temp',
        'OIT': 'Oil temp',
        'OIP': 'Oil pressure',
        'N1': 'N1 (%)',
        'N2': 'N2 (%)',
        'FF': 'Fuel flow',
        'VIB': 'Vibration',
    }

    # Match KEY/VALUE or KEY VALUE patterns
    for key, desc in engine_keys.items():
        pattern = rf'\b{re.escape(key)}[/: ]?\s*([+-]?\d+\.?\d*)'
        m = re.search(pattern, text)
        if m:
            result[key] = {'value': m.group(1), 'description': desc}

    return result if result else None


def parse_weather_data(text: str | None) -> dict | None:
    """Parse weather report fields (/WX blocks, METAR-like data)."""
    if not text:
        return None

    result: dict = {}

    # Wind: direction/speed (e.g., 270/15 or WND270015)
    wind_match = re.search(r'(?:WND|WIND)\s*(\d{3})[/ ]?(\d{2,3})', text)
    if wind_match:
        result['wind_dir'] = f"{wind_match.group(1)} deg"
        result['wind_speed'] = f"{wind_match.group(2)} kts"

    # Airport codes (3-4 letter ICAO)
    airports = re.findall(r'\b([A-Z]{3,4})\b', text)
    if airports:
        result['airports'] = list(dict.fromkeys(airports))[:4]

    # Temperature (e.g., T24/D18, TMP24, TEMP -5)
    temp_match = re.search(r'(?:TMP|TEMP|T)\s*([MP+-]?\d{1,3})', text)
    if temp_match:
        val = temp_match.group(1).replace('M', '-').replace('P', '')
        result['temperature'] = f"{val} C"

    # Visibility
    vis_match = re.search(r'VIS\s*(\d+(?:\.\d+)?)', text)
    if vis_match:
        result['visibility'] = f"{vis_match.group(1)} SM"

    return result if result else None


def parse_oooi(text: str | None) -> dict | None:
    """Parse 5Z OOOI (Out/Off/On/In) gate time messages.

    Typical format: origin destination OUT OFF ON IN
    e.g., KJFK KLAX 1423 1435 1812 1824
    """
    if not text:
        return None

    result: dict = {}

    # Try to find airport pair + 4 time blocks
    oooi_match = re.search(
        r'([A-Z]{3,4})\s+([A-Z]{3,4})\s+(\d{4})\s+(\d{4})\s+(\d{4})\s+(\d{4})',
        text
    )
    if oooi_match:
        result['origin'] = oooi_match.group(1)
        result['destination'] = oooi_match.group(2)
        result['out'] = oooi_match.group(3)
        result['off'] = oooi_match.group(4)
        result['on'] = oooi_match.group(5)
        result['in'] = oooi_match.group(6)
        return result

    # Try partial (just origin/destination and some times)
    partial = re.search(r'([A-Z]{3,4})\s+([A-Z]{3,4})', text)
    if partial:
        result['origin'] = partial.group(1)
        result['destination'] = partial.group(2)

    times = re.findall(r'\b(\d{4})\b', text)
    labels = ['out', 'off', 'on', 'in']
    for i, t in enumerate(times[:4]):
        result[labels[i]] = t

    return result if result else None


def translate_message(msg: dict) -> dict:
    """Translate an ACARS message dict, returning enrichment fields.

    Args:
        msg: Raw ACARS message dict with 'label', 'text'/'msg' fields.

    Returns:
        Dict with 'label_description', 'message_type', 'parsed'.
    """
    label = msg.get('label')
    text = msg.get('text') or msg.get('msg') or ''

    label_description = translate_label(label)
    message_type = classify_message_type(label, text)

    parsed: dict | None = None
    if message_type == 'position' or (label == 'H1' and 'POS' in text.upper()):
        parsed = parse_position_report(text)
    elif message_type == 'engine_data':
        parsed = parse_engine_data(text)
    elif message_type == 'weather':
        parsed = parse_weather_data(text)
    elif message_type == 'oooi':
        parsed = parse_oooi(text)

    return {
        'label_description': label_description,
        'message_type': message_type,
        'parsed': parsed,
    }