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

"""Find the website COW copies that have gone stale, and reset them.

The problem
-----------
A COW copy freezes the module view it was copied from. Version after version,
the MODULE view is modernised while the copy is not — it is user data, nothing
rewrites it. The copy keeps working right up to the moment a CHILD view does an
``xpath`` onto something the module added, renamed or re-anchored::

    Element '<xpath expr="//head/script[@id='web.layout.odooscript']">'
    cannot be located in parent view

Observed on ``web.layout`` during 14.0 -> 15.0: the copy dated from 12.0, where
the script tag had no ``id`` and QWeb still said ``t-raw``. It had survived
until then only because the 14.0 module xpath carried a fallback
(``//head/script[@id='…'] | //head/script[last()]``) that 15.0 removed.

What this checks
----------------
Not a heuristic on deprecated syntax, and not an absolute one either: the
DRIFT between a copy and its module twin. For every active child of a COW
copy, each ``xpath`` expression is resolved twice — against the module twin
and against the copy. An expression the twin can satisfy and the copy cannot
is an anchor the copy has lost.

The comparison has to be differential. Odoo resolves an xpath against the
COMBINED arch of the whole inheritance chain, so « does not resolve in this
parent » proves nothing on its own — a child of ``website.layout`` targets
``//header``, which comes from an ancestor.

When it bites
-------------
A reported copy is not necessarily failing right now. Odoo re-validates a COW
copy when its module twin is REWRITTEN — which is what a version bump does —
or when the page is rendered for that website. So a finding is a breakage
already present in the data, waiting for the next bump to surface it. That is
precisely when it is cheap to fix.

Resetting
---------
``--reset`` copies the MODULE arch over the stale copy. The previous arch is
always written to a backup file first, and the diff is printed, because a copy
can hold a genuine customisation — one line among fifty of drift. Read the
diff, reset, then re-apply what mattered as an INHERITING view rather than a
full copy, so the next version bump cannot make it stale again.

Plain psql on purpose: this runs on databases whose Odoo registry does not
load, which is precisely when it is needed.
"""

import argparse
import datetime
import difflib
import json
import os
import re
import subprocess
import sys


def run_psql(database, sql):
    """Run a statement and return stdout, raising on failure."""
    result = subprocess.run(
        ["psql", "-d", database, "-tAc", sql],
        capture_output=True,
        text=True,
    )
    if result.returncode:
        raise RuntimeError(
            f"Query failed on '{database}': {result.stderr.strip()}"
        )
    return result.stdout


def normalise_arch(value):
    """The arch as a string, whatever the column type.

    Odoo stores ``arch_db`` as text up to 15.0 and as jsonb (one entry per
    language) from 16.0. Casting to text gives ``{"en_US": "<t …"}`` in the
    second case, so unwrap it — the structure is the same in every language,
    and the structure is all this tool looks at.
    """
    if not isinstance(value, str):
        return "" if value is None else str(value)
    text = value.strip()
    if text.startswith("{") and '"' in text:
        try:
            data = json.loads(text)
        except ValueError:
            return value
        if isinstance(data, dict) and data:
            for lang in ("en_US", *sorted(data)):
                if lang in data and isinstance(data[lang], str):
                    return data[lang]
    return value


def fetch_views(database):
    """Every view that matters: COW copies, their module twin, their children.

    One query rather than one per view — these databases hold thousands of
    views. The result comes back as JSON: an arch is multi-line XML, so any
    line-based format would need a record separator the data could forge.
    """
    raw = run_psql(
        database,
        "SELECT COALESCE(json_agg(json_build_object("
        "'id', id, 'key', COALESCE(key, ''), 'inherit_id', inherit_id,"
        "'website_id', website_id, 'active', active,"
        "'arch', arch_db::text))::text, '[]')"
        " FROM ir_ui_view WHERE arch_db IS NOT NULL",
    )
    rows = {}
    for item in json.loads(raw.strip() or "[]"):
        item["arch"] = normalise_arch(item.get("arch"))
        rows[item["id"]] = item
    return rows


XPATH_RE = re.compile(r"<xpath\b[^>]*\bexpr=([\"'])(.*?)\1", re.S)


def child_xpaths(arch):
    """The xpath expressions a view applies to its parent."""
    return [match.group(2) for match in XPATH_RE.finditer(arch)]


def require_lxml():
    """The XPath engine, or a loud failure.

    Never degrade to « everything resolves » when lxml is missing: a checker
    that cannot check must not answer « all clean ». Odoo's own venvs all ship
    lxml; the bare system python3 usually does not.
    """
    try:
        from lxml import etree

        return etree
    except ImportError:
        sys.exit(
            "❌ lxml is required to resolve the xpath expressions.\n"
            "   Run this with an interpreter that has it, e.g.\n"
            "   ./.venv.erplibre/bin/python3 " + os.path.relpath(__file__)
        )


def resolve(etree, arch, expr):
    """True if `expr` matches something in `arch`.

    An arch that does not parse, or an expression lxml cannot evaluate, counts
    as resolvable: this tool reports views that will CERTAINLY break, and must
    never invent a failure it cannot substantiate.
    """
    try:
        tree = etree.fromstring(arch.encode("utf-8"))
    except etree.XMLSyntaxError:
        return True
    try:
        return bool(tree.xpath(expr))
    except etree.XPathEvalError:
        return True


