"""Meteor-M2 LRPT: VCDU -> M-PDU -> CCSDS paketid -> MSU-MR pildiplokid (JPEG-laadne 8x8 DCT, Huffman) -> pilt.
Puhas numpy. Kasutab lrpt.py väljundit (6_vcdu.npy). Iga APID (64..69 = kanalid) -> eraldi PNG, 1568 px lai.
"""
import os, sys
import numpy as np

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from specgram import write_png

# --- JPEG Annex K standardtabelid (heleduskanal)
DC_BITS = [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]
DC_VALS = list(range(12))
AC_BITS = [0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d]
AC_VALS = [
    0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71,
    0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72,
    0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37,
    0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
    0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83,
    0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3,
    0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
    0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
    0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa]
QTAB = np.array([
    16, 11, 10, 16, 24, 40, 51, 61, 12, 12, 14, 19, 26, 58, 60, 55, 14, 13, 16, 24, 40, 57, 69, 56,
    14, 17, 22, 29, 51, 87, 80, 62, 18, 22, 37, 56, 68, 109, 103, 77, 24, 35, 55, 64, 81, 104, 113, 92,
    49, 64, 78, 87, 103, 121, 120, 101, 72, 92, 95, 98, 112, 100, 103, 99], float).reshape(8, 8)
ZIGZAG = np.array([
    0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21,
    28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61,
    54, 47, 55, 62, 63])


def build_huff(bits, vals):
    """(pikkus, kood) -> väärtus sõnastik (kanooniline Huffman)."""
    table = {}; code = 0; k = 0
    for ln in range(1, 17):
        for _ in range(bits[ln - 1]):
            table[(ln, code)] = vals[k]; k += 1; code += 1
        code <<= 1
    return table


DC_HUFF, AC_HUFF = build_huff(DC_BITS, DC_VALS), build_huff(AC_BITS, AC_VALS)

# IDCT maatriks
_C = np.array([[np.cos((2 * x + 1) * u * np.pi / 16) * (np.sqrt(0.5) if u == 0 else 1) for x in range(8)] for u in range(8)]) / 2


class BitReader:
    def __init__(self, data):
        self.bits = np.unpackbits(np.frombuffer(bytes(data), np.uint8)); self.pos = 0

    def read(self, n):
        if self.pos + n > len(self.bits):
            raise EOFError
        v = 0
        for b in self.bits[self.pos:self.pos + n]:
            v = (v << 1) | int(b)
        self.pos += n
        return v

    def huff(self, table):
        code = 0
        for ln in range(1, 17):
            code = (code << 1) | self.read(1)
            if (ln, code) in table:
                return table[(ln, code)]
        raise ValueError("halb Huffman-kood")


def extend(v, n):
    return v if n == 0 or v >= (1 << (n - 1)) else v - (1 << n) + 1


def qscale(qf):
    if qf <= 0 or qf > 100:
        qf = 50
    s = 5000 / qf if qf < 50 else 200 - 2 * qf
    q = np.floor((QTAB * s + 50) / 100)
    return np.clip(q, 1, 255)


def decode_mcus(payload, qf, n_mcu=14):
    """Tagastab (n_mcu, 8, 8) uint8 pildiplokid; pooleli jäänud plokid jäävad halliks (128)."""
    q = qscale(qf)
    br = BitReader(payload)
    out = np.full((n_mcu, 8, 8), 128, np.uint8)
    dc = 0; done = 0
    try:
        for m in range(n_mcu):
            coef = np.zeros(64)
            n = br.huff(DC_HUFF)
            dc += extend(br.read(n), n) if n else 0
            coef[0] = dc
            k = 1
            while k < 64:
                rs = br.huff(AC_HUFF)
                r, s = rs >> 4, rs & 0xF
                if rs == 0x00:          # EOB
                    break
                if rs == 0xF0:          # ZRL
                    k += 16; continue
                k += r
                if k > 63:
                    break
                coef[k] = extend(br.read(s), s); k += 1
            blk = np.zeros((8, 8)); blk.flat[ZIGZAG] = coef
            blk *= q
            px = _C.T @ blk @ _C + 128
            out[m] = np.clip(np.round(px), 0, 255).astype(np.uint8); done += 1
    except (EOFError, ValueError):
        pass
    return out, done


def packets_from_vcdus(vcdus):
    """vcdus: list (counter, ok, bytes892). Kogub M-PDU pakettitsoonist CCSDS paketid (APID, seq, andmed)."""
    pkts = []
    buf = b""; expect = None; last_cnt = None
    for cnt, ok, vc in vcdus:
        fhp = ((int(vc[8]) & 0x07) << 8) | int(vc[9])      # päis 10 baiti (6 VCDU + 2 insert + 2 M-PDU), tsoon 882
        zone = bytes(vc[10:892])
        if last_cnt is not None and cnt != last_cnt + 1:
            buf = b""                                  # vahepealt kaadrid puudu -> alusta uuest paketist
        last_cnt = cnt
        if fhp == 0x7FF:                               # selles kaadris ükski pakett ei alga
            buf += zone; continue
        if fhp > len(zone):
            buf = b""; continue
        if buf:
            buf += zone[:fhp]
            pkts.extend(_split(buf))
        buf = zone[fhp:]
        pkts.extend(_split_complete(buf)); buf = _rest(buf)
    return pkts


