#!/usr/bin/env python3
# © 2021-2026 TechnoLibre (http://www.technolibre.ca)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)

"""Les index que la 17 a créés en double et n'a jamais retirés.

Odoo 17 a changé sa convention de nommage : `make_index_name` rend
désormais `{table}__{colonne}_index` — deux soulignés — là où les
versions d'avant écrivaient `{table}_{colonne}_index`. Le nouvel index
est créé, l'ancien reste. Mesuré sur une chaîne 12 → 18 :

    test_neutralize (12)   1 paire
    _16                    3
    _17                  370      ← la bascule
    _18                  365

Inerte à la lecture, coûteux à l'écriture : chaque INSERT et chaque
UPDATE sur ces tables entretient deux arbres B identiques. Ici 9,6 Mo et
une base vide ; sur une production le coût croît avec les lignes. C'est
le seul défaut de cette famille qui empire tout seul.

Ce que l'outil REFUSE de toucher, et pourquoi :

  adossé à une contrainte   PostgreSQL le recréerait, ou la contrainte
                            tomberait avec lui.
  clé primaire              même raison, en pire.
  index partiel ou calculé  `indpred` / `indexprs` : deux index sur les
                            mêmes colonnes n'y font pas le même travail.
  méthode différente        un gin et un btree sur la même colonne ne se
                            remplacent pas.
  convention ambiguë        aucun des deux noms — ou les deux — suit la
                            convention de la cible : on ne devine pas
                            lequel Odoo recréera.

Lecture seule par défaut. `--apply` supprime, puis RELIT pour vérifier.
"""

import argparse
import json
import os
import subprocess
import sys

sys.path.append(
    os.path.normpath(os.path.join(os.path.dirname(__file__), "..", "..", ".."))
)

try:
    from script.todo.todo_i18n import t
except Exception:  # pragma: no cover - repli si i18n indisponible

    def t(key: str) -> str:
        return key


# Les paires strictement identiques : même table, mêmes colonnes, même
# unicité, même méthode d'accès, mêmes classes d'opérateurs. Sans un seul
# de ces critères on comparerait des index qui ne font pas le même travail.
DETECTION = """
WITH idx AS (
  SELECT i.indexrelid,
         i.indrelid,
         i.indkey::text        AS cols,
         i.indclass::text      AS classes,
         i.indisunique         AS unique_,
         am.amname             AS methode,
         c.relname             AS nom,
         t.relname             AS tbl,
         pg_relation_size(i.indexrelid) AS taille,
         EXISTS (SELECT 1 FROM pg_constraint k
                 WHERE k.conindid = i.indexrelid) AS contrainte
  FROM pg_index i
  JOIN pg_class c   ON c.oid = i.indexrelid
  JOIN pg_class t   ON t.oid = i.indrelid
  JOIN pg_am am     ON am.oid = c.relam
  JOIN pg_namespace n ON n.oid = c.relnamespace
  WHERE n.nspname = 'public'
    AND i.indpred IS NULL
    AND i.indexprs IS NULL
    AND NOT i.indisprimary
    AND i.indisvalid
)
SELECT coalesce(json_agg(json_build_object(
         'table', a.tbl,
         'a', a.nom, 'a_size', a.taille, 'a_ctr', a.contrainte,
         'b', b.nom, 'b_size', b.taille, 'b_ctr', b.contrainte
       )), '[]')
FROM idx a
JOIN idx b
  ON a.indrelid = b.indrelid
 AND a.cols     = b.cols
 AND a.classes  = b.classes
 AND a.unique_  = b.unique_
 AND a.methode  = b.methode
 AND a.indexrelid < b.indexrelid
"""


def run_psql(database, sql, read_only=True):
    """Interroger la base. None si elle ne répond pas.

    Lecture seule garantie par le SERVEUR : une suppression qui se trompe
    de base doit être refusée par PostgreSQL, pas par une relecture.
    """
    env = os.environ.copy()
    if read_only:
        env["PGOPTIONS"] = "-c default_transaction_read_only=on"
    env["PSQLRC"] = ""
    done = subprocess.run(
        ["psql", "-X", "-w", "-d", database, "-tA", "-c", sql],
        capture_output=True,
        text=True,
        env=env,
    )
    if done.returncode:
        return None
    return done.stdout


def modern_name(table, nom):
    """Ce nom suit-il la convention de la cible ?

    `make_index_name` d'Odoo 18 rend `{table}__{colonne}_index`. Un nom
    trop long est tronqué et suffixé d'un condensat ; celui-là ne se
    reconnaît pas, et l'on préfère s'abstenir que deviner.
    """
    return nom.startswith(f"{table}__")


