#!/usr/bin/env python3
"""Private live upper-air GFS map with local ADS-B observation overlay."""

import argparse
from datetime import datetime, timezone
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import math
from pathlib import Path
import re
import secrets
import threading
import time
import urllib.error
import urllib.parse
import urllib.request

from live_weather import weather_candidate
from aircraft_wind_solver import AircraftWindSolver, MAX_ALT_FT, MIN_ALT_FT, NumericalError


SOUTH, NORTH, WEST, EAST = 48.5, 53.9, 3.0, 10.8
GRID = 7
REFRESH_SECONDS = 3600
RETRY_SECONDS = 600
MAX_MODEL_AGE = 3 * 3600
MODEL_URL = "https://api.open-meteo.com/v1/gfs"
LEVELS = ("10m", "1000hPa", "850hPa", "700hPa", "500hPa", "250hPa", "70hPa", "10hPa")


def points():
    return [(SOUTH + (NORTH-SOUTH)*j/(GRID-1), WEST + (EAST-WEST)*i/(GRID-1))
            for j in range(GRID) for i in range(GRID)]


def request_model():
    coords = points()
    query = urllib.parse.urlencode({
        "latitude": ",".join(str(lat) for lat, _ in coords),
        "longitude": ",".join(str(lon) for _, lon in coords),
        "hourly": ",".join(f"wind_{variable}_{level}"
                           for level in LEVELS for variable in ("speed", "direction")),
        "wind_speed_unit": "ms", "forecast_days": 2, "timezone": "GMT",
    })
    request = urllib.request.Request(MODEL_URL + "?" + query,
                                     headers={"User-Agent": "Luftlabor/1.0"})
    with urllib.request.urlopen(request, timeout=30) as response:
        return json.load(response)


def parse_model(data, fetched_at):
    if not isinstance(data, list) or len(data) != GRID * GRID:
        raise ValueError("GFS response has an unexpected number of locations")
    levels = {level: {} for level in LEVELS}
    for location, (lat, lon) in zip(data, points()):
        units = location["hourly_units"]
        if abs(location["latitude"] - lat) > .5 or abs(location["longitude"] - lon) > .5:
            raise ValueError("GFS response coordinates differ from requested grid")
        hourly = location["hourly"]
        times = hourly["time"]
        for level in LEVELS:
            speed_key, direction_key = f"wind_speed_{level}", f"wind_direction_{level}"
            if units[speed_key] != "m/s" or units[direction_key] != "°":
                raise ValueError(f"Unexpected GFS wind units for {level}")
            speeds, directions = hourly[speed_key], hourly[direction_key]
            if not len(times) or len(times) != len(speeds) or len(times) != len(directions):
                raise ValueError(f"Incomplete GFS time series for {level}")
            for timestamp, speed, direction in zip(times, speeds, directions):
                valid = datetime.fromisoformat(timestamp).replace(tzinfo=timezone.utc).timestamp()
                if not isinstance(speed, (int, float)) or not isinstance(direction, (int, float)):
                    raise ValueError(f"Missing GFS wind value for {level}")
                if not math.isfinite(speed) or not math.isfinite(direction) or not 0 <= speed <= 150:
                    raise ValueError(f"Invalid GFS wind value for {level}")
                angle = math.radians(direction)
                levels[level].setdefault(valid, []).append((-speed*math.sin(angle), -speed*math.cos(angle)))
    if any(len(values) != GRID*GRID for frames in levels.values() for values in frames.values()):
        raise ValueError("GFS locations do not have aligned hourly times")
    return {"fetched_at": fetched_at, "levels": levels}


def model_at(model, now, level="250hPa"):
    if level not in LEVELS:
        raise ValueError("Unknown wind level")
    if now - model["fetched_at"] > MAX_MODEL_AGE or now < model["fetched_at"] - 2:
        raise ValueError("Model data are older than three hours")
    frames = model["levels"][level]
    times = sorted(frames)
    for left, right in zip(times, times[1:]):
        if left <= now <= right and right-left == 3600:
            fraction = (now-left)/(right-left)
            vectors = [[round(a*(1-fraction)+b*fraction, 3) for a, b in zip(x, y)]
                       for x, y in zip(frames[left], frames[right])]
            return {"nx": GRID, "ny": GRID, "bounds": [WEST, SOUTH, EAST, NORTH],
                    "vectors": vectors, "valid_from": left, "valid_to": right,
                    "fetched_at": model["fetched_at"], "level": level}
    raise ValueError("No current hourly GFS model interval")


