"""LRPT pilt kaardile: iga rea ajatempel -> satelliidi asukoht (sgp4, TLE vahemälust) -> iga veeru skaneerimisnurk ->
maapunkt (kera) -> ekvidistantne (lat/lon) kaart koos kraadivõrgu, linnade ja (kui on) rannajoontega. Puhas numpy.

Kasutus: python lrpt_geo.py captures/lrpt/<nimi> [--sat "METEOR-M2 4"] [--apid 64] [--date 2026-09-19] [--fov 110]
         [--flip] [--coast ne_110m_coastline.geojson] [--lon 0 50 --lat 35 75 --deg 0.05]
Väljund: <kaust>/8_kaart_apid<N>.png (+ _rgb kui 3 kanalit) ja 8_geo.csv (rida -> alampunkt lat/lon).
"""
import argparse, json, math, os, sys
from datetime import datetime, timedelta, timezone
import numpy as np

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from specgram import write_png
from passes import load_tles
from sgp4.api import Satrec, jday

RE = 6371.0
CITIES = [("Tallinn", 59.44, 24.75), ("Helsingi", 60.17, 24.94), ("Stockholm", 59.33, 18.07), ("Riia", 56.95, 24.11),
          ("Peterburi", 59.93, 30.32), ("Oslo", 59.91, 10.75), ("Kopenhaagen", 55.68, 12.57), ("Varssavi", 52.23, 21.01),
          ("Berliin", 52.52, 13.40), ("Kiiev", 50.45, 30.52), ("Minsk", 53.90, 27.57), ("Moskva", 55.76, 37.62),
          ("Vilnius", 54.69, 25.28), ("Praha", 50.08, 14.44), ("Viin", 48.21, 16.37), ("Bukarest", 44.43, 26.10),
          ("Istanbul", 41.01, 28.98), ("Ateena", 37.98, 23.73), ("Rooma", 41.90, 12.50), ("Tromsø", 69.65, 18.96),
          ("Murmansk", 68.97, 33.08), ("Arhangelsk", 64.54, 40.54), ("Reykjavik", 64.13, -21.90), ("London", 51.51, -0.13),
          ("Pariis", 48.86, 2.35), ("Madrid", 40.42, -3.70)]


def read_png_gray(path):
    import zlib, struct
    d = open(path, "rb").read(); pos = 8; idat = b""; w = h = 0
    while pos < len(d):
        ln = struct.unpack(">I", d[pos:pos + 4])[0]; tag = d[pos + 4:pos + 8]; data = d[pos + 8:pos + 8 + ln]
        if tag == b"IHDR":
            w, h = struct.unpack(">II", data[:8])
        if tag == b"IDAT":
            idat += data
        pos += 12 + ln
    raw = np.frombuffer(zlib.decompress(idat), np.uint8).reshape(h, w + 1)
    assert (raw[:, 0] == 0).all(), "ainult filtrita PNG (write_png)"
    return raw[:, 1:].copy()


def gmst_deg(jd, fr):
    t = (jd + fr - 2451545.0) / 36525.0
    return (280.46061837 + 360.98564736629 * (jd + fr - 2451545.0) + 0.000387933 * t * t) % 360


def sat_state(sat, t):
    jd, fr = jday(t.year, t.month, t.day, t.hour, t.minute, t.second + t.microsecond / 1e6)
    e, r, v = sat.sgp4(jd, fr)
    if e != 0:
        raise RuntimeError(f"sgp4 viga {e}")
    g = math.radians(gmst_deg(jd, fr))
    # TEME -> ECEF (pöörle -GMST ümber z)
    c, s = math.cos(g), math.sin(g)
    R = np.array([[c, s, 0], [-s, c, 0], [0, 0, 1]])
    r_e = R @ np.array(r); v_e = R @ np.array(v) - np.cross([0, 0, 7.2921159e-5], r_e)
    return r_e, v_e


def ecef_to_ll(p):
    x, y, z = p
    lat = math.degrees(math.atan2(z, math.hypot(x, y))); lon = math.degrees(math.atan2(y, x))
    return lat, lon


def ground_point(r_e, look):
    """Sirge r_e + s*look lõikepunkt keraga RE (lähim)."""
    look = look / np.linalg.norm(look)
    b = 2 * np.dot(r_e, look); c = np.dot(r_e, r_e) - RE * RE
    disc = b * b - 4 * c
    if disc < 0:
        return None
    s = (-b - math.sqrt(disc)) / 2
    return r_e + s * look


