from __future__ import annotations

import sys
import unittest
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "src"))

from physics_model.dynamic_sampling import (
    ALL_MAX,
    OUTCOME_VARIATION,
    PROCESS_ONLY,
    SILENT,
    apply_dynamic_sampling,
    classify_group,
)
from physics_sft.grpo_reward import RewardConfig


class DynamicSamplingTests(unittest.TestCase):
    def test_process_only_variation_is_kept(self) -> None:
        totals = [1.10, 1.25, 1.10, 1.10]
        outcomes = [1.00, 1.00, 1.00, 1.00]
        processes = [0.10, 0.25, 0.10, 0.10]
        label = classify_group(
            totals,
            outcome_rewards=outcomes,
            process_rewards=processes,
            max_total=1.75,
            use_process=True,
        )
        self.assertEqual(label, PROCESS_ONLY)
        result = apply_dynamic_sampling(
            [totals],
            outcome_groups=[outcomes],
            process_groups=[processes],
            max_total=1.75,
            use_process=True,
        )
        self.assertEqual(result.keep_indices, [0])
        self.assertEqual(result.labels[0], PROCESS_ONLY)
        self.assertFalse(result.resample)

    def test_all_equal_total_is_filtered(self) -> None:
        totals = [0.25, 0.25, 0.25, 0.25]
        result = apply_dynamic_sampling(
            [totals],
            outcome_groups=[totals],
            process_groups=[[0, 0, 0, 0]],
            max_total=1.75,
            use_process=True,
            resample_cap=3,
        )
        self.assertEqual(result.labels[0], SILENT)
        self.assertEqual(result.keep_indices, [])
        self.assertTrue(result.resample)

    def test_all_max_uses_configured_maximum(self) -> None:
        cfg = RewardConfig(use_cot_process_reward=True)
        totals = [cfg.max_total_reward] * 4
        label = classify_group(totals, max_total=cfg.max_total_reward, use_process=True)
        self.assertEqual(label, ALL_MAX)
        other = classify_group(totals, max_total=9.99, use_process=True)
        self.assertEqual(other, SILENT)

    def test_disable_process_uses_outcome_only(self) -> None:
        totals = [1.10, 1.25, 1.10, 1.10]
        outcomes = [1.00, 1.00, 1.00, 1.00]
        processes = [0.10, 0.25, 0.10, 0.10]
        result = apply_dynamic_sampling(
            [totals],
            outcome_groups=[outcomes],
            process_groups=[processes],
            max_total=1.25,
            use_process=False,
        )
        self.assertEqual(result.labels[0], SILENT)
        self.assertEqual(result.keep_indices, [])

        mixed_outcome = apply_dynamic_sampling(
            [[1.0, 1.25, 1.0, 1.0]],
            outcome_groups=[[1.0, 1.25, 1.0, 1.0]],
            process_groups=[[0, 0, 0, 0]],
            max_total=1.25,
            use_process=False,
        )
        self.assertEqual(mixed_outcome.labels[0], OUTCOME_VARIATION)
        self.assertEqual(mixed_outcome.keep_indices, [0])

    def test_resample_cap_exhausts(self) -> None:
        silent = [[0.0, 0.0, 0.0, 0.0]]
        mid = apply_dynamic_sampling(silent, max_total=1.25, resample_attempt=1, resample_cap=3)
        self.assertTrue(mid.resample)
        self.assertFalse(mid.cap_exhausted)
        done = apply_dynamic_sampling(silent, max_total=1.25, resample_attempt=3, resample_cap=3)
        self.assertFalse(done.resample)
        self.assertTrue(done.cap_exhausted)
        self.assertEqual(done.keep_indices, [])

    def test_short_batch_does_not_raise(self) -> None:
        short = [[0.2, 0.8]]
        result = apply_dynamic_sampling(short, max_total=1.25, use_process=False)
        self.assertEqual(result.keep_indices, [0])
        leftover = apply_dynamic_sampling([[0.1]], max_total=1.25)
        self.assertEqual(leftover.labels[0], SILENT)


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