"""Ricostruisce l'indice archivio-foto -> gioco e riempie la tabella `giochi`.

L'archivio nomina i file col titolo che Paolo usa lui, il portale a volte con
quello italiano ("Clan di Caledonia" per "Clans of Caledonia"): l'abbinamento
guarda anche `altriNomi` di ogni scheda, confrontando i nomi normalizzati.

    python3 importa.py
"""
import json, os, re, sys, unicodedata
from collections import defaultdict

QUI = os.path.dirname(os.path.abspath(__file__))
ARCHIVIO = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "archivio")   # una cartella per gioco, "Nome (bggId)"

# Nomi d'archivio che l'abbinamento automatico sbaglia, e che quindi si decidono
# a mano. Deciso con Paolo il 2026-09-07. None vuol dire "non collegarlo a niente".
ECCEZIONI = {
    # tre foto di una partita che mescola gli altri due capitoli, non e' La via delle spezie
    "Century": None,
    # stesso gioco, ma con le tessere stampate in 3D in casa: le foto valgono per Terraforming Mars
    "Terraforming Mars 3D": 167791,
}
sys.path.insert(0, QUI)
from portale import dati_gioco
from db import conn


def norm(s):
    s = unicodedata.normalize("NFKD", s).encode("ascii", "ignore").decode().lower()
    return re.sub(r"[^a-z0-9]", "", s)


def foto_archivio():
    """{nome del gioco: [file, ...]} leggendo i nomi 'Titolo - 00b.jpg'.

    Dal 2026-09-07 le foto stanno in una sottocartella per gioco, chiamata
    "Nome (bggId)". Il nome del gioco resta quello del file, non quello della
    cartella: e' il file che l'archivio nomina, e i due a volte non coincidono
    (Honshu e Honshu' finiscono nella stessa cartella).
    """
    out = defaultdict(list)
    for cartella in sorted(os.listdir(ARCHIVIO)):
        piena = os.path.join(ARCHIVIO, cartella)
        if not os.path.isdir(piena):
            continue
        for f in sorted(os.listdir(piena)):
            m = re.match(r"^(.*) - (\d+[a-z]?)\.jpg$", f, re.I)
            if m:
                out[m.group(1)].append(os.path.join(cartella, f))
    return dict(out)


def main():
    portale = json.load(open(os.path.join(os.path.dirname(QUI), "dati", "giochi_portale.json"), encoding="utf-8"))
    archivio = foto_archivio()
    print(f"portale: {len(portale)} giochi | archivio: {len(archivio)} giochi fotografati")

    # tutti i nomi conosciuti di ogni gioco -> bgg_id
    alias, schede = {}, {}
    for nome, gid in sorted(portale.items(), key=lambda x: x[1]):
        d = dati_gioco(gid)
        if d.get("errore"):
            print("  errore su", nome, d["errore"]); continue
        schede[gid] = d
        for n in [nome, d.get("nome")] + list(d.get("altriNomi") or []):
            if n:
                alias.setdefault(norm(n), gid)

    indice = {a: alias[norm(a)] for a in archivio if norm(a) in alias}
    for nome, gid in ECCEZIONI.items():
        if gid is None:
            indice.pop(nome, None)
        elif nome in archivio:
            indice[nome] = gid
    print(f"abbinati: {len(indice)} | senza foto: {len(schede) - len(set(indice.values()))}"
          f" | foto senza scheda: {len(archivio) - len(indice)}")

    # Un gioco puo' essere fotografato sotto due nomi ("Terraforming Mars" e
    # "Terraforming Mars 3D"): le foto si sommano, se no vince l'ultimo nome letto
    # e il conteggio esce piu' basso del vero.
    foto_per_id = defaultdict(int)
    nome_per_id = {}
    for nome, gid in sorted(indice.items()):
        foto_per_id[gid] += len(archivio[nome])
        nome_per_id.setdefault(gid, nome)

    with conn() as c:
        for gid, nome in nome_per_id.items():
            d = schede[gid]
            c.execute("""
              INSERT INTO giochi (bgg_id, nome_archivio, nome_portale, n_foto, peso, etichetta_peso)
              VALUES (?,?,?,?,?,?)
              ON CONFLICT(bgg_id) DO UPDATE SET
                nome_archivio=excluded.nome_archivio, nome_portale=excluded.nome_portale,
                n_foto=excluded.n_foto, peso=excluded.peso, etichetta_peso=excluded.etichetta_peso
            """, (gid, nome, d.get("nome"), foto_per_id[gid],
                  d.get("peso"), d.get("pesoEtichetta")))
    json.dump(indice, open(os.path.join(os.path.dirname(QUI), "dati", "indice_nomi.json"), "w"),
              ensure_ascii=False, indent=0, sort_keys=True)
    print("indice salvato in indice_nomi.json")


if __name__ == "__main__":
    main()