def classify(paire):
    """(verdict, à garder, à supprimer).

    « safe » exige que l'un des deux noms — et un seul — suive la
    convention : c'est le seul cas où l'on sait lequel Odoo recréera.
    """
    if paire["a_ctr"] or paire["b_ctr"]:
        return "constraint", None, None
    table = paire["table"]
    a_moderne = modern_name(table, paire["a"])
    b_moderne = modern_name(table, paire["b"])
    if a_moderne == b_moderne:
        return "ambiguous", None, None
    if a_moderne:
        return "safe", paire["a"], paire["b"]
    return "safe", paire["b"], paire["a"]


def find(database):
    """[(verdict, table, garder, supprimer, octets)]. None si base muette."""
    sortie = run_psql(database, DETECTION)
    if sortie is None:
        return None
    try:
        paires = json.loads(sortie.strip() or "[]")
    except ValueError:
        return None
    lst = []
    for paire in paires:
        verdict, garder, supprimer = classify(paire)
        octets = (
            paire["b_size"] if supprimer == paire["b"] else paire["a_size"]
        )
        lst.append(
            (verdict, paire["table"], garder, supprimer, octets or 0, paire)
        )
    return sorted(lst, key=lambda x: (x[0], x[1], x[3] or ""))


def safe_only(lst):
    return [item for item in lst if item[0] == "safe"]


def drop_sql(lst):
    """Les suppressions, une par ligne. Vide s'il n'y a rien de sûr.

    `IF EXISTS` : deux paires peuvent nommer le même index à supprimer
    quand une table en porte trois copies, et la deuxième passe ne doit
    pas échouer sur ce qui vient de partir.
    """
    noms = []
    for _v, _tbl, _garder, supprimer, _o, _p in safe_only(lst):
        if supprimer and supprimer not in noms:
            noms.append(supprimer)
    return "\n".join(f'DROP INDEX IF EXISTS "{nom}";' for nom in noms)


def render(lst, applique=False):
    if not lst:
        return [f"✅ {t('No duplicate index.')}"]
    surs = safe_only(lst)
    octets = sum(item[4] for item in surs)
    lignes = [
        f"🗂  {len(lst)} {t('duplicate index pair(s)')}"
        f" — {len(surs)} {t('safe to drop')}"
        f" ({octets // 1024} kB)",
        "",
    ]
    for _v, table, garder, supprimer, taille, _p in surs[:20]:
        lignes.append(
            f"   {table} : {t('drop')} {supprimer}"
            f"  ({taille // 1024} kB), {t('keep')} {garder}"
        )
    if len(surs) > 20:
        lignes.append(f"   … {len(surs) - 20} {t('more')}")
    for genre, texte in (
        ("constraint", t("backed by a constraint — left alone")),
        ("ambiguous", t("neither name follows the convention — your call")),
    ):
        lot = [item for item in lst if item[0] == genre]
        if not lot:
            continue
        lignes.append("")
        lignes.append(f"   ⚠ {len(lot)} {texte}")
        for _v, table, _g, _s, _o, paire in lot[:6]:
            lignes.append(f"      {table} : {paire['a']}  ↔  {paire['b']}")
    if not applique and surs:
        lignes.append("")
        lignes.append(f"   {t('Use --apply to drop them.')}")
    return lignes


def main(argv=None):
    parser = argparse.ArgumentParser(
        description=(
            "Report the duplicate indexes Odoo 17 left behind when it"
            " renamed its index convention, and optionally drop them."
        )
    )
    parser.add_argument("-d", "--database", required=True)
    parser.add_argument(
        "--apply",
        action="store_true",
        help="actually drop the safe duplicates (default: report only)",
    )
    parser.add_argument("--json", action="store_true", help="machine output")
    config = parser.parse_args(argv)

    lst = find(config.database)
    if lst is None:
        print(f"❌ {t('Cannot read the database: ')}{config.database}")
        return 2
    if config.json:
        print(
            json.dumps(
                [
                    {
                        "verdict": v,
                        "table": tbl,
                        "keep": g,
                        "drop": s,
                        "bytes": o,
                    }
                    for v, tbl, g, s, o, _p in lst
                ],
                indent=2,
                sort_keys=True,
            )
        )
        return 1 if lst else 0
    if not lst:
        print("\n".join(render(lst)))
        return 0
    if not config.apply:
        print("\n".join(render(lst)))
        return 1

    sql = drop_sql(lst)
    if sql and run_psql(config.database, sql, read_only=False) is None:
        print(f"❌ {t('The correction failed.')}")
        return 2
    # RELIRE : annoncer « supprimé » sans regarder ferait croire le
    # problème réglé alors qu'un verrou a pu refuser la suppression.
    apres = find(config.database)
    if apres is None:
        print(f"❌ {t('Cannot read the database: ')}{config.database}")
        return 2
    if safe_only(apres):
        print("\n".join(render(apres, applique=True)))
        print(f"⚠️  {t('Some duplicates are still there.')}")
        return 1
    print("\n".join(render(apres, applique=True)))
    print(f"✅ {t('Duplicate indexes dropped.')}")
    return 0


if __name__ == "__main__":
    sys.exit(main())