def georef(rows_t, ncols, sat, date, fov_deg, flip):
    """Tagastab lat/lon massiivid (nrows, ncols) ja alampunktid."""
    nrows = len(rows_t); lat = np.full((nrows, ncols), np.nan); lon = np.full((nrows, ncols), np.nan); sub = []
    half = math.radians(fov_deg / 2)
    angs = (np.arange(ncols) - (ncols - 1) / 2) / ((ncols - 1) / 2) * half
    if flip:
        angs = -angs
    for i, ts in enumerate(rows_t):
        t = datetime(date.year, date.month, date.day, tzinfo=timezone.utc) + timedelta(seconds=ts % 86400)
        r_e, v_e = sat_state(sat, t)
        nadir = -r_e / np.linalg.norm(r_e)
        along = v_e - np.dot(v_e, -nadir) * (-nadir); along /= np.linalg.norm(along)
        cross = np.cross(along, nadir); cross /= np.linalg.norm(cross)      # paremale lennusuunast
        sub.append(ecef_to_ll(ground_point(r_e, nadir)))
        for j, a in enumerate(angs):
            look = math.cos(a) * nadir + math.sin(a) * cross
            g = ground_point(r_e, look)
            if g is not None:
                lat[i, j], lon[i, j] = ecef_to_ll(g)
    return lat, lon, sub