def _hdr(b):
    apid = ((b[0] & 0x07) << 8) | b[1]
    seq = ((b[2] & 0x3F) << 8) | b[3]
    ln = ((b[4] << 8) | b[5]) + 1
    return apid, seq, ln


def _split(buf):
    """Eelmise kaadri jätk: üks pakett (võib olla ainuke)."""
    if len(buf) < 6:
        return []
    apid, seq, ln = _hdr(buf)
    if 6 + ln > len(buf):
        return []
    return [(apid, seq, buf[6:6 + ln])]


def _split_complete(buf):
    out = []
    while len(buf) >= 6:
        apid, seq, ln = _hdr(buf)
        if ln < 1 or ln > 2000:
            break
        if 6 + ln > len(buf):
            break
        out.append((apid, seq, buf[6:6 + ln])); buf = buf[6 + ln:]
    return out


def _rest(buf):
    while len(buf) >= 6:
        apid, seq, ln = _hdr(buf)
        if ln < 1 or ln > 2000:
            return b""
        if 6 + ln > len(buf):
            return buf
        buf = buf[6 + ln:]
    return buf


def pkt_time(data):
    """Teisene päis: päev (2 B, alates 2000-01-01), ms päevas (4 B), µs (2 B) -> sekundid."""
    day = (data[0] << 8) | data[1]
    ms = (data[2] << 24) | (data[3] << 16) | (data[4] << 8) | data[5]
    us = (data[6] << 8) | data[7]
    return day * 86400.0 + ms / 1000.0 + us / 1e6


def build_images(pkts, out_dir, width_mcu=196):
    """Iga pildi-APID -> PNG. Rida = 8 px, 14 MCU paketi kohta, 196 MCU real. Rea indeks seq-loenduri järgi."""
    by_apid = {}
    for apid, seq, data in pkts:
        by_apid.setdefault(apid, []).append((seq, data))
    stats = {}
    # rea indeks ajatemplist: iga riba (14 paketti kanali kohta) kannab sama aega; riba periood mõõdetakse andmetest
    from collections import Counter
    tcount = Counter(pkt_time(d) for a, s, d in pkts if 64 <= a <= 69 and len(d) >= 14)
    all_t = sorted(t for t, n in tcount.items() if n >= 3)      # riba = mitu paketti sama ajaga; üksik aeg = rikutud päis
    if all_t:
        tmed = float(np.median(all_t))
        all_t = [t for t in all_t if abs(t - tmed) < 420]       # rikutud ajatemplid (RS-ita kaadrid) välja: ±7 min mediaanist (ülelend ≤ 15 min)
    if len(all_t) >= 3:
        dts = np.diff(all_t); period = float(np.median(dts[dts > 0.2]))
    else:
        period = 1.0
    t_first = all_t[0] if all_t else 0.0
    t_last = all_t[-1] if all_t else 0.0
    for apid, lst in sorted(by_apid.items()):
        if not (64 <= apid <= 69) or len(lst) < 3:
            stats[apid] = (len(lst), None); continue
        lst = [(s, d) for s, d in lst if len(d) >= 14]
        times = np.array([pkt_time(d) for s, d in lst])
        rel = np.round((times - t_first) / period).astype(int)
        rows = int(round((t_last - t_first) / period)) + 1
        rel[(rel < 0) | (rel >= rows)] = -1                      # vigase ajaga paketid jäetakse vahele
        img = np.full((rows * 8, width_mcu * 8), 128, np.uint8)
        good = bad = 0
        for (seq, data), row in zip(lst, rel):
            if len(data) < 14:
                continue
            mcun, qt, dcac, qfm, qf = data[8], data[9], data[10], (data[11] << 8) | data[12], data[13]
            row = int(row)
            if row < 0 or row >= rows or mcun % 14 != 0 or mcun >= width_mcu:
                bad += 1; continue
            blocks, done = decode_mcus(data[14:], qf)
            good += done; bad += 14 - done
            for m in range(14):
                x = (mcun + m) * 8
                img[row * 8:row * 8 + 8, x:x + 8] = blocks[m]
        path = os.path.join(out_dir, f"7_pilt_apid{apid}.png")
        write_png(path, img)
        stats[apid] = (len(lst), (rows, good, bad, path))
    # ridade ajatemplid georefereerimiseks (lrpt_geo.py): rida -> aeg (s alates 2000-01-01, satelliidi kell)
    with open(os.path.join(out_dir, "7_read.csv"), "w", encoding="utf-8") as f:
        f.write("rida,t_sat_s,periood_s\n")
        for r in range(int(round((t_last - t_first) / period)) + 1 if all_t else 0):
            f.write(f"{r},{t_first + r * period:.3f},{period:.4f}\n")
    return stats
