orderPRO/tools/generowanie/akrylowa_statuetka_podziekowanie_rodzice_wzor2.py

"""
Generator PSD - Akrylowa statuetka podziekowanie dla Rodzicow ze zdjeciem (Wzor 2).

Plaska struktura PSD: w grupie "Projekt" znajduja sie:
- warstwy tekstowe: naglowek, tresc, para, data, motto
- Smart Object zdjecia: zdjecie (clipping mask do warstwy ponizej)

Podmiana zdjecia:
- jesli --zdjecie wskazuje na istniejacy plik graficzny -> zostaje wstawione,
  przeskalowane "cover" do oryginalnych boundsow placeholdera i wycentrowane
- jesli zdjecie nie zostalo podane lub plik nie istnieje -> wstawiamy
  zielony prostokat (#00FF00) jako sygnal, ze klient nie przeslal foto

Wymaga: uruchomiony Adobe Photoshop, photoshop-python-api, Pillow.
"""

import argparse
import os
import photoshop.api as ps


PROJEKT_DIR = os.path.join(
    r"d:\pomysloweprezenty.pl\projekty\ślub - podziękowania",
    "Akrylowa statuetka podziękowanie dla rodziców ze zdjęciem - Wzór 2",
)
SZABLON_PATH = os.path.join(PROJEKT_DIR, "Akrylowa statuetka podziękowanie dla rodziców ze zdjęciem - Wzór 2.psd")
GOTOWE_DIR = os.path.join(PROJEKT_DIR, "_gotowe")

ASSETS_DIR = os.path.join(os.path.dirname(__file__), "_assets")
GREEN_PLACEHOLDER_PATH = os.path.join(ASSETS_DIR, "green_placeholder.png")

PHOTO_SLOT = "zdjecie"


def ensure_green_placeholder():
    """Tworzy raz zielony PNG (#00FF00) jako placeholder dla brakujacego zdjecia."""
    if os.path.exists(GREEN_PLACEHOLDER_PATH):
        return GREEN_PLACEHOLDER_PATH
    os.makedirs(ASSETS_DIR, exist_ok=True)
    from PIL import Image
    Image.new("RGB", (1000, 1000), (0, 255, 0)).save(GREEN_PLACEHOLDER_PATH)
    return GREEN_PLACEHOLDER_PATH


def set_text(layer, new_text):
    """Zmienia tekst zachowujac srodek bounding boxa (centrowane warstwy)."""
    b = [float(x) for x in layer.bounds]
    cx, cy = (b[0] + b[2]) / 2, (b[1] + b[3]) / 2
    layer.textItem.contents = new_text
    b2 = [float(x) for x in layer.bounds]
    cx2, cy2 = (b2[0] + b2[2]) / 2, (b2[1] + b2[3]) / 2
    dx, dy = cx - cx2, cy - cy2
    if dx or dy:
        layer.translate(dx, dy)


def set_layer_text(container, layer_name, new_text):
    if new_text is None:
        return
    layer = container.artLayers[layer_name]
    old = layer.textItem.contents
    set_text(layer, new_text)
    print(f'    {layer_name}: "{old}" -> "{new_text}"')


def replace_smart_object_contents(app, file_path):
    """Wykonuje akcje placedLayerReplaceContents na aktywnej warstwie SO."""
    desc = ps.ActionDescriptor()
    desc.putPath(app.charIDToTypeID("null"), file_path)
    desc.putInteger(app.charIDToTypeID("PgNm"), 1)
    app.executeAction(app.stringIDToTypeID("placedLayerReplaceContents"), desc)


def replace_photo_cover(app, so_layer, photo_path):
    """Podmienia zawartosc Smart Object i skaluje 'cover' do oryginalnych boundsow."""
    target = [float(x) for x in so_layer.bounds]
    target_w = target[2] - target[0]
    target_h = target[3] - target[1]
    target_cx = (target[0] + target[2]) / 2
    target_cy = (target[1] + target[3]) / 2

    app.activeDocument.activeLayer = so_layer
    replace_smart_object_contents(app, photo_path)

    new_b = [float(x) for x in so_layer.bounds]
    new_w = new_b[2] - new_b[0]
    new_h = new_b[3] - new_b[1]
    if new_w <= 0 or new_h <= 0:
        return

    scale = max(target_w / new_w, target_h / new_h) * 100.0
    so_layer.resize(scale, scale, ps.AnchorPosition.MiddleCenter)

    cur = [float(x) for x in so_layer.bounds]
    cur_cx = (cur[0] + cur[2]) / 2
    cur_cy = (cur[1] + cur[3]) / 2
    so_layer.translate(target_cx - cur_cx, target_cy - cur_cy)


def swap_photo_slot(app, container, slot_name, photo_path):
    """Podmienia zdjecie w slocie; brak/nieistnieje -> zielony placeholder."""
    so_layer = container.artLayers[slot_name]
    if photo_path and os.path.isfile(photo_path):
        print(f"  {slot_name}: {photo_path}")
        replace_photo_cover(app, so_layer, photo_path)
    else:
        if photo_path:
            print(f"  {slot_name}: UWAGA plik nie istnieje ({photo_path}) - zielony placeholder")
        else:
            print(f"  {slot_name}: brak - zielony placeholder")
        replace_photo_cover(app, so_layer, ensure_green_placeholder())


def generate(klient, para, data, tresc=None, naglowek=None, motto=None, zdjecie=None):
    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:
        projekt = doc.layerSets["Projekt"]

        print("  Podmiana tekstow:")
        set_layer_text(projekt, "naglowek", naglowek)
        set_layer_text(projekt, "tresc", tresc)
        set_layer_text(projekt, "para", para)
        set_layer_text(projekt, "data", data)
        set_layer_text(projekt, "motto", motto)

        print("  Podmiana zdjecia:")
        swap_photo_slot(app, projekt, PHOTO_SLOT, zdjecie)

        psd_opts = ps.PhotoshopSaveOptions()
        doc.saveAs(output_path, psd_opts, True)
        print(f"Zapisano: {output_path}")
    finally:
        try:
            doc.close(ps.SaveOptions.DoNotSaveChanges)
        except Exception:
            pass

    print("Gotowe!")
    return output_path


def main():
    parser = argparse.ArgumentParser(
        description="Generator PSD - Akrylowa statuetka podziekowanie dla Rodzicow Wzor 2"
    )
    parser.add_argument("--klient", required=True, help="Nazwa pliku wyjsciowego (bez rozszerzenia)")
    parser.add_argument("--para", required=True, help="Imiona pary mlodej (np. 'Klaudia i Marcin')")
    parser.add_argument("--data", required=True, help="Data uroczystosci (np. '04.10.2025')")
    parser.add_argument("--tresc", default=None, help="Tresc podziekowania (opcjonalnie, domyslnie z szablonu)")
    parser.add_argument("--naglowek", default=None, help="Naglowek (opcjonalnie, domyslnie 'Kochani Rodzice!')")
    parser.add_argument("--motto", default=None, help="Motto (opcjonalnie)")
    parser.add_argument("--zdjecie", default=None, help="Sciezka do zdjecia (opcjonalnie; brak = zielony placeholder)")

    args = parser.parse_args()
    generate(
        klient=args.klient,
        para=args.para,
        data=args.data,
        tresc=args.tresc,
        naglowek=args.naglowek,
        motto=args.motto,
        zdjecie=args.zdjecie,
    )


if __name__ == "__main__":
    main()