"""
Generator PSD - Podziekowanie dla gosci weselnych (buteleczka, Wzor 2).

Otwiera szablon PSD, podmienia teksty w Smart Object "Projekt"
z zachowaniem pozycji warstw, zapisuje jako nowy PSD w folderze _gotowe.

Wszystkie 8 warstw w szablonie to linkowane kopie tego samego Smart Object,
wiec edycja w "Projekt" propaguje sie automatycznie na pozostale buteleczki.

Wymaga: uruchomiony Adobe Photoshop, pakiet photoshop-python-api.

Uzycie:
    python buteleczki_slub_wzor2.py --imie_pana "Piotr" --imie_pani "Anna" \
        --data "12.12.2024" --klient "Anna Kowalska"

    python buteleczki_slub_wzor2.py --imie_pana "Piotr" --imie_pani "Anna" \
        --inicjal_pana "P" --inicjal_pani "A" --data "12.12.2024" \
        --tekst "Dziekujemy!" --klient "Anna Kowalska"
"""

import argparse
import os
import photoshop.api as ps


# --- Sciezki ---
PROJEKT_DIR = os.path.join(
    r"d:\pomysloweprezenty.pl\projekty\ślub - buteleczki",
    "Podziękowanie dla gości weselnych buteleczka z nadrukiem UV - Wzór 2",
)
SZABLON_PATH = os.path.join(PROJEKT_DIR, "szablon 370x300.psd")
GOTOWE_DIR = os.path.join(PROJEKT_DIR, "_gotowe")

# Nazwa warstwy Smart Object w glownym PSD (jeden z 8 - edycja propaguje na wszystkie)
SMART_OBJECT_LAYER = "Projekt"


def open_smart_object(app):
    """Otwiera zawartosc aktywnej warstwy Smart Object do edycji."""
    desc = ps.ActionDescriptor()
    ref = ps.ActionReference()
    ref.putEnumerated(
        app.stringIDToTypeID("layer"),
        app.stringIDToTypeID("ordinal"),
        app.stringIDToTypeID("targetEnum"),
    )
    desc.putReference(app.stringIDToTypeID("null"), ref)
    app.executeAction(app.stringIDToTypeID("placedLayerEditContents"), desc)


def change_text_preserve_position(layer, new_text):
    """Zmienia tekst warstwy z zachowaniem oryginalnej pozycji.

    Zwraca (dx, dy, ok) gdzie ok=False oznacza ze bounds_after=(0,0,0,0)
    (warstwa poza canvas SO po zmianie tekstu - delta nieuzyteczna).
    """
    bounds_before = [float(b) for b in layer.bounds]
    layer.textItem.contents = new_text
    bounds_after = [float(b) for b in layer.bounds]

    if bounds_after == [0.0, 0.0, 0.0, 0.0]:
        return (None, None, False)

    dx = bounds_before[0] - bounds_after[0]
    dy = bounds_before[1] - bounds_after[1]
    if dx != 0 or dy != 0:
        layer.translate(dx, dy)
    return (dx, dy, True)


def apply_replacements(group, replacements):
    """Podmienia teksty w grupie warstw z fallbackiem dla warstw gubiacych bounds.

    Photoshop po zmianie textItem.contents potrafi przeniesc warstwe
    poza canvas SO (bounds=0). Wykrywamy to i kompensujemy srednia delta
    z poprawnie obsluzonych warstw - przesuniecie jest systematyczne.
    """
    deltas = []
    pending = []

    for layer_name, new_text in replacements.items():
        layer = group.artLayers[layer_name]
        old_text = layer.textItem.contents
        dx, dy, ok = change_text_preserve_position(layer, new_text)
        if ok:
            deltas.append((dx, dy))
            print(f'  {layer_name}: "{old_text}" -> "{new_text}"')
        else:
            pending.append((layer_name, layer, old_text, new_text))
            print(f'  {layer_name}: "{old_text}" -> "{new_text}" (poza canvas, fallback)')

    if pending:
        if not deltas:
            raise RuntimeError("Wszystkie warstwy poza canvas - brak referencji do fallbacku")
        avg_dx = sum(d[0] for d in deltas) / len(deltas)
        avg_dy = sum(d[1] for d in deltas) / len(deltas)
        for layer_name, layer, _old, _new in pending:
            layer.translate(avg_dx, avg_dy)
            print(f'    [{layer_name}] fallback translate ({avg_dx:.2f},{avg_dy:.2f})')


