"""Synthetic, deterministic sampling and missing-outcome investigation.

All examples are constructed for teaching. No external data or network calls.
"""

from dataclasses import dataclass
from fractions import Fraction
from itertools import combinations
from math import sqrt


@dataclass(frozen=True)
class Stratum:
    name: str
    frame_size: int
    inspected: int
    successes: int

    def validate(self) -> None:
        if not 0 <= self.successes <= self.inspected <= self.frame_size:
            raise ValueError(f"inconsistent stratum: {self.name}")

    @property
    def expansion_weight(self) -> Fraction:
        self.validate()
        if not self.inspected:
            raise ValueError(f"no inspected cases in {self.name}")
        return Fraction(self.frame_size, self.inspected)


def stratified_rate(strata: list[Stratum]) -> Fraction:
    if not strata:
        raise ValueError("at least one stratum is required")
    frame = sum(s.frame_size for s in strata)
    if not frame:
        raise ValueError("empty frame")
    return sum((Fraction(s.frame_size, frame) * Fraction(s.successes, s.inspected)
                for s in strata), Fraction(0))


def stratified_design_variance(strata: list[Stratum]) -> Fraction:
    """Estimated design variance for independent within-stratum SRS without replacement.

    Assumes every inspected binary outcome was observed. Does not include frame,
    response, measurement or model uncertainty.
    """
    if not strata:
        raise ValueError("at least one stratum is required")
    frame = sum(s.frame_size for s in strata)
    if not frame:
        raise ValueError("empty frame")
    total = Fraction(0)
    for s in strata:
        s.validate()
        if s.inspected < 2:
            raise ValueError("at least two inspected units per stratum required")
        p = Fraction(s.successes, s.inspected)
        sample_variance = Fraction(s.inspected, s.inspected - 1) * p * (1 - p)
        W = Fraction(s.frame_size, frame)
        f = Fraction(s.inspected, s.frame_size)
        total += W * W * (1 - f) * sample_variance / s.inspected
    return total


def outcome_bounds(known_successes: int, known_failures: int, unknown: int) -> tuple[Fraction, Fraction]:
    if min(known_successes, known_failures, unknown) < 0:
        raise ValueError("counts must be nonnegative")
    total = known_successes + known_failures + unknown
    if not total:
        raise ValueError("empty cohort")
    return Fraction(known_successes, total), Fraction(known_successes + unknown, total)


def unknown_needed(known_successes: int, known_failures: int, unknown: int, threshold: Fraction) -> int:
    if not 0 <= threshold <= 1:
        raise ValueError("threshold outside [0,1]")
    outcome_bounds(known_successes, known_failures, unknown)
    total = known_successes + known_failures + unknown
    required_total = -(-(threshold.numerator * total) // threshold.denominator)
    return max(0, required_total - known_successes)


def exact_two_unit_sample_means() -> list[Fraction]:
    frame = [0, 0, 1, 1, 1]
    return [Fraction(a + b, 2) for a, b in combinations(frame, 2)]


def main() -> None:
    routine = Stratum("routine", 800, 100, 90)
    complex_ = Stratum("complex", 200, 100, 60)
    sample_rate = Fraction(routine.successes + complex_.successes,
                           routine.inspected + complex_.inspected)
    weighted = stratified_rate([routine, complex_])
    design_se = sqrt(float(stratified_design_variance([routine, complex_])))
    lower, upper = outcome_bounds(120, 40, 40)
    needed = unknown_needed(120, 40, 40, Fraction(72, 100))
    print(f"Inspected cases: {routine.inspected + complex_.inspected}")
    print(f"Unweighted inspected rate: {float(sample_rate):.1%}")
    print(f"Design-weighted frame rate: {float(weighted):.1%}")
    print(f"Design-only estimated standard error: {design_se:.2%}")
    print(f"Routine / complex expansion weights: {routine.expansion_weight} / {complex_.expansion_weight}")
    print(f"Full-cohort missing-outcome bounds: {float(lower):.1%}–{float(upper):.1%}")
    print(f"Unknown successes needed for 72%: {needed} of 40 ({needed / 40:.1%})")
    print(f"Urban/remote poststratified respondent rate: {float(Fraction(600,1000)*Fraction(153,180)+Fraction(400,1000)*Fraction(7,20)):.1%}")
    means = exact_two_unit_sample_means()
    assert len(means) == 10
    assert sum(means) / len(means) == Fraction(3, 5)
    assert sum((x - Fraction(3, 5)) ** 2 for x in means) / len(means) == Fraction(9, 100)
    print("Exact two-unit samples: 1 mean 0, 6 means 0.5, 3 means 1; variance 0.09")


if __name__ == "__main__":
    main()
