"""Restrict Joomla extension-data migration to component-owned domains.

``dbmesh_policy_patch`` intentionally made the old catch-all extension phase
conservative, but an empty target table could still be treated as client data
simply because it was not otherwise classified.  That is still too broad.

The migration rule is now:

    component -> owns client data tables
    plugin/module/template/package -> runtime/config/dependency branch only

A physical table that cannot be assigned to an installed source component is
quarantined.  Component tables that do not yet exist on the target stay behind
until the target component is installed.  The underlying row copier, factory
maps, id remaps and semantic merge rules remain unchanged.
"""
from __future__ import annotations

from . import component_data_domains as domains
from . import dbmesh as d
from . import dbmesh_policy_patch as policy

_INSTALLED = False
_PRIOR_CLASSIFY = policy.classify_table
_PRIOR_PHASE_TABLES = policy.phase_tables
_PRIOR_PLAN = d.plan
_PRIOR_MIGRATE = d.migrate

CORE_CLAIMED = {
    "usergroups", "viewlevels", "users", "user_usergroup_map",
    "template_styles", "categories", "content", "content_frontpage",
    "menu_types", "menu", "modules", "modules_menu", "fields_groups",
    "fields", "fields_values", "tags", "contentitem_tag_map",
}


def _owner_shape(owner: dict | None) -> dict:
    if not owner:
        return {}
    return {
        "component": owner.get("element") or "",
        "component_name": owner.get("name") or owner.get("element") or "",
        "component_token": owner.get("token") or "",
        "component_version": owner.get("version") or "",
        "component_core": bool(owner.get("core")),
    }


def classify_table(sconn, dconn, sp: str, dp: str, table: str, *, phase: str = "extensions") -> dict:
    """Policy classification with component ownership as the extension gate."""
    if phase != "extensions" or table in CORE_CLAIMED:
        return _PRIOR_CLASSIFY(sconn, dconn, sp, dp, table, phase=phase)

    stabs, dtabs = d.tables(sconn, sp), d.tables(dconn, dp)
    src_rows = d.row_count(sconn, sp + table) if table in stabs else 0
    dst_rows = d.row_count(dconn, dp + table) if table in dtabs else 0

    # Keep the semantic distinction visible even though the lower safety patch
    # also places regenerate tables in NEVER_COPY to stop old callers copying
    # them.  They are rebuildable state, not target factory catalogues.
    if table in policy.REGENERATE:
        return {"class": "regenerate", "source_rows": src_rows, "target_rows": dst_rows}
    if table in policy.FACTORY or table in d.NEVER_COPY:
        return _PRIOR_CLASSIFY(sconn, dconn, sp, dp, table, phase=phase)

    if table not in stabs:
        return _PRIOR_CLASSIFY(sconn, dconn, sp, dp, table, phase=phase)

    component = domains.owner(sconn, sp, table)
    if component is None:
        return {
            "class": "quarantine",
            "source_rows": src_rows,
            "target_rows": dst_rows,
            "reason": "table is not owned by an installed Joomla component; plugins/modules/packages are not data owners",
            "component": "",
        }

    result = dict(_PRIOR_CLASSIFY(sconn, dconn, sp, dp, table, phase=phase))
    result.update(_owner_shape(component))
    if result.get("class") == "missing_target":
        result["reason"] = (
            f"{component.get('element')} owns this data, but the component table does not exist on the target; "
            "install/bridge the target component before migrating its data"
        )
    elif result.get("class") == "quarantine":
        result["reason"] = result.get("reason") or (
            f"{component.get('element')} owns this table, but the target already contains rows and no safe semantic merge key is known"
        )
    return result


def phase_tables(sconn, dconn, sp, dp, phase, exclude=()):
    """Reuse the policy phase selector with the stricter classifier installed."""
    return _PRIOR_PHASE_TABLES(sconn, dconn, sp, dp, phase, exclude)


def _component_map(sconn, dconn, sp: str, dp: str) -> dict:
    stabs, dtabs = d.tables(sconn, sp), d.tables(dconn, dp)
    rows = domains.domains(
        sconn, dconn, sp, dp,
        source_tables=stabs - CORE_CLAIMED,
        target_tables=dtabs - CORE_CLAIMED,
    )
    out = []
    for row in rows:
        tables = []
        for table in row.get("source_tables") or []:
            decision = classify_table(sconn, dconn, sp, dp, table, phase="extensions")
            tables.append({"table": table, **decision})
        item = {**row, "tables": tables}
        item["rows"] = sum(t.get("source_rows", 0) for t in tables
                           if t.get("class") not in {"target_factory", "regenerate"})
        item["migratable_tables"] = [t["table"] for t in tables
                                     if t.get("class") in {"client_entity", "semantic_merge"}]
        item["blocked_tables"] = [t["table"] for t in tables
                                  if t.get("class") in {"missing_target", "quarantine"}]
        out.append(item)
    return {
        "rule": "components own data; plugin/module/template/package members are runtime dependencies only",
        "domains": out,
        "components": len(out),
        "tables": sum(len(x.get("tables") or []) for x in out),
        "rows": sum(x.get("rows", 0) for x in out),
    }


def plan(src, dst, resolve, exclude=()):
    """Classified plan plus explicit component data domains."""
    result = _PRIOR_PLAN(src, dst, resolve, exclude)
    sconn, sp, _ = resolve(src)
    dconn, dp, _ = resolve(dst)
    try:
        result["component_data"] = _component_map(sconn, dconn, sp, dp)
        # The prior planner already sees our patched classifier through the
        # policy module, so its quarantined bucket includes unowned tables.
        result["unowned_tables"] = [
            x for x in result.get("quarantined", []) if not x.get("component")
        ]
    finally:
        sconn.close(); dconn.close()
    return result


def migrate(src, dst, phases=d.PHASES, *, live=False, urls=True, resolve,
            url_override=None, on_progress=None, on_conflict="reassign", exclude=()):
    """Run the existing migrator while exposing component-data semantics."""
    sconn, sp, _ = resolve(src)
    dconn, dp, _ = resolve(dst)
    try:
        component_map = _component_map(sconn, dconn, sp, dp)
    finally:
        sconn.close(); dconn.close()

    def progress(event):
        ev = dict(event)
        if ev.get("phase") == "extensions":
            ev["phase"] = "component data"
        if on_progress:
            on_progress(ev)

    report = _PRIOR_MIGRATE(
        src, dst, phases,
        live=live, urls=urls, resolve=resolve, url_override=url_override,
        on_progress=progress, on_conflict=on_conflict, exclude=exclude,
    )
    report["component_data"] = component_map
    # Keep the internal phase key for backward compatibility while naming the
    # user-facing meaning explicitly.
    report["component_data_phase"] = report.get("phases", {}).get("extensions", {})
    return report


def install() -> None:
    global _INSTALLED
    if _INSTALLED:
        return
    # dbmesh_policy_patch's plan/migrate resolve these globals at runtime, so
    # replacing them here narrows every existing MPort/Studio entry point too.
    policy.classify_table = classify_table
    policy.phase_tables = phase_tables
    d.classify_table = classify_table
    d.phase_tables = phase_tables
    d.plan = plan
    d.migrate = migrate
    d.COMPONENT_DATA_DOMAINS = domains
    _INSTALLED = True