from job import recorder, run_batch
from persist import KIND_NOT_FOUND, KIND_OK, STAMP_CONTRACT, STAMP_DONE, AgreementOutcome
from rebate_flow_steps import RebateImportResult, RebateSubmitResult
from repo import MemoryRebateRepo


def _t4(**overrides) -> dict:
    row = {
        "fid": 1,
        "oms_id": 2026100501,
        "action_code": 1,
        "contract_status": 1,
        "contract_fail_reason": None,
        "contract_no": "HT1",
        "agreement_status": None,
        "agreement_fail_reason": None,
        "agreement_id": None,
        "agreement_dtl_id": None,
        "org_code": "901",
        "push_status": 0,
        "create_user_name": STAMP_CONTRACT,
        "update_user_name": STAMP_CONTRACT,
    }
    row.update(overrides)
    return row


def _t3(**overrides) -> dict:
    row = {
        "fid": 10,
        "oms_id": 2026100503,
        "contract_no": "HT-OLD",
        "contract_entry_status": 0,
        "process_status": 0,
        "process_result": "",
        "org_code": "901",
    }
    row.update(overrides)
    return row


def test_job_finds_contract_and_writes_agreement():
    repo = MemoryRebateRepo(
        table4=[
            _t4(),
            _t4(fid=2, oms_id=2026100502),
            _t4(fid=3, contract_status=2, contract_no="HT-DONE", update_user_name=STAMP_DONE),
        ]
    )
    steps: list[str] = []

    def runner(group):
        steps.append(group.contract_no)
        return AgreementOutcome(KIND_OK, "AGR1", "AGRD1", None)

    summary = run_batch(repo, runner=runner)
    assert summary.claimed == 2
    assert summary.ok == 1
    assert steps == ["HT1"]
    drafts = [row for row in repo.table4.values() if row["fid"] in (1, 2)]
    assert {row["contract_status"] for row in drafts} == {2}
    assert {row["action_code"] for row in drafts} == {1}
    assert {row["update_user_name"] for row in drafts} == {STAMP_DONE}
    assert {row["push_status"] for row in drafts} == {0}
    agreements = [row for row in repo.table4.values() if row["action_code"] == 2]
    assert sorted(row["oms_id"] for row in agreements) == [2026100501, 2026100502]
    assert {row["contract_no"] for row in agreements} == {"HT1"}
    assert {row["agreement_status"] for row in agreements} == {1}
    assert {row["agreement_id"] for row in agreements} == {"AGR1"}
    assert {row["agreement_dtl_id"] for row in agreements} == {"AGRD1"}
    assert {row["push_status"] for row in agreements} == {0}
    assert repo.table4[3]["contract_status"] == 2
    assert repo.table4[3]["action_code"] == 1


def test_job_leaves_not_found_for_next_shift():
    repo = MemoryRebateRepo(table4=[_t4()])
    later = {"n": 0}

    def runner(group):
        later["n"] += 1
        return AgreementOutcome(KIND_NOT_FOUND, None, None, None)

    run_batch(repo, runner=runner)
    assert later["n"] == 1
    row = repo.table4[1]
    assert row["contract_status"] == 1
    assert row["action_code"] == 1
    assert row["update_user_name"] == STAMP_CONTRACT
    assert [item["action_code"] for item in repo.table4.values()] == [1]


def test_job_claims_protocol_only_and_writes_table4():
    repo = MemoryRebateRepo(table3=[_t3(), _t3(fid=11, process_status=1, contract_no="HT-SKIP")])
    steps: list[str] = []

    def runner(group):
        steps.append(group.contract_no)
        return AgreementOutcome(KIND_OK, "AGR-OLD", "AGRD-OLD", None)

    run_batch(repo, runner=runner)
    assert steps == ["HT-OLD"]
    assert repo.table3[10]["process_status"] == 1
    assert repo.table3[11]["process_status"] == 1
    success = [row for row in repo.table4.values() if row["action_code"] == 1]
    agreements = [row for row in repo.table4.values() if row["action_code"] == 2]
    assert len(success) == 1
    assert success[0]["oms_id"] == 2026100503
    assert success[0]["contract_status"] == 2
    assert success[0]["contract_no"] == "HT-OLD"
    assert success[0]["push_status"] == 0
    assert len(agreements) == 1
    assert agreements[0]["agreement_status"] == 1
    assert agreements[0]["agreement_id"] == "AGR-OLD"
    assert agreements[0]["agreement_dtl_id"] == "AGRD-OLD"


def test_recorder_passes_contract_no_to_header_import_submit():
    steps: list[str] = []

    def header(contract_no: str) -> str:
        steps.append(f"header:{contract_no}")
        return "RB1"

    def importer(contract_no: str) -> RebateImportResult:
        steps.append(f"import:{contract_no}")
        return RebateImportResult(1, 0, (), True)

    def submitter(contract_no: str) -> RebateSubmitResult:
        steps.append(f"submit:{contract_no}")
        return RebateSubmitResult(True, "AGR1", "AGRD1")

    outcome = recorder("HT1", header, importer, submitter)
    assert steps == ["header:HT1", "import:HT1", "submit:HT1"]
    assert outcome.kind == KIND_OK
    assert outcome.agreement_id == "AGR1"
    assert outcome.agreement_dtl_id == "AGRD1"