from datetime import date

from arm_statements.evaluation import EvalLine
from arm_statements.loader import Rules
from arm_statements.model import DocumentType, Edition, FormVariant, LineStatus
from arm_statements.structure import choose_edition, confirm_codes

BAL = DocumentType.BALANCE
Q3_2025 = date(2025, 9, 30)
FULL_CONF = 100.0


def seq(*items: tuple[str, float]) -> list[EvalLine]:
    return [EvalLine(f"r{i}", i, LineStatus.OK, code, conf, False, ()) for i, (code, conf) in enumerate(items)]


def unconfirmed(lines: list[EvalLine], rules: Rules, effective: date | None = Q3_2025) -> set[str]:
    return set(confirm_codes(lines, BAL, FormVariant.FULL, effective, rules).unconfirmed)


def test_uncertain_code_in_place(rules: Rules) -> None:
    assert unconfirmed(seq(("1220", 100.0), ("1230", 50.0), ("1240", 100.0)), rules) == set()


def test_swapped_uncertain_neighbours(rules: Rules) -> None:
    lines = seq(("1210", 100.0), ("1230", 50.0), ("1220", 50.0), ("1240", 100.0))
    assert unconfirmed(lines, rules) == {"r1", "r2"}


def test_conflicting_anchors(rules: Rules) -> None:
    lines = seq(("1210", 100.0), ("1240", 100.0), ("1230", 100.0), ("1250", 50.0))
    assert unconfirmed(lines, rules) == set()


def test_legal_repeat_1220_fsbu4(rules: Rules) -> None:
    lines = seq(("1215", 100.0), ("1220", 100.0), ("1220", 50.0), ("1230", 100.0))
    assert unconfirmed(lines, rules) == set()


def test_repeat_outside_orders(rules: Rules) -> None:
    lines = seq(("1220", 100.0), ("1230", 100.0), ("1230", 50.0), ("1240", 100.0))
    assert unconfirmed(lines, rules) == {"r2"}


def test_66n_blank_in_2025(rules: Rules) -> None:
    lines = seq(("1110", 100.0), ("1120", 60.0), ("1130", 100.0))
    result = confirm_codes(lines, BAL, FormVariant.FULL, Q3_2025, rules)
    assert (result.edition, result.unconfirmed) == (Edition.RAS_66N, frozenset())


def test_tie_resolved_by_date(rules: Rules) -> None:
    lines = seq(("1210", 100.0), ("1230", 100.0))
    assert confirm_codes(lines, BAL, FormVariant.FULL, Q3_2025, rules).edition is Edition.FSBU4
    assert confirm_codes(lines, BAL, FormVariant.FULL, date(2024, 12, 31), rules).edition is Edition.RAS_66N


def test_choose_edition_public(rules: Rules) -> None:
    blank_66n = [("1110", True), ("1120", False), ("1130", True)]
    assert choose_edition(BAL, blank_66n, Q3_2025, rules) is Edition.RAS_66N
    tie = [("1210", True), ("1230", True)]
    assert choose_edition(BAL, tie, Q3_2025, rules) is Edition.FSBU4
    assert choose_edition(BAL, tie, date(2024, 12, 31), rules) is Edition.RAS_66N
    assert choose_edition(BAL, tie, None, rules) is None
    assert choose_edition(BAL, [], Q3_2025, rules) is Edition.FSBU4
    assert choose_edition(DocumentType.DISCLOSURE, [("5101", True)], date(2024, 12, 31), rules) is Edition.RAS_66N


def test_choose_edition_equals_confirm_codes(rules: Rules) -> None:
    lines = seq(("1110", 100.0), ("1120", 60.0), ("1130", 100.0))
    pairs = [(ln.line_code or "", (ln.code_confidence or 0.0) >= FULL_CONF) for ln in lines]
    expected = confirm_codes(lines, BAL, FormVariant.FULL, Q3_2025, rules).edition
    assert choose_edition(BAL, pairs, Q3_2025, rules, variant=FormVariant.FULL) is expected


def test_confident_nonstandard_code_not_flagged(rules: Rules) -> None:
    assert unconfirmed(seq(("1230", 100.0), ("1231", 100.0), ("11101", 100.0)), rules) == set()


def test_subline_follows_confirmed_parent(rules: Rules) -> None:
    lines = seq(("1220", 100.0), ("1230", 50.0), ("12301", 60.0), ("1240", 100.0))
    assert unconfirmed(lines, rules) == set()
    orphan = seq(("1220", 100.0), ("12301", 60.0), ("1240", 100.0))
    assert unconfirmed(orphan, rules) == {"r1"}


def test_tie_without_date_union_of_editions(rules: Rules) -> None:
    lines = seq(("1210", 100.0), ("1230", 50.0))
    result = confirm_codes(lines, BAL, FormVariant.FULL, None, rules)
    assert result.edition is None
    assert result.unconfirmed == frozenset()


def test_disclosure_has_no_unconfirmed(rules: Rules) -> None:
    lines = seq(("5101", 50.0))
    result = confirm_codes(lines, DocumentType.DISCLOSURE, None, Q3_2025, rules)
    assert (result.edition, result.unconfirmed) == (Edition.FSBU4, frozenset())


def test_uncertain_code_outside_order_unconfirmed(rules: Rules) -> None:
    assert unconfirmed(seq(("1230", 100.0), ("9999", 50.0), ("1240", 100.0)), rules) == {"r1"}


def test_performance_realistic_size(rules: Rules) -> None:
    order = rules.code_orders.sequence(Edition.FSBU4, BAL, FormVariant.FULL)
    lines = seq(*[(code, 50.0) for code in order] * 1)
    assert confirm_codes(lines, BAL, FormVariant.FULL, Q3_2025, rules).unconfirmed == frozenset()