build_everything.py

#!/usr/bin/env python3
"""
Indexador universal — lê TODOS os PNGs do workspace e gera
data/everything.json + copia imagens pra static/everything/.

Uso: rodar depois de build_catalog.py.
"""
import json
import hashlib
from pathlib import Path

ROOT = Path("/home/user/workspace")
OUT = Path("/home/user/workspace/slotforge_catalog/data/everything.json")
STATIC_ALL = Path("/home/user/workspace/slotforge_catalog/static/everything")
STATIC_ALL.mkdir(parents=True, exist_ok=True)

# Pastas a excluir (agent outputs internos)
EXCLUDE_DIRS = {
    "__pycache__",
    "node_modules",
    ".git",
    "slotforge_catalog",  # evita auto-indexar
}

# Max size pra copiar pra static (imagens gigantes viram problema de deploy)
MAX_SIZE_MB = 15


def should_include(p: Path) -> bool:
    parts = set(p.parts)
    if parts & EXCLUDE_DIRS:
        return False
    # Ignorar fullres gigantes se existir versão normal
    if p.stat().st_size > MAX_SIZE_MB * 1024 * 1024:
        return False
    return True


def short_hash(s: str) -> str:
    return hashlib.md5(s.encode()).hexdigest()[:8]


def categorize(rel_path: str) -> str:
    """Categoria leve baseada no caminho."""
    rl = rel_path.lower()
    # Heroes/hero_clean ainda são úteis distinguir
    if "hero_clean" in rl or "/top10" in rl or "tgs_reimagined" in rl:
        return "Hero 1x5 (MadLab)"
    if "pipeline_bison_express" in rl or "bison_express" in rl:
        return "Bison Express"
    if "pipeline_thunder_drum_wyrm" in rl or "pipeline_v2_thunder_drum_wyrm" in rl or "pipeline_seq_thunder" in rl:
        return "Thunder Drum Wyrm"
    if "heroes_official" in rl:
        return "Coin Baron Official"
    if "pigs_of_olympus" in rl or "pigs_olympus" in rl:
        if "/characters" in rl or "character" in rl:
            return "Pigs of Olympus — Characters"
        if "/bonus" in rl:
            return "Pigs of Olympus — Bonus"
        if "/symbols" in rl or "sym_" in rl:
            return "Pigs of Olympus — Symbols"
        return "Pigs of Olympus"
    if "mystic_throne" in rl or "mystic_playable" in rl:
        return "Mystic Throne"
    if "coin_baron" in rl:
        return "Coin Baron"
    if "slotforge_data/hero_images" in rl:
        return "SlotForge hero_images (histórico)"
    if "slotforge_data/symbols" in rl:
        return "SlotForge symbols"
    if "references_library" in rl or "image_vault" in rl:
        return "References (refs externas)"
    if "slotforge_data/base_game_screens" in rl:
        return "Base game screens"
    if "slotforge_data/fullscreen" in rl:
        return "Fullscreen v1"
    if "slotforge_gallery/assets" in rl:
        return "Gallery assets"
    if "slotforge_gallery/mockups_with_hands" in rl:
        return "Mockups with hands"
    if "tgs_reference" in rl:
        return "TGS reference"
    if "tool_calls" in rl:
        return "Tool calls (AI gen)"
    if "phase2_mystic_throne/assets" in rl or "phase2_mystic_throne/modern_refs" in rl:
        return "Mystic Throne assets/refs"
    if "phase2_mystic_throne" in rl:
        return "Phase 2 outros"
    if "forgingslots" in rl:
        return "Forging Slots outputs"
    return "Outros"


def classify_format(filename: str, rel_path: str) -> str:
    """Form-factor bucket para filtro."""
    hay = (filename + " " + rel_path).lower()
    if "pulltab" in hay:
        return "pulltab"
    if "cabinet" in hay or "gabinete" in hay:
        return "cabinet"
    if "ipad" in hay and "landscape" in hay:
        return "ipad_landscape"
    if "ipad" in hay and "portrait" in hay:
        return "ipad_portrait"
    if "ipad" in hay:
        return "ipad"
    if "mobile" in hay and "landscape" in hay:
        return "mobile_landscape"
    if "mobile" in hay and "portrait" in hay:
        return "mobile_portrait"
    if "mobile" in hay:
        return "mobile"
    if "web" in hay:
        return "web"
    if "portrait" in hay or "9_16" in hay or "9x16" in hay:
        return "portrait"
    if "landscape" in hay or "16_9" in hay or "16x9" in hay:
        return "landscape"
    if "symbol" in hay or "sym_" in hay:
        return "symbol"
    if "character" in hay or "char" in hay or "mascot" in hay:
        return "character"
    if "bonus" in hay:
        return "bonus"
    if "logo" in hay:
        return "logo"
    if "bg_" in hay or "background" in hay:
        return "background"
    return "other"


def main():
    all_pngs = []
    for p in ROOT.rglob("*.png"):
        try:
            if not should_include(p):
                continue
            rel = p.relative_to(ROOT)
            rel_str = str(rel)
            # Filtros
            parts = set(rel.parts)
            if parts & EXCLUDE_DIRS:
                continue
            all_pngs.append(p)
        except Exception:
            continue

    print(f"Encontrados: {len(all_pngs)} PNGs")

    entries = []
    copy_errors = 0
    for src in all_pngs:
        rel = src.relative_to(ROOT)
        rel_str = str(rel)
        # ID estável baseado em path
        id_hash = short_hash(rel_str)
        ext = src.suffix.lower()
        dst_name = f"{id_hash}_{src.stem[:40]}{ext}"
        dst = STATIC_ALL / dst_name

        try:
            if not dst.exists() or dst.stat().st_mtime < src.stat().st_mtime:
                dst.write_bytes(src.read_bytes())
        except Exception as e:
            copy_errors += 1
            continue

        category = categorize(rel_str)
        fmt = classify_format(src.name, rel_str)
        size_kb = src.stat().st_size // 1024

        entries.append({
            "id": f"all_{id_hash}",
            "filename": src.name,
            "rel_path": rel_str,
            "category": category,
            "format_class": fmt,
            "size_kb": size_kb,
            "image_url": f"/static/everything/{dst_name}",
        })

    # Stats
    cat_counts = {}
    fmt_counts = {}
    for e in entries:
        cat_counts[e["category"]] = cat_counts.get(e["category"], 0) + 1
        fmt_counts[e["format_class"]] = fmt_counts.get(e["format_class"], 0) + 1

    doc = {
        "generated_at": "2026-04-20",
        "total": len(entries),
        "copy_errors": copy_errors,
        "by_category": cat_counts,
        "by_format": fmt_counts,
        "items": entries,
    }

    OUT.parent.mkdir(parents=True, exist_ok=True)
    with open(OUT, "w") as f:
        json.dump(doc, f, indent=2, ensure_ascii=False)

    print(f"Escrito: {OUT}")
    print(f"Total indexado: {len(entries)}")
    print(f"Erros de cópia: {copy_errors}")
    print("\nPor categoria:")
    for c, n in sorted(cat_counts.items(), key=lambda x: -x[1]):
        print(f"  {n:4d}  {c}")
    print("\nPor form-factor:")
    for f, n in sorted(fmt_counts.items(), key=lambda x: -x[1]):
        print(f"  {n:4d}  {f}")


if __name__ == "__main__":
    main()