from __future__ import annotations

import unittest
from decimal import Decimal

from scripts.rectification.decision_policy import (
    POLICY_VERSION,
    RELATIVE_SUPPORT_MODE,
    _relative_support,
    build_candidate_decisions,
)
from scripts.rectification.scoring_service import ALGORITHM_VERSION


def _row(time: str, score: float) -> dict:
    return {"time": time, "score": score, "evidence": [], "missing_layers": []}


class RelativeSupportScaleTest(unittest.TestCase):
    def test_holdout_gate_keeps_proportional_default(self) -> None:
        self.assertEqual(POLICY_VERSION, "rectification-candidate-policy-v3")
        self.assertEqual(ALGORITHM_VERSION, "rectification-v5-matrix-scoring-7")
        self.assertEqual(RELATIVE_SUPPORT_MODE, "proportional")

    def test_offset_top_two_lead_is_at_least_proportional(self) -> None:
        scores = [
            Decimal("15.52"), Decimal("15.40"), Decimal("14.10"), Decimal("13.00"),
            Decimal("12.50"), Decimal("12.00"), Decimal("11.80"), Decimal("11.50"),
            Decimal("11.40"), Decimal("11.20"), Decimal("11.10"), Decimal("10.96"),
        ]
        floor = min(scores)
        proportional = _relative_support(scores, floor=floor, mode="proportional")
        offset = _relative_support(scores, floor=floor, mode="offset")
        prop_lead = sorted(proportional, reverse=True)
        offset_lead = sorted(offset, reverse=True)
        self.assertGreaterEqual(offset_lead[0] - offset_lead[1], prop_lead[0] - prop_lead[1])
        self.assertEqual(sum(offset), 100)
        self.assertEqual(sum(proportional), 100)

    def test_equal_scores_split_evenly_for_offset_and_proportional(self) -> None:
        scores = [Decimal("12")] * 12
        expected = _relative_support(scores, floor=Decimal("12"), mode="proportional")
        offset = _relative_support(scores, floor=Decimal("12"), mode="offset")
        self.assertEqual(offset, expected)
        self.assertEqual(sum(offset), 100)
        self.assertTrue(all(value in {8, 9} for value in offset))

    def test_build_candidate_decisions_offset_lead_beats_proportional_on_spaced_grid(self) -> None:
        scores = [
            15.52, 15.40, 14.10, 13.00, 12.50, 12.00,
            11.80, 11.50, 11.40, 11.20, 11.10, 10.96,
        ]
        rows = [_row(f"05:{index * 5:02d}", score) for index, score in enumerate(scores)]
        proportional = build_candidate_decisions(rows, result_id="00000000-0000-4000-8000-000000000001", support_mode="proportional")
        offset = build_candidate_decisions(rows, result_id="00000000-0000-4000-8000-000000000001", support_mode="offset")
        self.assertEqual(len(proportional), 12)
        self.assertEqual(len(offset), 12)
        prop_lead = proportional[0]["relative_support"] - proportional[1]["relative_support"]
        offset_lead = offset[0]["relative_support"] - offset[1]["relative_support"]
        self.assertGreaterEqual(offset_lead, prop_lead)
        self.assertEqual(sum(item["relative_support"] for item in offset), 100)


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