#!/usr/bin/env python3
"""
gerar_library.py — gera .excalidrawlib Imperatriz com shapes-base premium.

Library inclui: card premium, hub central, frame de secao, conector elbow,
post-it Virgil, container tracejado, highlighter, breadcrumb de fases.
Importar no excalidraw.com via Library Panel.

Uso:
    python3 gerar_library.py --saida ~/library-imperatriz.excalidrawlib --paleta imperatriz
"""

import argparse
import json
import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent))

from helpers.excalidraw import (  # noqa: E402
    card_premium,
    container_secao,
    elipse,
    highlighter,
    library_excalidraw,
    linha,
    post_it,
    retangulo,
    seta,
    texto,
)
from helpers.paleta import (  # noqa: E402
    FONT_CASCADIA,
    FONT_HELVETICA,
    FONT_VIRGIL,
    TAMANHOS,
    cor_sombra,
    get_paleta,
)


def shape_card_premium(paleta):
    els = card_premium(0, 0, 240, 120, paleta, "Card Premium",
                       fill=paleta["background"], sombra=True)
    return els


def shape_card_destaque(paleta):
    els = card_premium(0, 0, 240, 120, paleta, "Destaque",
                       fill=paleta["dominante"], sombra=True)
    # Texto branco
    for el in els:
        if el["type"] == "text":
            el["strokeColor"] = paleta["background"]
    return els


def shape_card_accent(paleta):
    els = card_premium(0, 0, 240, 120, paleta, "Accent",
                       fill=cor_sombra(paleta["accent"], 30), sombra=True)
    return els


def shape_hub_central(paleta):
    centro = elipse(0, 0, 200, 200, paleta, fill=paleta["dominante"])
    centro["strokeColor"] = paleta["accent"]
    centro["strokeWidth"] = 3
    lbl = texto(40, 90, "HUB", paleta, tamanho=24, fonte=FONT_HELVETICA,
                alinhamento="center", cor=paleta["background"], largura=120)
    return [centro, lbl]


def shape_frame_secao(paleta):
    return container_secao(0, 0, 400, 240, "FASE 01 — DESCOBERTA", paleta)


def shape_conector_elbow(paleta):
    s = seta(0, 0, 200, 80, paleta, elbow=True)
    return [s]


def shape_post_it(paleta):
    return post_it(0, 0, 180, 180, paleta, "Anotacao\nimportante")


def shape_metrica_kpi(paleta):
    """Card metrica grande tipo dashboard."""
    elementos = []
    base = retangulo(0, 0, 220, 140, paleta, fill=paleta["background"], arredondado=True)
    base["strokeColor"] = paleta["neutro_medio"]
    elementos.append(base)
    elementos.append(texto(20, 16, "RECEITA", paleta, tamanho=12,
                           fonte=FONT_HELVETICA, cor=paleta["neutro_medio"]))
    elementos.append(texto(20, 40, "R$ 1.2M", paleta, tamanho=42,
                           fonte=FONT_CASCADIA, cor=paleta["dominante"]))
    elementos.append(texto(20, 100, "↑ 24% vs anterior", paleta, tamanho=14,
                           fonte=FONT_VIRGIL, cor=paleta["accent"]))
    return elementos


def shape_breadcrumb_fases(paleta):
    """4 setas chevron horizontais (estilo Power BI/processo)."""
    elementos = []
    x = 0
    nomes = ["Diagnostico", "Estrategia", "Execucao", "Resultado"]
    for i, nome in enumerate(nomes):
        cor = paleta["dominante"] if i == 0 else paleta["background"]
        cor_txt = paleta["background"] if i == 0 else paleta["traco"]
        bloco = retangulo(x, 0, 140, 50, paleta, fill=cor, arredondado=True)
        elementos.append(bloco)
        lbl = texto(x, 14, nome, paleta, tamanho=14, fonte=FONT_HELVETICA,
                    alinhamento="center", cor=cor_txt, largura=140)
        lbl["x"] = x
        lbl["y"] = 0
        lbl["width"] = 140
        lbl["height"] = 50
        lbl["containerId"] = bloco["id"]
        lbl["verticalAlign"] = "middle"
        bloco["boundElements"] = [{"type": "text", "id": lbl["id"]}]
        elementos.append(lbl)
        # Seta entre eles
        if i < len(nomes) - 1:
            s = seta(x + 140, 25, x + 152, 25, paleta, elbow=False,
                     espessura=2, cor=paleta["neutro_medio"])
            elementos.append(s)
        x += 152

    return elementos