def draw_line(canvas, x0, y0, x1, y1, val):
    n = int(max(abs(x1 - x0), abs(y1 - y0))) + 1
    xs = np.linspace(x0, x1, n).astype(int); ys = np.linspace(y0, y1, n).astype(int)
    ok = (xs >= 0) & (xs < canvas.shape[1]) & (ys >= 0) & (ys < canvas.shape[0])
    canvas[ys[ok], xs[ok]] = val


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("folder"); ap.add_argument("--sat", default="METEOR-M2 4"); ap.add_argument("--apid", type=int, default=64)
    ap.add_argument("--date", default=datetime.now().strftime("%Y-%m-%d")); ap.add_argument("--fov", type=float, default=110.0)
    ap.add_argument("--flip", action="store_true"); ap.add_argument("--coast")
    ap.add_argument("--lon", type=float, nargs=2, default=[0, 50]); ap.add_argument("--lat", type=float, nargs=2, default=[35, 75])
    ap.add_argument("--deg", type=float, default=0.05); ap.add_argument("--rowstep", type=int, default=1)
    ap.add_argument("--rgb", default="", help="värvikomposiit, APID-id R,G,B (nt 65,64,64); kirjutab 7_pilt_rgb.png ja 8_kaart_rgb.png")
    a = ap.parse_args()
    img = read_png_gray(os.path.join(a.folder, f"7_pilt_apid{a.apid}.png"))
    rgb = None
    if a.rgb:
        chans = [read_png_gray(os.path.join(a.folder, f"7_pilt_apid{int(c)}.png")) for c in a.rgb.split(",")]
        h = min(c.shape[0] for c in chans)
        rgb = np.stack([c[:h] for c in chans], axis=2)
        from specgram import write_png_rgb
        write_png_rgb(os.path.join(a.folder, "7_pilt_rgb.png"), rgb)
        img = img[:h]
    rows = np.genfromtxt(os.path.join(a.folder, "7_read.csv"), delimiter=",", skip_header=1)
    if rows.ndim == 1:
        rows = rows[None, :]
    period = rows[0, 2]; t0 = rows[0, 1]
    nstrip = img.shape[0] // 8
    sats = load_tles()
    key = [k for k in sats if k.upper().startswith(a.sat.upper())]
    if not key:
        raise SystemExit(f"TLE puudub: {a.sat}; olemas nt {[k for k in sats if 'METEOR' in k]}")
    sat = Satrec.twoline2rv(*sats[key[0]])
    date = datetime.strptime(a.date, "%Y-%m-%d")
    # iga pildirea (8 px riba sees rida k) aeg: riba algus + k/8 perioodist
    line_t = np.array([t0 + s * period + (k + 0.5) / 8 * period for s in range(nstrip) for k in range(8)])
    lat, lon, sub = georef(line_t, img.shape[1], sat, date, a.fov, a.flip)
    with open(os.path.join(a.folder, "8_geo.csv"), "w", encoding="utf-8") as f:
        f.write("riba,t_utc,alampunkt_lat,alampunkt_lon\n")
        for s in range(nstrip):
            tt = datetime(date.year, date.month, date.day, tzinfo=timezone.utc) + timedelta(seconds=(t0 + s * period) % 86400)
            f.write(f"{s},{tt:%H:%M:%S},{sub[s*8][0]:.3f},{sub[s*8][1]:.3f}\n")
    print(f"{key[0]}: {nstrip} riba, alampunkt {sub[0][0]:.1f}N {sub[0][1]:.1f}E -> {sub[-1][0]:.1f}N {sub[-1][1]:.1f}E; "
          f"vasak serv {lat[0,0]:.1f}N {lon[0,0]:.1f}E, parem serv {lat[0,-1]:.1f}N {lon[0,-1]:.1f}E")
    # kaart
    lo0, lo1 = a.lon; la0, la1 = a.lat; W = int((lo1 - lo0) / a.deg); H = int((la1 - la0) / a.deg)
    canvas = np.full((H, W), 235, np.uint8); hit = np.zeros((H, W), bool)
    canvas_rgb = np.full((H, W, 3), 235, np.uint8) if rgb is not None else None
    ok = np.isfinite(lat) & (lon >= lo0) & (lon < lo1) & (lat >= la0) & (lat < la1)
    xs = ((lon[ok] - lo0) / a.deg).astype(int); ys = ((la1 - lat[ok]) / a.deg).astype(int)
    vals = img[ok]
    good = vals != 128
    # splat: pilt kaardile (ka naaberpikslid, et augud kaoksid)
    for dx in (0, 1):
        for dy in (0, 1):
            xx = np.clip(xs + dx, 0, W - 1); yy = np.clip(ys + dy, 0, H - 1)
            canvas[yy[good], xx[good]] = vals[good]; hit[yy[good], xx[good]] = True
            if canvas_rgb is not None:
                canvas_rgb[yy[good], xx[good]] = rgb[ok][good]
    def line(x0, y0, x1, y1, val):
        draw_line(canvas, x0, y0, x1, y1, val)
        if canvas_rgb is not None:
            col = {0: (20, 20, 20), 90: (120, 120, 120), 255: (255, 255, 0)}.get(val, (val, val, val))
            for ch in range(3):
                draw_line(canvas_rgb[:, :, ch], x0, y0, x1, y1, col[ch])
    # kraadivõrk iga 5°
    for lo in np.arange(math.ceil(lo0 / 5) * 5, lo1, 5):
        line((lo - lo0) / a.deg, 0, (lo - lo0) / a.deg, H - 1, 90)
    for la in np.arange(math.ceil(la0 / 5) * 5, la1, 5):
        line(0, (la1 - la) / a.deg, W - 1, (la1 - la) / a.deg, 90)
    # rannajooned (GeoJSON LineString/MultiLineString), kui antud
    if a.coast and os.path.exists(a.coast):
        gj = json.load(open(a.coast, encoding="utf-8"))
        for feat in gj["features"]:
            geom = feat["geometry"]; lines = geom["coordinates"] if geom["type"] == "MultiLineString" else [geom["coordinates"]]
            if geom["type"] == "Polygon":
                lines = geom["coordinates"]
            if geom["type"] == "MultiPolygon":
                lines = [ring for poly in geom["coordinates"] for ring in poly]
            for seg_ in lines:
                pts = np.array(seg_)
                for (x0, y0), (x1, y1) in zip(pts[:-1], pts[1:]):
                    if lo0 <= x0 < lo1 and la0 <= y0 < la1 and lo0 <= x1 < lo1 and la0 <= y1 < la1:
                        line((x0 - lo0) / a.deg, (la1 - y0) / a.deg, (x1 - lo0) / a.deg, (la1 - y1) / a.deg, 0)
    # linnad: väike ristike
    for name, la, lo in CITIES:
        if lo0 <= lo < lo1 and la0 <= la < la1:
            x = int((lo - lo0) / a.deg); y = int((la1 - la) / a.deg)
            line(x - 4, y, x + 4, y, 0); line(x, y - 4, x, y + 4, 0)
    # alampunkti rada
    for (la, lo) in sub[::8]:
        if lo0 <= lo < lo1 and la0 <= la < la1:
            line(int((lo - lo0) / a.deg), int((la1 - la) / a.deg), int((lo - lo0) / a.deg), int((la1 - la) / a.deg), 255)
    out = os.path.join(a.folder, f"8_kaart_apid{a.apid}.png")
    write_png(out, canvas)
    if canvas_rgb is not None:
        from specgram import write_png_rgb
        write_png_rgb(os.path.join(a.folder, "8_kaart_rgb.png"), canvas_rgb)
    print(f"kaart {out} ({W}x{H}, {a.deg}°/px, kaetud {hit.mean()*100:.1f} %)")


if __name__ == "__main__":
    main()