def generate(
    imie_pana,
    imie_pani,
    data,
    klient,
    inicjal_pana=None,
    inicjal_pani=None,
    tekst=None,
):
    """Generuje PSD z podmienionymi danymi."""
    os.makedirs(GOTOWE_DIR, exist_ok=True)
    output_path = os.path.join(GOTOWE_DIR, f"{klient}.psd")

    # Auto-inicjaly z imion jesli nie podane
    if inicjal_pana is None:
        inicjal_pana = imie_pana[:1].upper() if imie_pana else ""
    if inicjal_pani is None:
        inicjal_pani = imie_pani[:1].upper() if imie_pani else ""

    app = ps.Application()
    doc = app.open(SZABLON_PATH)
    print(f"Otwarto szablon: {doc.name}")

    target = None
    for layer in doc.layers:
        if layer.name == SMART_OBJECT_LAYER:
            target = layer
            break

    if target is None:
        doc.close(ps.SaveOptions.DoNotSaveChanges)
        raise RuntimeError(f"Nie znaleziono warstwy '{SMART_OBJECT_LAYER}'")

    app.activeDocument.activeLayer = target
    open_smart_object(app)
    so_doc = app.activeDocument

    # Nawigacja do grupy z tekstami (po renamie: "Tekst")
    tekst_group = so_doc.layerSets["Tekst"]

    replacements = {
        "imie_pana": imie_pana,
        "imie_pani": imie_pani,
        "inicjal_pana": inicjal_pana,
        "inicjal_pani": inicjal_pani,
        "data": data,
    }
    if tekst is not None:
        replacements["tekst"] = tekst

    apply_replacements(tekst_group, replacements)

    so_doc.save()
    so_doc.close()
    print("Smart Object zapisany")

    psd_opts = ps.PhotoshopSaveOptions()
    app.activeDocument.saveAs(output_path, psd_opts, True)
    print(f"Zapisano: {output_path}")

    app.activeDocument.close(ps.SaveOptions.DoNotSaveChanges)
    print("Gotowe!")
    return output_path


def main():
    parser = argparse.ArgumentParser(
        description="Generator PSD - buteleczki weselne Wzor 2"
    )
    parser.add_argument("--imie_pana", required=True, help="Imie pana mlodego (np. Piotr)")
    parser.add_argument("--imie_pani", required=True, help="Imie pani mlodej (np. Anna)")
    parser.add_argument("--data", required=True, help="Data slubu (np. 12.12.2024)")
    parser.add_argument("--klient", required=True, help="Nazwa pliku wyjsciowego (bez .psd)")
    parser.add_argument(
        "--inicjal_pana",
        default=None,
        help="Inicjal pana mlodego (domyslnie: pierwsza litera --imie_pana)",
    )
    parser.add_argument(
        "--inicjal_pani",
        default=None,
        help="Inicjal pani mlodej (domyslnie: pierwsza litera --imie_pani)",
    )
    parser.add_argument(
        "--tekst",
        default=None,
        help="Tekst podziekowania (domyslnie: oryginalny z szablonu)",
    )

    args = parser.parse_args()
    generate(
        imie_pana=args.imie_pana,
        imie_pani=args.imie_pani,
        data=args.data,
        klient=args.klient,
        inicjal_pana=args.inicjal_pana,
        inicjal_pani=args.inicjal_pani,
        tekst=args.tekst,
    )


if __name__ == "__main__":
    main()
