orderPRO/tools/generowanie/buteleczki_slub_labedzie.py

"""
Generator PSD — Podziękowanie dla gości weselnych (buteleczka, Łabędzie).

Szablon 370x300 to layout 8-up: 8 instancji Smart Object linkujących do
jednego źródła (Warstwa 1.psb). Edycja zawartości jednej warstwy SO
propaguje się na wszystkie 8 kopii w arkuszu.

Wewnątrz SO warstwy tekstowe są w grupie "Warstwa 1":
    imie_zenskie, imie_meskie, data, zyczenia
(separator "&" zostaje bez zmian)

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

Użycie:
    python buteleczki_slub_labedzie.py --klient "Ania Pilarczyk" \
        --imie_zenskie "Ania" --imie_meskie "Maciek" --data "09.05.2026"

    python buteleczki_slub_labedzie.py --klient "Ania Pilarczyk" \
        --imie_zenskie "Ania" --imie_meskie "Maciek" --data "09.05.2026" \
        --zyczenia "DZIĘKUJEMY!"
"""

import argparse
import os
import photoshop.api as ps


# --- Ścieżki ---
PROJEKT_DIR = os.path.join(
    r"d:\pomysloweprezenty.pl\projekty\ślub - buteleczki",
    "Podziękowanie dla gości weselnych buteleczka z nadrukiem UV - Łabędzie",
)
SZABLON_PATH = os.path.join(PROJEKT_DIR, "szablon 370x300.psd")
GOTOWE_DIR = os.path.join(PROJEKT_DIR, "_gotowe")

# Grupa z tekstami wewnątrz Smart Object (Warstwa 1.psb)
TEKST_GROUP = "Warstwa 1"

# Kind code dla Smart Object w photoshop-python-api
SMART_OBJECT_KIND = 17


def open_smart_object(app):
    """Otwiera zawartość 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 zachowując środek bounding boxa
    (kompensacja dla warstw z wyśrodkowaną justyfikacją)."""
    b = [float(x) for x in layer.bounds]
    cx_before, cy_before = (b[0] + b[2]) / 2, (b[1] + b[3]) / 2

    layer.textItem.contents = new_text

    b2 = [float(x) for x in layer.bounds]
    cx_after, cy_after = (b2[0] + b2[2]) / 2, (b2[1] + b2[3]) / 2

    dx, dy = cx_before - cx_after, cy_before - cy_after
    if dx or dy:
        layer.translate(dx, dy)


def find_first_smart_object(doc):
    """Zwraca pierwszą warstwę Smart Object w dokumencie.

    Wszystkie 8 kopii linkuje do jednego .psb, więc edycja jednej
    propaguje zmiany na pozostałe.
    """
    for layer in doc.artLayers:
        if layer.kind == SMART_OBJECT_KIND:
            return layer
    raise RuntimeError("Nie znaleziono warstwy Smart Object w szablonie")


def close_all_without_saving(app):
    """Zamyka wszystkie otwarte dokumenty bez zapisu (awaryjne sprzątanie)."""
    while app.documents.length > 0:
        app.activeDocument.close(ps.SaveOptions.DoNotSaveChanges)


def generate(klient, imie_zenskie, imie_meskie, data, zyczenia=None):
    """Generuje PSD z podmienionymi danymi."""
    os.makedirs(GOTOWE_DIR, exist_ok=True)
    output_path = os.path.join(GOTOWE_DIR, f"{klient}.psd")

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

    try:
        so_layer = find_first_smart_object(doc)
        app.activeDocument.activeLayer = so_layer
        open_smart_object(app)
        so_doc = app.activeDocument
        print(f"Wszedłem do Smart Object: {so_doc.name}")

        tekst = so_doc.layerSets[TEKST_GROUP]

        replacements = {
            "imie_zenskie": imie_zenskie,
            "imie_meskie": imie_meskie,
            "data": data,
        }
        if zyczenia is not None:
            replacements["zyczenia"] = zyczenia

        print("Podmiana tekstów:")
        for layer_name, new_text in replacements.items():
            layer = tekst.artLayers[layer_name]
            old_text = layer.textItem.contents
            change_text_preserve_position(layer, new_text)
            print(f'  {layer_name}: "{old_text}" -> "{new_text}"')

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

        # Wymus odswiezenie cache wszystkich Smart Objectow w glownym dokumencie
        # — bez tego saveAs zapisze stary composite, mimo ze warstwy tekstowe
        # wewnatrz SO maja nowe wartosci.
        app.executeAction(
            app.stringIDToTypeID("placedLayerUpdateAllModified"),
            ps.ActionDescriptor(),
        )

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

        app.activeDocument.close(ps.SaveOptions.DoNotSaveChanges)
    except Exception:
        close_all_without_saving(app)
        raise

    print("Gotowe!")
    return output_path


def main():
    parser = argparse.ArgumentParser(
        description="Generator PSD - buteleczki ślubne (Łabędzie) 370x300 8-up"
    )
    parser.add_argument("--klient", required=True, help="Nazwa pliku wyjściowego (bez rozszerzenia)")
    parser.add_argument("--imie_zenskie", required=True, help="Imię żeńskie (np. Ania)")
    parser.add_argument("--imie_meskie", required=True, help="Imię męskie (np. Maciek)")
    parser.add_argument("--data", required=True, help="Data uroczystości (DD.MM.YYYY)")
    parser.add_argument(
        "--zyczenia",
        default=None,
        help='Tekst życzeń (opcjonalnie, domyślnie "NA ZDROWIE!" z szablonu)',
    )

    args = parser.parse_args()
    generate(
        klient=args.klient,
        imie_zenskie=args.imie_zenskie,
        imie_meskie=args.imie_meskie,
        data=args.data,
        zyczenia=args.zyczenia,
    )


if __name__ == "__main__":
    main()