"""Offline two-stage routing sensitivity model; all defaults hypothetical."""
from dataclasses import dataclass
from math import isfinite
import unittest

@dataclass(frozen=True)
class Result:
    escalation: float
    true_acceptance: float
    false_acceptance: float
    spend: float
    spend_per_true_acceptance: float

def route(cheap_success, reject_good, accept_bad, fallback_success,
          first_cost, verifier_cost, fallback_cost):
    values = (cheap_success, reject_good, accept_bad, fallback_success,
              first_cost, verifier_cost, fallback_cost)
    if any(not isfinite(x) for x in values):
        raise ValueError("Inputs must be finite")
    if any(x < 0 or x > 1 for x in values[:4]) or any(x < 0 for x in values[4:]):
        raise ValueError("Probabilities must be in [0,1], costs nonnegative")
    good_kept = cheap_success * (1 - reject_good)
    bad_kept = (1 - cheap_success) * accept_bad
    escalated = cheap_success * reject_good + (1 - cheap_success) * (1 - accept_bad)
    true_accepted = good_kept + escalated * fallback_success
    spend = first_cost + verifier_cost + escalated * fallback_cost
    return Result(escalated, true_accepted, bad_kept, spend,
                  spend / true_accepted if true_accepted else float("inf"))

class Tests(unittest.TestCase):
    def test_example(self):
        r = route(.8, .05, .1, .9, .0015, .004, .06)
        self.assertAlmostEqual(r.escalation, .22)
        self.assertAlmostEqual(r.true_acceptance, .958)
        self.assertAlmostEqual(r.false_acceptance, .02)
        self.assertAlmostEqual(r.spend, .0187)
        self.assertAlmostEqual(r.spend_per_true_acceptance, .0187 / .958)
        low_recovery = route(.8, .05, .1, .4, .0015, .004, .06)
        self.assertAlmostEqual(low_recovery.true_acceptance, .848)
        self.assertAlmostEqual(low_recovery.spend, r.spend)
    def test_oracle(self):
        r = route(.8, 0, 0, .9, .0015, 0, .06)
        self.assertAlmostEqual(r.true_acceptance, .98)
    def test_reject_everything(self):
        self.assertEqual(route(.8, 1, 0, .9, 1, 1, 1).escalation, 1)
    def test_accept_everything(self):
        r = route(.8, 0, 1, .9, 1, 1, 1)
        self.assertEqual(r.escalation, 0)
        self.assertAlmostEqual(r.false_acceptance, .2)
    def test_zero_acceptance(self):
        self.assertEqual(route(0, 0, 0, 0, 1, 1, 1).spend_per_true_acceptance, float("inf"))
    def test_invalid(self):
        for value in (-.1, 1.1, float("nan"), float("inf")):
            with self.assertRaises(ValueError):
                route(value, 0, 0, .9, 1, 1, 1)

if __name__ == "__main__":
    result = unittest.main(exit=False)
    if not result.result.wasSuccessful():
        raise SystemExit(1)
    for recovery in (.9, .4):
        print(route(.8, .05, .1, recovery, .0015, .004, .06))