import io
import tempfile
import unittest
from pathlib import Path
import numpy as np
import pandas as pd
from s34_comparisons import summarize_metrics, paired_contrasts, operational_tables, promotion_decision
from s34_reporting import print_table


class ReportingTests(unittest.TestCase):
    def _primary_fixture(self):
        values = {"A0": .20, "A0M": .21, "A1": .22, "A2": .25, "P1": .24}
        metrics = pd.DataFrame([dict(faculty=f"f{i}", fold=f, seed=s, arm=a,
                                     stage="development", ap=v)
                 for i in range(14) for f in range(1, 6) for s in [29, 129, 229]
                 for a, v in values.items()])
        ops = pd.DataFrame([dict(faculty=f"f{i}", fold=f, seed=s, arm=a, beta=b,
                                 f1=.4+(a == "A2")*.01, f2=.5+(a == "A2")*.01,
                                 alert_fraction=.2)
                 for i in range(14) for f in range(2, 6) for s in [29, 129, 229]
                 for a in ["A1", "A2"] for b in [1, 2]])
        return metrics, ops

    def test_complete_primary_guard_and_undefined_failure(self):
        m, o = self._primary_fixture()
        self.assertEqual(promotion_decision(m, o, primary=True)["research_promotion"], "PASS")
        m.loc[0, "ap"] = np.nan
        self.assertEqual(promotion_decision(m, o, primary=True)["research_promotion"], "FAIL")

    def test_primary_decision_ignores_retrospective_and_checks_operating_harm(self):
        m, o = self._primary_fixture()
        d1 = promotion_decision(m, o, primary=True)
        retro = m[m.fold == 5].copy(); retro["fold"] = 6; retro["ap"] = .99
        d2 = promotion_decision(pd.concat([m, retro]), o, primary=True)
        self.assertEqual(d1, d2)
        o.loc[(o.arm == "A2") & (o.beta == 2), "f2"] = .1
        self.assertEqual(promotion_decision(m, o, primary=True)["research_promotion"], "FAIL")

    def test_macro_is_cell_weighted_not_row_pooled(self):
        rows = []
        for fold, n, a in [(1, 100, .2), (2, 10, .8)]:
            for seed in [29, 129]:
                rows.append(dict(faculty="f", fold=fold, seed=seed, arm="A2",
                                 stage="development", rows=n, failures=2, ap=a, auc=.7))
        m = summarize_metrics(pd.DataFrame(rows))
        self.assertAlmostEqual(m.iloc[0]["ap"], .5)

    def test_f6_f7_thresholds_frozen_and_retro_cannot_change_decision(self):
        with tempfile.TemporaryDirectory() as td:
            index = []
            for fold in [1, 6, 7]:
                path = Path(td)/f"f{fold}.csv"
                pd.DataFrame(dict(y=[1, 0, 1, 0], p=[.9, .8, .7, .1],
                                  row_index=range(4))).to_csv(path, index=False)
                index.append(dict(faculty="f", fold=fold, arm="A2", seed=29, path=str(path)))
            thresholds, ops = operational_tables(pd.DataFrame(index))
            f6 = thresholds[(thresholds.fold == 6) & (thresholds.beta == 2)].iloc[0]
            f7 = thresholds[(thresholds.fold == 7) & (thresholds.beta == 2)].iloc[0]
            self.assertEqual(f6.threshold, f7.threshold)
            d = pd.read_csv(index[1]["path"]); d.y = 1-d.y; d.to_csv(index[1]["path"], index=False)
            changed, _ = operational_tables(pd.DataFrame(index))
            self.assertEqual(f7.threshold, changed[(changed.fold == 7) & (changed.beta == 2)].iloc[0].threshold)
        metrics = pd.DataFrame([dict(faculty="f", fold=f, seed=29, arm=a,
                                     stage="development" if f < 6 else "retrospective",
                                     ap=.2) for f in range(1, 8) for a in ["A0", "A0M", "A1", "A2", "P1"]])
        d1 = promotion_decision(metrics, pd.DataFrame(), primary=False)
        metrics.loc[metrics.fold > 5, "ap"] = .99
        d2 = promotion_decision(metrics, pd.DataFrame(), primary=False)
        self.assertEqual(d1, d2)
        self.assertEqual(d1["research_promotion"], "INCONCLUSIVE")

    def test_full_table_has_no_truncation(self):
        out = io.StringIO()
        print_table("COMPLETE", pd.DataFrame(dict(marker=[f"row_{i:04d}" for i in range(1500)])), stream=out)
        t = out.getvalue()
        self.assertIn("row_0000", t)
        self.assertIn("row_1499", t)
        self.assertIn("rows=1500", t)
        self.assertNotIn("...", t)

    def test_paired_seeds_and_faculty_cluster_bootstrap(self):
        metrics = pd.DataFrame([dict(stage="development", faculty=f, fold=k, seed=s,
                                     arm=a, ap=.3+(a == "A2")*.02)
                                for f in ["f", "g"] for k in [1, 2] for s in [29, 129]
                                for a in ["A1", "A2"]])
        summary, deltas, uncertainty = paired_contrasts(metrics, bootstrap=20)
        contrast = summary[summary.contrast == "A2-A1"].iloc[0]
        self.assertAlmostEqual(contrast.mean_delta_ap, .02)
        u = uncertainty[uncertainty.contrast == "A2-A1"].iloc[0]
        self.assertEqual(u.clusters, 2)
        self.assertEqual(u.paired_cells, 4)