def analyse(database):
    """[(copy, module_twin, [(child_id, failing_expr), ...])] — the COW copies
    that have DRIFTED away from their module twin.

    The test is differential, and it has to be. Odoo resolves an xpath against
    the COMBINED arch of the whole inheritance chain, not against the parent's
    own arch, so « does not resolve here » proves nothing on its own: a child
    of ``website.layout`` legitimately targets ``//header``, which comes from
    an ancestor. Comparing the copy with its module twin removes that whole
    class of noise:

        resolves in the module twin, not in the copy  -> the copy lost an
                                                         anchor: real drift
        resolves in neither                           -> the anchor lives
                                                         further up the chain
        resolves in both                              -> nothing to see

    Inactive children are skipped: Odoo never applies them, so they cannot
    break a load.
    """
    etree = require_lxml()
    views = fetch_views(database)
    module_by_key = {
        v["key"]: v
        for v in views.values()
        if v["website_id"] is None and v["key"]
    }
    children = {}
    for view in views.values():
        if view["inherit_id"]:
            children.setdefault(view["inherit_id"], []).append(view)

    findings = []
    for view in sorted(views.values(), key=lambda v: v["id"]):
        twin = module_by_key.get(view["key"])
        if view["website_id"] is None or twin is None:
            continue
        broken = []
        for child in children.get(view["id"], []):
            if not child.get("active", True):
                continue
            for expr in child_xpaths(child["arch"]):
                if resolve(etree, twin["arch"], expr) and not resolve(
                    etree, view["arch"], expr
                ):
                    broken.append((child["id"], expr))
        if broken:
            findings.append((view, twin, broken))
    return findings


def show_diff(module_view, cow_view):
    """Module arch vs copy: what the copy would gain and lose on a reset."""
    diff = difflib.unified_diff(
        module_view["arch"].splitlines(),
        cow_view["arch"].splitlines(),
        fromfile=f"module id={module_view['id']}",
        tofile=f"cow id={cow_view['id']}",
        lineterm="",
    )
    for line in diff:
        print(f"    {line}")


def backup(database, cow_view, directory):
    """Store the arch about to be replaced, and return the file path."""
    os.makedirs(directory, exist_ok=True)
    stamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    path = os.path.join(
        directory, f"{cow_view['key']}_{cow_view['id']}_{stamp}.json"
    )
    with open(path, "w", encoding="utf-8") as fh:
        json.dump(
            {
                "database": database,
                "id": cow_view["id"],
                "key": cow_view["key"],
                "website_id": cow_view["website_id"],
                "saved_at": stamp,
                "arch_db": cow_view["arch"],
            },
            fh,
            indent=2,
            ensure_ascii=False,
        )
    return path


def reset(database, cow_view, module_view):
    """Copy the module arch over the stale copy. Returns rows updated."""
    sql = (
        "UPDATE ir_ui_view c SET arch_db = m.arch_db "
        "FROM ir_ui_view m "
        f"WHERE c.id = {cow_view['id']} AND m.id = {module_view['id']}"
    )
    run_psql(database, sql)
    return 1


def main():
    parser = argparse.ArgumentParser(
        description=(
            "Report the website COW copies whose children can no longer be"
            " applied, and optionally reset them onto the module view."
        )
    )
    parser.add_argument("-d", "--database", required=True)
    parser.add_argument(
        "--reset",
        metavar="KEY",
        action="append",
        default=[],
        help="reset this key onto its module view ('all' for every finding)",
    )
    parser.add_argument(
        "--apply",
        action="store_true",
        help="really write; without it --reset only shows what it would do",
    )
    parser.add_argument(
        "--backup-dir",
        default=None,
        help="where the replaced arch is saved"
        " (default private/odoo/migration/<db>/cow_reset)",
    )
    config = parser.parse_args()

    findings = analyse(config.database)
    if not findings:
        print("✅ No COW copy has drifted from its module view.")
        return 0

    print(
        f"⚠️  {len(findings)} COW copy(ies) drifted from their module view"
        f" in {config.database}"
    )
    print(
        "   Odoo surfaces this when the module view is rewritten (a version"
        " bump) or when the page is rendered.\n"
    )
    for cow_view, module_view, broken in findings:
        twin = (
            f"module id={module_view['id']}"
            if module_view
            else "NO module view with this key"
        )
        print(
            f"  id={cow_view['id']} key={cow_view['key']}"
            f" website_id={cow_view['website_id']}  [{twin}]"
        )
        for child_id, expr in broken:
            print(f"      child {child_id} cannot apply: {expr}")
        if module_view:
            show_diff(module_view, cow_view)
        print()

    if not config.reset:
        print(
            "Nothing changed. Re-run with --reset <key> --apply to reset a"
            " copy onto its module view."
        )
        return 1

    wanted = set(config.reset)
    directory = config.backup_dir or os.path.join(
        "private", "odoo", "migration", config.database, "cow_reset"
    )
    done = 0
    for cow_view, module_view, _broken in findings:
        if "all" not in wanted and cow_view["key"] not in wanted:
            continue
        if not module_view:
            print(
                f"⏭  {cow_view['key']}: no module view to reset onto,"
                " skipped."
            )
            continue
        if not config.apply:
            print(
                f"[dry-run] would reset id={cow_view['id']}"
                f" ({cow_view['key']}) onto id={module_view['id']}"
            )
            continue
        path = backup(config.database, cow_view, directory)
        reset(config.database, cow_view, module_view)
        done += 1
        print(f"✅ reset id={cow_view['id']} ({cow_view['key']})")
        print(f"   previous arch saved to {path}")
    if config.apply and done:
        print(
            f"\n{done} copy(ies) reset. Re-apply any real customisation as an"
            " INHERITING view, not a copy, so it cannot go stale again."
        )
    return 0


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