"""PROTOTYP — wegwerfen. Bereitet die Daten für den Logoflächen-Editor im Bericht vor:
bereinigte Vorlagen (EV-Logo entfernt), Umfärbemasken, Wandhelligkeit, Standardflächen
und die Firmenlogos als Schild. Alles als data:-URI, damit der Canvas auch unter file:// lesen darf."""
import base64
import io
import json
import os
import re

import numpy as np
from PIL import Image, ImageFilter
from scipy import ndimage

from bilder import ANSICHTEN, HIER
from bilder2 import BREITE_MAX, ev_logo_box, logo_vorbereiten, vorlage
from einfaerben import maske


def data_uri(im, fmt, **kw):
    buf = io.BytesIO()
    im.save(buf, fmt, **kw)
    return f"data:image/{fmt.lower()};base64," + base64.b64encode(buf.getvalue()).decode()


def ev_logo_entfernen(im):
    """Übermalt das weiße EV-Logo mit der umgebenden Wand (nächster Nachbar, leicht weichgezeichnet)."""
    a = np.array(im).astype(float)
    x0, y0, x1, y1 = ev_logo_box(im)
    grau = a[..., :3].mean(-1)
    bereich = np.zeros(grau.shape, bool)
    bereich[y0 - 4:y1 + 4, x0 - 4:x1 + 4] = True
    wand = np.median(grau[y0 - 30:y1 + 30, x0 - 60:x1 + 60])
    logo = bereich & (grau > wand + 12)
    logo = ndimage.binary_dilation(logo, iterations=3) & bereich
    _, (iy, ix) = ndimage.distance_transform_edt(logo, return_indices=True)
    gefuellt = a[iy, ix]
    weich = np.array(Image.fromarray(gefuellt.astype(np.uint8), "RGBA").filter(ImageFilter.GaussianBlur(3))).astype(float)
    a[logo] = weich[logo]
    return Image.fromarray(a.clip(0, 255).astype(np.uint8), "RGBA")


FESTGESCHRIEBEN = json.load(open(os.path.join(HIER, "logoflaechen.json")))


def standardflaeche(datei, im):
    if datei in FESTGESCHRIEBEN["flaechen"]:
        return FESTGESCHRIEBEN["flaechen"][datei]
    if datei not in BREITE_MAX:
        return None
    x0, y0, x1, y1 = ev_logo_box(im)
    bw, bh = x1 - x0, y1 - y0
    w, h = bw * BREITE_MAX[datei], bh * 1.15
    cx, cy = (x0 + x1) / 2, (y0 + y1) / 2
    return {"x": round(cx - w / 2), "y": round(cy - h / 2), "w": round(w), "h": round(h)}


if __name__ == "__main__":
    ansichten = []
    for datei, label, seite in ANSICHTEN:
        v = vorlage(datei)
        bereinigt = ev_logo_entfernen(v) if seite else v
        a = np.array(bereinigt)
        m = maske(np.array(v))
        ref = float(np.median(a[..., :3].astype(float).mean(-1)[m & (a[..., 3] > 250)]))
        ansichten.append({
            "datei": datei, "label": label, "seite": seite,
            "bild": data_uri(bereinigt, "WEBP", lossless=True),
            "maske": data_uri(Image.fromarray((m * 255).astype(np.uint8), "L"), "PNG", optimize=True),
            "ref": round(ref, 2),
            "standard": standardflaeche(datei, v),
            "breite": v.width, "hoehe": v.height,
        })
    ergebnisse = json.load(open(os.path.join(HIER, "ergebnis.json")))
    firmen = []
    for name, r in ergebnisse.items():
        slug = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
        pfad = os.path.join(HIER, "gen", slug, "logo.png")
        if r.get("farbe_quelle") != "container" or not os.path.exists(pfad):
            continue
        schild, _ = logo_vorbereiten(pfad)
        schild.thumbnail((600, 600))
        firmen.append({"name": name, "slug": slug, "farbe": r["farbe"], "logo": data_uri(schild, "PNG", optimize=True)})
    json.dump({"ansichten": ansichten, "firmen": firmen, "fest": {k: v for k, v in FESTGESCHRIEBEN.items() if k != "flaechen"}}, open(os.path.join(HIER, "editor-daten.json"), "w"))
    groesse = os.path.getsize(os.path.join(HIER, "editor-daten.json"))
    print(f"{len(ansichten)} Ansichten, {len(firmen)} Firmen, {groesse // 1024} KB")
    # Kontrolle: bereinigte Seitenansichten
    blatt = Image.new("RGBA", (700 * 5, 466), (230, 230, 230, 255))
    for i, (datei, _, seite) in enumerate([x for x in ANSICHTEN if x[2]]):
        b = ev_logo_entfernen(vorlage(datei)).resize((700, 466))
        blatt.alpha_composite(b, (700 * i, 0))
    blatt.convert("RGB").save(os.path.join(HIER, "bereinigt.jpg"), quality=85)