#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from __future__ import annotations

import numpy as np

from suite19_common import import_suite17
from suite19_incremental import _stable_keys


ROOT = "/root/disk_3tb/earlywarning/30072026"

CACHE_DIR = (
    ROOT
    + "/results/cross_faculty_residual_moe/cache"
)

STRUCTURED_DIR = (
    ROOT
    + "/results/suite12_structured_cache"
)


def main():
    mods = import_suite17()

    pipe = mods[
        "suite17_pipeline"
    ]

    available = (
        pipe.discover_faculties(
            CACHE_DIR,
            1,
        )
    )

    faculties = (
        pipe.parse_faculties(
            "all",
            available,
        )
    )

    print(
        f"[FACULTIES] {len(faculties)}"
    )

    print("\n[LOAD F1]")

    h1, _, names1 = (
        pipe.load_fold_bundle(
            CACHE_DIR,
            STRUCTURED_DIR,
            faculties,
            1,
        )
    )

    print("\n[LOAD F2]")

    h2, _, names2 = (
        pipe.load_fold_bundle(
            CACHE_DIR,
            STRUCTURED_DIR,
            faculties,
            2,
        )
    )

    print("\n" + "=" * 100)
    print("SCHEMA")
    print("=" * 100)

    print(
        "F1 rows =",
        len(h1.y),
    )

    print(
        "F2 rows =",
        len(h2.y),
    )

    print(
        "F1 dim =",
        np.asarray(h1.flat).shape,
    )

    print(
        "F2 dim =",
        np.asarray(h2.flat).shape,
    )

    print(
        "feature count F1/F2 =",
        len(names1),
        len(names2),
    )

    names_equal = (
        list(names1)
        == list(names2)
    )

    print(
        "feature names/order equal =",
        names_equal,
    )

    if not names_equal:
        print(
            "\n[FEATURE NAME DIFFERENCES]"
        )

        mx = max(
            len(names1),
            len(names2),
        )

        shown = 0

        for i in range(mx):
            a = (
                names1[i]
                if i < len(names1)
                else "<MISSING>"
            )

            b = (
                names2[i]
                if i < len(names2)
                else "<MISSING>"
            )

            if a != b:
                print(
                    i,
                    repr(a),
                    "!=",
                    repr(b),
                )

                shown += 1

                if shown >= 30:
                    break

    # --------------------------------------------------------------
    # Rebuild exact previous -> current mapping.
    # --------------------------------------------------------------
    k1, scheme1 = _stable_keys(h1)
    k2, scheme2 = _stable_keys(h2)

    lookup2 = {
        key: i
        for i, key
        in enumerate(k2)
    }

    mapping = np.asarray(
        [
            lookup2.get(
                key,
                -1,
            )
            for key in k1
        ],
        dtype=int,
    )

    print("\n" + "=" * 100)
    print("ROW MAPPING")
    print("=" * 100)

    print(
        "scheme F1 =",
        scheme1,
    )

    print(
        "scheme F2 =",
        scheme2,
    )

    print(
        "mapped =",
        int(
            np.sum(mapping >= 0)
        ),
        "/",
        len(mapping),
    )

    assert np.all(
        mapping >= 0
    ), (
        "Some F1 rows cannot be "
        "mapped to F2."
    )

    # --------------------------------------------------------------
    # Check chronology-sensitive non-X fields.
    # --------------------------------------------------------------
    checks = {
        "y": (
            np.asarray(h1.y),
            np.asarray(h2.y)[mapping],
        ),
        "blocks": (
            np.asarray(h1.blocks),
            np.asarray(h2.blocks)[mapping],
        ),
        "faculty_idx": (
            np.asarray(
                h1.faculty_idx
            ),
            np.asarray(
                h2.faculty_idx
            )[mapping],
        ),
        "teacher": (
            np.asarray(
                h1.teacher
            ),
            np.asarray(
                h2.teacher
            )[mapping],
        ),
        "mechanism_targets": (
            np.asarray(
                h1.mechanism_targets
            ),
            np.asarray(
                h2.mechanism_targets
            )[mapping],
        ),
        "target_semester": (
            np.asarray(
                h1.target_semester
            ),
            np.asarray(
                h2.target_semester
            )[mapping],
        ),
    }

    print("\n" + "=" * 100)
    print("OTHER FIELDS")
    print("=" * 100)

    for name, (a, b) in checks.items():
        if (
            np.issubdtype(
                a.dtype,
                np.number,
            )
            and np.issubdtype(
                b.dtype,
                np.number,
            )
        ):
            equal = np.allclose(
                a,
                b,
                rtol=0,
                atol=0,
                equal_nan=True,
            )

        else:
            equal = np.array_equal(
                a.astype(str),
                b.astype(str),
            )

        print(
            f"{name:20s}",
            "EXACT" if equal else "DIFFERENT",
        )

    # --------------------------------------------------------------
    # Raw common feature matrix.
    # --------------------------------------------------------------
    A = np.asarray(
        h1.flat,
        dtype=np.float64,
    )

    B = np.asarray(
        h2.flat,
        dtype=np.float64,
    )[mapping]

    assert (
        A.shape == B.shape
    )

    both_nan = (
        np.isnan(A)
        & np.isnan(B)
    )

    exact = (
        (A == B)
        | both_nan
    )

    different = ~exact

    rows_different = (
        different.any(axis=1)
    )

    cols_different = (
        different.any(axis=0)
    )

    finite_pair = (
        np.isfinite(A)
        & np.isfinite(B)
    )

    finite_diff = np.zeros_like(
        A,
        dtype=np.float64,
    )

    finite_diff[
        finite_pair
    ] = np.abs(
        A[finite_pair]
        - B[finite_pair]
    )

    finite_changed = (
        finite_pair
        & different
    )

    vals = finite_diff[
        finite_changed
    ]

    print("\n" + "=" * 100)
    print("FLAT FEATURE DIFFERENCE SUMMARY")
    print("=" * 100)

    print(
        "shape =",
        A.shape,
    )

    print(
        "different entries =",
        int(different.sum()),
        "/",
        different.size,
        "=",
        float(
            different.mean()
        ),
    )

    print(
        "rows with >=1 difference =",
        int(
            rows_different.sum()
        ),
        "/",
        len(A),
        "=",
        float(
            rows_different.mean()
        ),
    )

    print(
        "columns with >=1 difference =",
        int(
            cols_different.sum()
        ),
        "/",
        A.shape[1],
    )

    if len(vals):
        print(
            "finite absolute diff:"
        )

        print(
            "  mean =",
            float(
                np.mean(vals)
            ),
        )

        print(
            "  median =",
            float(
                np.median(vals)
            ),
        )

        print(
            "  p90 =",
            float(
                np.quantile(
                    vals,
                    .90,
                )
            ),
        )

        print(
            "  p99 =",
            float(
                np.quantile(
                    vals,
                    .99,
                )
            ),
        )

        print(
            "  max =",
            float(
                np.max(vals)
            ),
        )

        for tol in (
            1e-10,
            1e-9,
            1e-8,
            1e-7,
            1e-6,
            1e-5,
            1e-4,
            1e-3,
            1e-2,
        ):
            print(
                f"  abs(diff) > {tol:g}:",
                int(
                    np.sum(
                        vals > tol
                    )
                ),
                "/",
                len(vals),
                "=",
                float(
                    np.mean(
                        vals > tol
                    )
                ),
            )

    # --------------------------------------------------------------
    # NaN / finite-state differences are especially important.
    # --------------------------------------------------------------
    state_diff = (
        np.isfinite(A)
        != np.isfinite(B)
    )

    print(
        "\nfinite/NaN state differences =",
        int(
            state_diff.sum()
        ),
    )

    # --------------------------------------------------------------
    # Column-level ranking.
    # --------------------------------------------------------------
    rows = []

    for j in range(
        A.shape[1]
    ):
        mask = different[:, j]

        if not np.any(mask):
            continue

        fm = (
            np.isfinite(A[:, j])
            & np.isfinite(B[:, j])
            & mask
        )

        dv = np.abs(
            A[fm, j]
            - B[fm, j]
        )

        rows.append(
            {
                "column_index": j,
                "feature": (
                    names1[j]
                    if j < len(names1)
                    else f"x{j}"
                ),
                "changed_rows":
                    int(
                        mask.sum()
                    ),
                "changed_fraction":
                    float(
                        mask.mean()
                    ),
                "finite_state_changes":
                    int(
                        np.sum(
                            np.isfinite(
                                A[:, j]
                            )
                            != np.isfinite(
                                B[:, j]
                            )
                        )
                    ),
                "mean_abs_diff": (
                    float(
                        np.mean(dv)
                    )
                    if len(dv)
                    else np.nan
                ),
                "max_abs_diff": (
                    float(
                        np.max(dv)
                    )
                    if len(dv)
                    else np.nan
                ),
            }
        )

    rows.sort(
        key=lambda r: (
            r[
                "changed_fraction"
            ],
            0.0
            if np.isnan(
                r["max_abs_diff"]
            )
            else r[
                "max_abs_diff"
            ],
        ),
        reverse=True,
    )

    print("\n" + "=" * 100)
    print("TOP CHANGED FEATURES")
    print("=" * 100)

    for r in rows[:40]:
        print(
            f"{r['column_index']:3d} "
            f"{r['feature'][:55]:55s} "
            f"changed="
            f"{r['changed_rows']:7d} "
            f"({r['changed_fraction']:.2%}) "
            f"state="
            f"{r['finite_state_changes']:6d} "
            f"meanAbs="
            f"{r['mean_abs_diff']:.8g} "
            f"maxAbs="
            f"{r['max_abs_diff']:.8g}"
        )

    print("\n" + "=" * 100)
    print("BLOCK-LEVEL DIFFERENCES")
    print("=" * 100)

    old_blocks = np.asarray(
        h1.blocks,
        float,
    )

    for block in sorted(
        v
        for v in np.unique(
            old_blocks
        )
        if np.isfinite(v)
    ):
        m = (
            old_blocks == block
        )

        dm = different[m]

        print(
            f"block={block:g} "
            f"rows={int(m.sum()):7d} "
            f"rows_changed="
            f"{int(dm.any(axis=1).sum()):7d} "
            f"fraction="
            f"{float(dm.any(axis=1).mean()):.2%} "
            f"entries_changed="
            f"{int(dm.sum()):9d}"
        )


if __name__ == "__main__":
    main()