def observations(snapshot, now):
    timestamp = snapshot.get("now")
    if not isinstance(timestamp, (int, float)) or not math.isfinite(timestamp):
        raise ValueError("Invalid ADS-B snapshot timestamp")
    age = now - timestamp
    if age > 5 or age < -2:
        raise ValueError("ADS-B snapshot is stale")
    result = []
    for aircraft in snapshot["aircraft"]:
        altitude = aircraft.get("alt_baro")
        if not isinstance(altitude, (int, float)) or not MIN_ALT_FT <= altitude <= MAX_ALT_FT:
            continue
        lat, lon = aircraft.get("lat"), aircraft.get("lon")
        if not isinstance(lat, (int, float)) or not isinstance(lon, (int, float)):
            continue
        if not math.isfinite(lat) or not math.isfinite(lon) or not (SOUTH <= lat <= NORTH and WEST <= lon <= EAST):
            continue
        if aircraft.get("seen", math.inf) + max(age, 0) > 10 or aircraft.get("seen_pos", math.inf) + max(age, 0) > 10:
            continue
        if not isinstance(aircraft.get("weather_provenance"), dict):
            continue
        candidate = weather_candidate({**aircraft, "_snapshot_utc": timestamp})
        if candidate["wind"] is None:
            continue
        direction, speed = candidate["wind"]
        if direction is None:
            east = north = 0.0
        else:
            east, north = -speed*math.sin(math.radians(direction)), -speed*math.cos(math.radians(direction))
        result.append({"lat": lat, "lon": lon, "alt_ft": altitude,
                       "flight": str(aircraft.get("flight", "")).strip(),
                       "icao": str(aircraft.get("hex", "")), "east": round(east, 2),
                       "north": round(north, 2), "speed": round(speed, 2)})
    return {"snapshot_time": timestamp, "aircraft": result}


def borders(path):
    data = json.loads(path.read_text())
    paths = []
    for feature in data["features"]:
        geometry = feature["geometry"]
        polygons = geometry["coordinates"] if geometry["type"] == "MultiPolygon" else [geometry["coordinates"]]
        for polygon in polygons:
            for ring in polygon:
                if any(WEST-1 <= lon <= EAST+1 and SOUTH-1 <= lat <= NORTH+1 for lon, lat, *_ in ring):
                    paths.append([[lon, lat] for lon, lat, *_ in ring])
    return paths


class ModelCache:
    def __init__(self):
        self.lock = threading.Lock()
        self.model = None
        self.error = "GFS-Daten werden geladen"

    def refresh(self):
        try:
            model = parse_model(request_model(), time.time())
            for level in LEVELS:
                model_at(model, time.time(), level)
            with self.lock:
                self.model, self.error = model, None
            print("GFS wind grid refreshed", flush=True)
            return REFRESH_SECONDS
        except (OSError, ValueError, KeyError, TypeError) as error:
            with self.lock:
                self.error = f"GFS-Aktualisierung fehlgeschlagen: {error}"
            print(self.error, flush=True)
            return RETRY_SECONDS

    def run(self):
        while True:
            time.sleep(self.refresh())

    def current(self, level="250hPa"):
        with self.lock:
            model, error = self.model, self.error
        if model is None:
            raise ValueError(error)
        result = model_at(model, time.time(), level)
        result["warning"] = error
        return result


class AircraftModelCache:
    def __init__(self, snapshot):
        self.snapshot = snapshot
        self.solver = AircraftWindSolver()
        self.lock = threading.Lock()
        self.result = None
        self.error = "Flugzeugmodell wird gestartet"

    def refresh(self):
        now = time.time()
        warning = None
        try:
            data = observations(json.loads(self.snapshot.read_text()), now)
            rows = [row for row in data["aircraft"] if row["icao"]]
            observed_at = data["snapshot_time"]
        except (OSError, ValueError, KeyError, TypeError) as error:
            rows = []
            observed_at = now
            warning = f"ADS-B-Quelle vorübergehend nicht verfügbar: {error}"
            print(warning, flush=True)
        try:
            self.solver.update(rows, now, observed_at)
            result = self.solver.grid(now)
            result["warning"] = "; ".join(part for part in (result["warning"], warning) if part) or None
            with self.lock:
                self.result, self.error = result, None
        except NumericalError as error:
            message = str(error)
            print(f"Flugzeugmodell: {message}; Solver wird neu gestartet", flush=True)
            self.solver = AircraftWindSolver()
            with self.lock:
                self.result, self.error = None, message
        except (ValueError, KeyError, TypeError) as error:
            message = str(error)
            if not (message.startswith("Warte auf") or message == "Flugzeugdaten sind veraltet"):
                print(f"Flugzeugmodell: {message}", flush=True)
            elif warning:
                message = f"{message}; {warning}"
            with self.lock:
                self.result, self.error = None, message

    def run(self):
        while True:
            self.refresh()
            time.sleep(5)

    def current(self):
        with self.lock:
            result, error = self.result, self.error
        if result is None:
            raise ValueError(error)
        if not -2 <= time.time()-result["updated_at"] <= 15:
            raise ValueError("Flugzeugmodell wird nicht aktuell berechnet")
        return result


