import io
import unittest

import numpy as np
import torch

from pace.models import HistoryEncoder
from pace.training import _optimizer_step, corrupt_batch, fit_neural, predict_neural, train_ssl


def ssl_fixture(n=16):
    return {
        "course": np.full((n, 2, 2), 3, dtype=np.int64),
        "grade_band": np.full((n, 2, 2), 6, dtype=np.int64),
        "numeric": np.tile(np.array([.65, .6, .2], dtype=np.float32), (n, 2, 2, 1)),
        "event_mask": np.ones((n, 2, 2), dtype=bool),
        "semester_mask": np.ones((n, 2), dtype=bool),
        "gaps": np.tile(np.array([0., 1.], dtype=np.float32), (n, 1)),
    }


class SSLTrainingTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        torch.set_num_threads(1)

    def test_masks_hide_all_corresponding_inputs_without_mutating_source(self):
        batch = {k: torch.from_numpy(v) for k, v in ssl_fixture(2).items()}
        corrupted, grade_mask, course_mask = corrupt_batch(batch, "joint", 1., torch.Generator().manual_seed(2))
        self.assertTrue(grade_mask.all() and course_mask.all())
        self.assertTrue((corrupted["grade_band"] == 2).all())
        self.assertTrue((corrupted["course"] == 2).all())
        self.assertTrue((corrupted["numeric"] == 0).all())
        self.assertTrue((batch["numeric"] > 0).all())

    def test_masks_sample_only_observed_tokens_and_force_one_per_task(self):
        batch = {k: torch.from_numpy(v) for k, v in ssl_fixture(2).items()}
        batch["event_mask"][0] = False
        batch["grade_band"][1, 0, 0] = 1
        batch["course"][1, 0, 1] = 1
        _, gm, cm = corrupt_batch(batch, "joint", 0., torch.Generator().manual_seed(1))
        self.assertEqual(int(gm.sum()), 1)
        self.assertEqual(int(cm.sum()), 1)
        self.assertFalse(gm[0].any() or cm[0].any())
        self.assertFalse(gm[1, 0, 0] or cm[1, 0, 1])

    def test_ssl_learns_and_fixed_epochs_refit_without_validation(self):
        cfg = dict(dim=16, layers=1, heads=4, dropout=0., batch_size=16, ssl_lr=.02, mask_rate=.5)
        result = train_ssl(ssl_fixture(), None, 5, "mlp", "joint", cfg, 4, "cpu", lambda _: None, fixed_epochs=8)
        self.assertEqual(result.epochs, 8)
        self.assertEqual(len(result.history), 8)
        self.assertLess(result.history[-1]["train_loss"], result.history[0]["train_loss"] * .4)
        self.assertTrue(np.isfinite(result.history[-1]["train_loss"]))
        self.assertIs(result.encoder, result.model.encoder)

    def test_validation_masks_fixed_and_frequency_baselines_training_only(self):
        tr, va = ssl_fixture(8), ssl_fixture(6)
        va["course"][:] = 4
        va["grade_band"][:] = 7
        cfg = dict(dim=8, layers=1, dropout=0., batch_size=4, ssl_epochs=3, ssl_patience=5)
        result = train_ssl(tr, va, 5, "mlp", "joint", cfg, 9, "cpu", lambda _: None)
        baseline = result.diagnostics["frequency_baselines"]
        self.assertEqual(baseline["course_counts"], [32, 0])
        self.assertEqual(baseline["grade_counts"], [0, 0, 0, 32, 0])
        self.assertEqual(len({r["val_grade_tokens"] for r in result.history}), 1)
        self.assertEqual(len({r["val_course_tokens"] for r in result.history}), 1)
        self.assertTrue(result.diagnostics["validation_mask_hash"])

    def test_all_empty_ssl_is_rejected_as_unsupported_training(self):
        tr = ssl_fixture(4)
        tr["event_mask"][:] = False
        tr["semester_mask"][:] = False
        with self.assertRaisesRegex(ValueError, "SSL training.*no eligible"):
            train_ssl(tr, None, 5, "transformer", "joint", dict(dim=8, heads=2, layers=1), 2, "cpu", lambda _: None, fixed_epochs=1)

    def test_active_ssl_tasks_require_observed_targets_in_training_and_validation(self):
        for split in ("training", "validation"):
            for missing, task in (("course", "course"), ("course", "joint"), ("grade", "grade"), ("grade", "joint")):
                with self.subTest(split=split, missing=missing, task=task):
                    tr, va = ssl_fixture(4), ssl_fixture(4)
                    unsupported = tr if split == "training" else va
                    unsupported["course" if missing == "course" else "grade_band"][:] = 1
                    with self.assertRaisesRegex(ValueError, "SSL " + split + ".*no eligible.*historical overlap.*explicit alternate split"):
                        train_ssl(tr, va, 5, "mlp", task, dict(dim=8, layers=1, ssl_epochs=1), 2, "cpu", lambda _: None)

    def test_inactive_ssl_task_without_targets_does_not_block_training(self):
        for task, missing in (("grade", "course"), ("course", "grade_band")):
            with self.subTest(task=task):
                tr, va = ssl_fixture(4), ssl_fixture(4)
                tr[missing][:] = 1
                va[missing][:] = 1
                result = train_ssl(tr, va, 5, "mlp", task, dict(dim=8, layers=1, ssl_epochs=1), 2, "cpu", lambda _: None)
                self.assertGreater(result.history[0]["val_" + task + "_tokens"], 0)

    def test_fixed_epoch_refit_also_rejects_missing_active_task_targets(self):
        tr = ssl_fixture(4)
        tr["course"][:] = 1
        with self.assertRaisesRegex(ValueError, "SSL training.*no eligible known-course"):
            train_ssl(tr, None, 5, "mlp", "course", dict(dim=8, layers=1), 2, "cpu", lambda _: None, fixed_epochs=1)

    def test_fixed_validation_masks_force_targets_in_each_eligible_batch(self):
        cfg = dict(dim=8, layers=1, dropout=0., batch_size=2, ssl_epochs=1, mask_rate=0.)
        result = train_ssl(ssl_fixture(4), ssl_fixture(6), 5, "mlp", "joint", cfg, 9, "cpu", lambda _: None)
        self.assertEqual(result.history[0]["val_grade_tokens"], 3)
        self.assertEqual(result.history[0]["val_course_tokens"], 3)

    def test_unknown_course_exclusion_is_reported(self):
        va = ssl_fixture(4)
        va["course"][:, 0, 0] = 1
        result = train_ssl(ssl_fixture(4), va, 5, "mlp", "joint", dict(dim=8, layers=1, ssl_epochs=1), 9, "cpu", lambda _: None)
        self.assertEqual(result.diagnostics["target_eligibility"]["validation"]["unknown_course_events"], 4)
        self.assertEqual(result.diagnostics["target_eligibility"]["validation"]["course_targets"], 12)

    def test_nonfinite_ssl_loss_stops_before_optimizer_step(self):
        tr = ssl_fixture(4)
        tr["numeric"][..., 1] = np.nan
        with self.assertRaisesRegex(FloatingPointError, "non-finite.*loss"):
            train_ssl(tr, None, 5, "mlp", "grade", dict(dim=8, layers=1), 2, "cpu", lambda _: None, fixed_epochs=1)

    def test_nonfinite_gradient_stops_before_optimizer_step(self):
        model = torch.nn.Linear(1, 1, bias=False)
        model.weight.data.zero_()
        optimizer = torch.optim.AdamW(model.parameters(), lr=.01)
        loss = model.weight.sqrt().sum()
        with self.assertRaisesRegex(FloatingPointError, "non-finite.*gradient"):
            _optimizer_step(loss, model, optimizer, 1., "test")
        self.assertEqual(model.weight.item(), 0.)


