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

from __future__ import annotations

import numpy as np

from suite19_common import (
    PrefixPreprocessor,
    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 stats(a, b):
    a = np.asarray(a, np.float32)
    b = np.asarray(b, np.float32)

    if a.shape != b.shape:
        return {
            "shape_equal": False,
        }

    d = np.abs(
        a.astype(np.float64)
        - b.astype(np.float64)
    )

    return {
        "shape_equal": True,

        "exact": bool(
            np.array_equal(a, b)
        ),

        "mean_abs": float(
            np.mean(d)
        ),

        "p99_abs": float(
            np.quantile(d, .99)
        ),

        "max_abs": float(
            np.max(d)
        ),

        "gt_1e7": float(
            np.mean(d > 1e-7)
        ),

        "gt_1e6": float(
            np.mean(d > 1e-6)
        ),

        "gt_1e5": float(
            np.mean(d > 1e-5)
        ),

        "gt_1e4": float(
            np.mean(d > 1e-4)
        ),
    }


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] "
        f"{len(faculties)}"
    )

    print("[LOAD F1]")

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

    print("[LOAD F2]")

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

    assert (
        list(names1)
        == list(names2)
    )

    # --------------------------------------------------------------
    # Exact F1 -> F2 row mapping.
    # --------------------------------------------------------------
    k1, _ = _stable_keys(h1)
    k2, _ = _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,
    )

    assert np.all(
        mapping >= 0
    )

    print(
        "[MAPPING] "
        f"{len(mapping):,}/"
        f"{len(mapping):,}"
    )

    A = np.asarray(
        h1.flat,
        np.float32,
    )

    B = np.asarray(
        h2.flat,
        np.float32,
    )

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

    b2 = np.asarray(
        h2.blocks,
        float,
    )

    # --------------------------------------------------------------
    # Committee / teacher change.
    # --------------------------------------------------------------
    T1 = np.asarray(
        h1.teacher,
        np.float32,
    )

    T2 = np.asarray(
        h2.teacher,
        np.float32,
    )[mapping]

    q1 = T1.mean(axis=1)
    q2 = T2.mean(axis=1)

    print()
    print("=" * 110)
    print("TEACHER / COMMITTEE DIFFERENCE")
    print("=" * 110)

    ts = stats(T1, T2)
    qs = stats(q1, q2)

    print(
        "teacher:",
        ts,
    )

    print(
        "committee mean:",
        qs,
    )

    # --------------------------------------------------------------
    # Actual Suite19 PrefixPreprocessor invariance.
    #
    # These are the matrices the representation encoders actually see.
    # --------------------------------------------------------------
    print()
    print("=" * 110)
    print(
        "PREFIX-PREPROCESSED "
        "ENCODER INPUT INVARIANCE"
    )
    print("=" * 110)

    legal_blocks = []

    for qb in sorted(
        v
        for v in np.unique(b1)
        if np.isfinite(v)
    ):
        tr1 = np.where(
            b1 < qb
        )[0]

        qi1 = np.where(
            b1 == qb
        )[0]

        # Same F1 rows mapped into F2.
        tr2 = mapping[tr1]
        qi2 = mapping[qi1]

        # Verify F2 has not inserted new earlier rows
        # that would alter this temporal training prefix.
        actual_tr2 = np.where(
            b2 < qb
        )[0]

        actual_qi2 = np.where(
            b2 == qb
        )[0]

        train_population_same = (
            len(tr2)
            == len(actual_tr2)
            and set(
                tr2.tolist()
            )
            == set(
                actual_tr2.tolist()
            )
        )

        query_population_same = (
            len(qi2)
            == len(actual_qi2)
            and set(
                qi2.tolist()
            )
            == set(
                actual_qi2.tolist()
            )
        )

        # Row order also matters for reproducible
        # stochastic training and subsampling.
        train_order_same = bool(
            np.array_equal(
                tr2,
                actual_tr2,
            )
        )

        query_order_same = bool(
            np.array_equal(
                qi2,
                actual_qi2,
            )
        )

        if not (
            train_population_same
            and query_population_same
        ):
            print(
                f"block={qb:g} "
                "POPULATION DIFFERENT "
                f"train_same="
                f"{train_population_same} "
                f"query_same="
                f"{query_population_same}"
            )
            continue

        if len(tr1) == 0:
            print(
                f"block={qb:g} "
                "no prior rows"
            )
            continue

        prep1 = (
            PrefixPreprocessor(
                12.0
            )
            .fit(
                A[tr1]
            )
        )

        prep2 = (
            PrefixPreprocessor(
                12.0
            )
            .fit(
                B[tr2]
            )
        )

        ztr1 = prep1.transform(
            A[tr1]
        )

        ztr2 = prep2.transform(
            B[tr2]
        )

        zq1 = prep1.transform(
            A[qi1]
        )

        zq2 = prep2.transform(
            B[qi2]
        )

        train_stats = stats(
            ztr1,
            ztr2,
        )

        query_stats = stats(
            zq1,
            zq2,
        )

        # Faculty / y are also encoder inputs through
        # weighting and must remain aligned.
        y_same = bool(
            np.array_equal(
                np.asarray(
                    h1.y
                )[tr1],
                np.asarray(
                    h2.y
                )[tr2],
            )
        )

        fac_same = bool(
            np.array_equal(
                np.asarray(
                    h1.faculty_idx
                )[tr1],
                np.asarray(
                    h2.faculty_idx
                )[tr2],
            )
        )

        print()
        print(
            f"block={qb:g}"
        )

        print(
            f"  train rows="
            f"{len(tr1):,} "
            f"query rows="
            f"{len(qi1):,}"
        )

        print(
            "  population:"
            f" train={train_population_same}"
            f" query={query_population_same}"
        )

        print(
            "  order:"
            f" train={train_order_same}"
            f" query={query_order_same}"
        )

        print(
            f"  y_same={y_same} "
            f"faculty_same={fac_same}"
        )

        print(
            "  TRAIN transformed:",
            train_stats,
        )

        print(
            "  QUERY transformed:",
            query_stats,
        )

        legal_blocks.append(
            {
                "block": qb,
                "train_exact":
                    train_stats.get(
                        "exact",
                        False,
                    ),
                "query_exact":
                    query_stats.get(
                        "exact",
                        False,
                    ),
                "train_max":
                    train_stats.get(
                        "max_abs",
                        np.nan,
                    ),
                "query_max":
                    query_stats.get(
                        "max_abs",
                        np.nan,
                    ),
                "train_order":
                    train_order_same,
                "query_order":
                    query_order_same,
            }
        )

    print()
    print("=" * 110)
    print("FINAL PREFIX-INVARIANCE SUMMARY")
    print("=" * 110)

    if not legal_blocks:
        print(
            "No comparable blocks."
        )
        return

    exact = [
        r
        for r in legal_blocks
        if (
            r["train_exact"]
            and r["query_exact"]
            and r["train_order"]
            and r["query_order"]
        )
    ]

    print(
        "comparable blocks =",
        len(legal_blocks),
    )

    print(
        "bitwise-exact encoder-input blocks =",
        len(exact),
        "/",
        len(legal_blocks),
    )

    print(
        "worst transformed train max abs diff =",
        max(
            r["train_max"]
            for r in legal_blocks
        ),
    )

    print(
        "worst transformed query max abs diff =",
        max(
            r["query_max"]
            for r in legal_blocks
        ),
    )

    if (
        len(exact)
        == len(legal_blocks)
    ):
        print()
        print(
            "[PASS] Prefix preprocessing fully "
            "cancels the fold-specific flat changes."
        )
        print(
            "Cross-fold representation reuse can "
            "be considered for Committee-independent "
            "encoders."
        )
    else:
        print()
        print(
            "[FAIL] Encoder inputs remain different "
            "after PrefixPreprocessor."
        )
        print(
            "Cross-fold representation reuse must "
            "remain disabled."
        )


if __name__ == "__main__":
    main()