#!/usr/bin/env python3
import os, time, struct, glob
from PIL import Image, ImageDraw, ImageFont
import serial

OUTDIR = "/home/pi/wunderkammer/data/wunderkammer64"
CURRENT = os.path.join(OUTDIR, "current.png")
BUILD   = os.path.join(OUTDIR, "current_build.png")

SERIAL_PORT = "/dev/serial/by-id/usb-Raspberry_Pi_Pico_<GERÄTE-ID>-if00"
BAUD = 115200

MAGIC = b"WK"
VERSION = 1
FMT_RGB565 = 1
W = H = 64
PAYLOAD_LEN = W * H * 2

MORPH_STEPS = 24
MORPH_DT = 1/30
POLL_DT = 0.2

def file_stat(path):
    try:
        st = os.stat(path)
        return (st.st_size, st.st_mtime_ns)
    except FileNotFoundError:
        return None

def build_is_active():
    st = file_stat(BUILD)
    if not st:
        return False
    age_s = (time.time_ns() - st[1]) / 1e9
    return age_s < 2.0

def wait_stable(path, checks=3, dt=0.25, max_wait=30.0):
    t0 = time.time()
    last = None
    stable = 0
    while time.time() - t0 < max_wait:
        cur = file_stat(path)
        if cur is None or cur[0] <= 0:
            stable = 0
            last = cur
            time.sleep(dt); continue
        if cur == last:
            stable += 1
            if stable >= checks:
                return True
        else:
            stable = 0
            last = cur
        time.sleep(dt)
    return False

def newest_finished_image():
    if os.path.exists(CURRENT):
        return CURRENT
    files = glob.glob(os.path.join(OUTDIR, "*.png"))
    files = [p for p in files if os.path.basename(p) != "current_build.png"]
    if not files:
        return None
    return max(files, key=lambda p: os.path.getmtime(p))

def to_rgb_image(path_or_img):
    if isinstance(path_or_img, Image.Image):
        img = path_or_img.convert("RGB")
    else:
        img = Image.open(path_or_img).convert("RGB")
    if img.size != (W, H):
        img = img.resize((W, H), Image.NEAREST)
    return img

def img_to_rgb565_bytes(img_rgb):
    px = img_rgb.load()
    out = bytearray(PAYLOAD_LEN)
    i = 0
    for y in range(H):
        for x in range(W):
            r, g, b = px[x, y]
            rgb565 = ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3)
            out[i]   = (rgb565 >> 8) & 0xFF
            out[i+1] = rgb565 & 0xFF
            i += 2
    return bytes(out)

def send_frame(ser, frame_id, payload):
    header = struct.pack(">2sBBHH", MAGIC, VERSION, FMT_RGB565, len(payload), frame_id & 0xFFFF)
    ser.write(header)
    ser.write(payload)
    ser.flush()

def morph_frames(a_img, b_img, steps):
    a = to_rgb_image(a_img)
    b = to_rgb_image(b_img)
    for i in range(steps + 1):
        yield Image.blend(a, b, i/steps)

def make_intro_frame(lines):
    img = Image.new("RGB", (W, H), (0, 0, 0))
    d = ImageDraw.Draw(img)
    font = ImageFont.load_default()
    y = 10
    for line in lines:
        box = d.textbbox((0, 0), line, font=font)
        tw, th = box[2]-box[0], box[3]-box[1]
        d.text(((W-tw)//2, y), line, font=font, fill=(255,255,255))
        y += 14
    return img

def main():
    frame_id = 0
    last_sig = None
    last_img = Image.new("RGB", (W, H), (0, 0, 0))

    print("Opening Pico serial:", SERIAL_PORT)
    with serial.Serial(SERIAL_PORT, BAUD, timeout=1) as ser:
        time.sleep(2.0)

        intro = make_intro_frame(["GOTTW(AI)G", "WUNDERKAMMER", "by Christian Munk"])
        send_frame(ser, frame_id, img_to_rgb565_bytes(intro)); frame_id += 1
        time.sleep(5.0)

        latest = newest_finished_image()
        if latest and wait_stable(latest):
            target = to_rgb_image(latest)
            for fr in morph_frames(intro, target, MORPH_STEPS):
                send_frame(ser, frame_id, img_to_rgb565_bytes(fr)); frame_id += 1
                time.sleep(MORPH_DT)
            last_img = target
            last_sig = file_stat(latest)

        while True:
            if build_is_active():
                time.sleep(POLL_DT)
                continue

            path = CURRENT if os.path.exists(CURRENT) else newest_finished_image()
            if path:
                sig = file_stat(path)
                if sig and sig != last_sig and wait_stable(path):
                    new_img = to_rgb_image(path)
                    for fr in morph_frames(last_img, new_img, MORPH_STEPS):
                        send_frame(ser, frame_id, img_to_rgb565_bytes(fr)); frame_id += 1
                        time.sleep(MORPH_DT)
                    last_img = new_img
                    last_sig = sig

            time.sleep(POLL_DT)

if __name__ == "__main__":
    main()