class Server(ThreadingHTTPServer):
    daemon_threads = True

    def __init__(self, address, snapshot, border_file, token=None):
        if token is not None and not re.fullmatch(r"[A-Za-z0-9_-]{24,64}", token):
            raise ValueError("Invalid URL token")
        self.prefix = "/" + (token or secrets.token_urlsafe(24)) + "/"
        self.snapshot = snapshot
        self.html = Path(__file__).with_name("wind_map.html").read_bytes()
        self.geography = json.dumps(borders(border_file), separators=(",", ":"), allow_nan=False).encode()
        self.cache = ModelCache()
        self.aircraft_model = AircraftModelCache(snapshot)
        super().__init__(address, Handler)


class Handler(BaseHTTPRequestHandler):
    def log_message(self, format_string, *args):
        if len(args) > 1 and str(args[1]) != "200":
            print(f"Wind map HTTP status: {args[1]}", flush=True)

    def do_GET(self):
        parsed = urllib.parse.urlsplit(self.path)
        name = parsed.path
        if not name.startswith(self.server.prefix):
            self.send_error(404)
            return
        route = name[len(self.server.prefix):]
        status = 200
        try:
            if route == "":
                content, kind = self.server.html, "text/html; charset=utf-8"
            elif route == "borders":
                content, kind = self.server.geography, "application/json"
            elif route == "model":
                query = urllib.parse.parse_qs(parsed.query)
                level = query.get("level", ["250hPa"])
                if len(level) != 1 or level[0] not in LEVELS:
                    self.send_error(400, "Invalid wind level")
                    return
                content = json.dumps(self.server.cache.current(level[0]), allow_nan=False).encode()
                kind = "application/json"
            elif route == "aircraft":
                snapshot = json.loads(self.server.snapshot.read_text())
                content = json.dumps(observations(snapshot, time.time()), allow_nan=False).encode()
                kind = "application/json"
            elif route == "aircraft-model":
                content = json.dumps(self.server.aircraft_model.current(), allow_nan=False).encode()
                kind = "application/json"
            else:
                self.send_error(404)
                return
        except (OSError, ValueError, KeyError, TypeError) as error:
            print(f"Wind map {route}: {error}", flush=True)
            if route != "aircraft-model":
                self.send_error(503, "Data temporarily unavailable")
                return
            status = 503
            content = json.dumps({"error": str(error)}).encode()
            kind = "application/json"
        self.send_response(status)
        self.send_header("Content-Type", kind)
        self.send_header("Content-Length", str(len(content)))
        self.send_header("Cache-Control", "no-store")
        self.send_header("X-Content-Type-Options", "nosniff")
        self.send_header("Referrer-Policy", "no-referrer")
        self.send_header("Content-Security-Policy", "default-src 'self'; script-src 'unsafe-inline'; "
                         "style-src 'unsafe-inline'; connect-src 'self'; img-src 'self' data:; "
                         "frame-ancestors 'none'; base-uri 'none'")
        self.end_headers()
        self.wfile.write(content)


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--snapshot", type=Path, required=True)
    parser.add_argument("--borders", type=Path, required=True)
    parser.add_argument("--host", default="127.0.0.1")
    parser.add_argument("--port", type=int, default=8088)
    parser.add_argument("--token")
    args = parser.parse_args()
    with Server((args.host, args.port), args.snapshot, args.borders, args.token) as server:
        threading.Thread(target=server.cache.run, daemon=True).start()
        threading.Thread(target=server.aircraft_model.run, daemon=True).start()
        print(f"Live wind map: http://{args.host}:{args.port}{server.prefix}", flush=True)
        try:
            server.serve_forever()
        except KeyboardInterrupt:
            pass


if __name__ == "__main__":
    main()