def shape_quadrante_matriz(paleta):
    """Mini matriz 2x2 pronta."""
    elementos = []
    tam = 100
    cores = [
        cor_sombra(paleta["accent"], 30),
        cor_sombra(paleta["dominante"], 30),
        cor_sombra(paleta["neutro_medio"], 20),
        cor_sombra(paleta["destaque_quente"], 25),
    ]
    posicoes = [(0, 0), (tam, 0), (0, tam), (tam, tam)]
    labels = ["Q1", "Q2", "Q3", "Q4"]
    for (x, y), cor, lbl in zip(posicoes, cores, labels):
        r = retangulo(x, y, tam, tam, paleta, fill=cor, arredondado=False)
        elementos.append(r)
        t = texto(x + 35, y + 35, lbl, paleta, tamanho=24,
                  fonte=FONT_HELVETICA, alinhamento="center", largura=30)
        elementos.append(t)
    return elementos


def shape_funil_trio(paleta):
    """3 faixas de funil pre-prontas (gradiente)."""
    elementos = []
    cores = [
        cor_sombra(paleta["dominante"], 90),
        cor_sombra(paleta["dominante"], 60),
        cor_sombra(paleta["dominante"], 30),
    ]
    y = 0
    larguras = [320, 240, 160]
    for i, (l, cor) in enumerate(zip(larguras, cores)):
        x = (320 - l) / 2
        els = card_premium(int(x), y, l, 60, paleta, f"Etapa {i+1}",
                           fill=cor, sombra=(i == 0))
        elementos.extend(els)
        y += 68
    return elementos


def shape_highlighter_text(paleta):
    """Texto com marca-texto atras (estilo annotation)."""
    hl = highlighter(0, 0, 160, 28, paleta, cor_destaque=paleta["accent"])
    txt = texto(8, 6, "Palavra-chave", paleta, tamanho=16,
                fonte=FONT_HELVETICA, cor=paleta["traco"])
    return [hl, txt]


def main():
    parser = argparse.ArgumentParser(description="Gera library Excalidraw Imperatriz")
    parser.add_argument("--saida", required=True, help="Caminho .excalidrawlib")
    parser.add_argument("--paleta", default="imperatriz",
                        choices=["imperatriz", "mckinsey", "dark_premium", "notion_minimal"])
    args = parser.parse_args()

    paleta = get_paleta(args.paleta)

    items = [
        {"nome": "Card Premium", "elementos": shape_card_premium(paleta)},
        {"nome": "Card Destaque (dominante)", "elementos": shape_card_destaque(paleta)},
        {"nome": "Card Accent", "elementos": shape_card_accent(paleta)},
        {"nome": "Hub Central", "elementos": shape_hub_central(paleta)},
        {"nome": "Frame de Secao", "elementos": shape_frame_secao(paleta)},
        {"nome": "Conector Elbow", "elementos": shape_conector_elbow(paleta)},
        {"nome": "Post-it (Virgil)", "elementos": shape_post_it(paleta)},
        {"nome": "Card Metrica KPI", "elementos": shape_metrica_kpi(paleta)},
        {"nome": "Breadcrumb de Fases", "elementos": shape_breadcrumb_fases(paleta)},
        {"nome": "Mini Matriz 2x2", "elementos": shape_quadrante_matriz(paleta)},
        {"nome": "Trio de Funil", "elementos": shape_funil_trio(paleta)},
        {"nome": "Highlighter + Texto", "elementos": shape_highlighter_text(paleta)},
    ]

    lib = library_excalidraw(items, nome=f"Imperatriz {paleta['nome']}")
    p = Path(args.saida).expanduser()
    p.parent.mkdir(parents=True, exist_ok=True)
    p.write_text(json.dumps(lib, ensure_ascii=False, indent=2), encoding="utf-8")
    print(f"✓ Library com {len(items)} shapes salva em: {p}")


if __name__ == "__main__":
    main()