class NeuralTrainingTests(unittest.TestCase):
    def test_indexed_minibatches_preserve_dense_training_and_predictions(self):
        from pace.data import IndexedHistory
        torch.set_num_threads(1)
        unique=ssl_fixture(2);unique['course'][1]=4
        back=np.tile(np.array([0,1]),4)
        compact=IndexedHistory(unique,back)
        dense={k:v[back] for k,v in unique.items()}
        x=np.arange(24,dtype=np.float32).reshape(8,3)/24;y=back
        cfg=dict(dim=8,layers=1,heads=2,dropout=0.,hidden_dim=8,batch_size=4,neural_lr=.01)
        for mode in ('scratch','frozen','finetune'):
            with self.subTest(mode=mode):
                torch.manual_seed(19);encoder=HistoryEncoder(5,'gru',8,1,2,0.)
                a=fit_neural(x,y,dense,None,None,None,encoder,mode,cfg,29,'cpu',lambda _:None,fixed_epochs=2)
                b=fit_neural(x,y,compact,None,None,None,encoder,mode,cfg,29,'cpu',lambda _:None,fixed_epochs=2)
                np.testing.assert_allclose(predict_neural(a.model,x,dense,'cpu',4),
                                           predict_neural(b.model,x,compact,'cpu',4),atol=1e-6,rtol=1e-6)

    @classmethod
    def setUpClass(cls):
        torch.set_num_threads(1)

    def test_frozen_encoder_unchanged_and_finetune_has_gradients(self):
        x = np.arange(32, dtype=np.float32).reshape(16, 2) / 32
        y = (np.arange(16) % 2).astype(np.float32)
        batch = ssl_fixture()
        encoder = HistoryEncoder(5, "gru", dim=8, layers=1, dropout=.2)
        original = {k: v.detach().clone() for k, v in encoder.state_dict().items()}
        cfg = dict(batch_size=16, hidden_dim=8, dropout=0., neural_lr=.01)
        frozen = fit_neural(x, y, batch, None, None, None, encoder, "frozen", cfg, 3, "cpu", lambda _: None, fixed_epochs=2)
        for k, v in original.items():
            torch.testing.assert_close(v, frozen.model.encoder.state_dict()[k], atol=0, rtol=0)
        self.assertFalse(any(p.requires_grad for p in frozen.model.encoder.parameters()))
        self.assertFalse(frozen.model.encoder.training)
        tuned = fit_neural(x, y, batch, None, None, None, encoder, "finetune", cfg, 3, "cpu", lambda _: None, fixed_epochs=2)
        self.assertTrue(any(p.grad is not None and p.grad.abs().sum() > 0 for p in tuned.model.encoder.parameters()))
        self.assertTrue(any(not torch.equal(v, tuned.model.encoder.state_dict()[k]) for k, v in original.items()))
        for k, v in original.items():
            torch.testing.assert_close(v, encoder.state_dict()[k], atol=0, rtol=0)

    def test_checkpoint_replay_is_exact(self):
        x = np.arange(32, dtype=np.float32).reshape(16, 2) / 32
        y = (np.arange(16) % 2).astype(np.float32)
        batch = ssl_fixture()
        model = fit_neural(x, y, batch, None, None, None, HistoryEncoder(5, "transformer", dim=8, layers=1, heads=2), "scratch", dict(hidden_dim=8, dropout=0.), 4, "cpu", lambda _: None, fixed_epochs=2).model
        first = predict_neural(model, x, batch, "cpu", batch_size=5)
        checkpoint = io.BytesIO()
        torch.save(model, checkpoint)
        checkpoint.seek(0)
        replay = torch.load(checkpoint, weights_only=False)
        np.testing.assert_array_equal(first, predict_neural(replay, x, batch, "cpu", batch_size=5))

    def test_none_mode_and_ap_selection(self):
        x = np.arange(32, dtype=np.float32).reshape(16, 2) / 32
        y = (np.arange(16) > 7).astype(np.float32)
        fit = fit_neural(x, y, None, x, y, None, None, "none", dict(neural_epochs=3, neural_patience=3, dropout=0.), 2, "cpu", lambda _: None)
        self.assertGreaterEqual(fit.epochs, 1)
        selected = fit.history[fit.epochs - 1]["val_ap"]
        self.assertEqual(selected, max(r["val_ap"] for r in fit.history))
        p = predict_neural(fit.model, x, None, "cpu")
        self.assertTrue(np.isfinite(p).all() and ((0 <= p) & (p <= 1)).all())

    def test_nonfinite_history_loss_stops_neural_training(self):
        batch = ssl_fixture(4)
        batch["numeric"][..., 1] = np.nan
        with self.assertRaisesRegex(FloatingPointError, "non-finite.*loss"):
            fit_neural(np.zeros((4, 1)), np.array([0, 1, 0, 1]), batch, None, None, None,
                       HistoryEncoder(5, "gru", dim=8, layers=1), "scratch", dict(hidden_dim=8),
                       3, "cpu", lambda _: None, fixed_epochs=1)


if __name__ == "__main__":
    unittest.main()
