"""Verify fictional invoice examples offline, using Python 3 standard library.
No network calls, live transaction IDs, wallet access or output files.
"""
from pathlib import Path
from datetime import datetime, timezone
from decimal import Decimal
from copy import deepcopy
import csv
import json

ROOT=Path(__file__).resolve().parent
data=json.loads((ROOT/'invoice-cases.json').read_text(encoding='utf-8'))
valuations=json.loads((ROOT/'fictional-valuations.json').read_text(encoding='utf-8'))

def instant(value):
    if value is None:
        return None
    t=datetime.fromisoformat(value.replace('Z','+00:00'))
    if t.tzinfo is None or t.utcoffset() is None:
        raise ValueError('A timestamp must declare its UTC offset')
    return t.astimezone(timezone.utc)

def time_relation(value,deadline):
    t=instant(value); d=instant(deadline)
    if t is None:
        return 'unknown'
    return 'before_deadline' if t<d else 'after_deadline' if t>d else 'at_deadline'

def amount_relation(actual,expected):
    if actual is None:
        return 'unknown'
    if type(actual) is not int or type(expected) is not int or min(actual,expected)<0:
        raise ValueError('Amounts must be nonnegative integer litoshis')
    return 'short' if actual<expected else 'excess' if actual>expected else 'exact'

def next_step(c):
    # This selects a question from supplied evidence, not a provider outcome.
    if c['network_matches'] is False:
        return 'network_policy_review'
    if c['destination_matches'] is False:
        return 'destination_review'
    if c['never_authorized']:
        return 'fresh_instructions'
    if c['lookup_state']!='record_found':
        return 'hold_and_establish_broadcast'
    amount=amount_relation(c['delivered_litoshis'],c['required_litoshis'])
    state=c['provider_status_supplied']
    if state in ('complete','complete_excess_refund_offered'):
        return 'excess_resolution' if amount=='excess' else 'fulfillment_check'
    relation=time_relation(c['provider_first_observed'],c['deadline'])
    if relation=='at_deadline':
        return 'boundary_review'
    if amount=='short':
        return 'amount_resolution'
    if relation=='after_deadline':
        return 'late_receipt_review'
    return 'receiver_review'

assert data['evidence_type']=='constructed teaching casebook'
assert len(data['cases'])==10
assert not data['observed_provider_test'] and not data['observed_mainnet_payment']
assert instant('2026-10-12T12:15:00+02:00')==instant('2026-10-12T10:15:00Z')
try:
    instant('2026-10-12T12:15:00')
except ValueError:
    pass
else:
    raise AssertionError('Timezone-free input must be rejected')

with (ROOT/'invoice-cases.csv').open(encoding='utf-8',newline='') as f:
    csv_rows=list(csv.DictReader(f))
assert len(csv_rows)==10
csv_by_id={r['case_id']:r for r in csv_rows}
computed=[]
for c in data['cases']:
    assert c['fictional'] is True
    for field,expected in [('provider_first_observed','expected_first_seen_relation'),
                           ('sender_reported_broadcast','expected_broadcast_relation')]:
        assert time_relation(c[field],c['deadline'])==c[expected],(c['case_id'],field)
    assert amount_relation(c['delivered_litoshis'],c['required_litoshis'])==c['expected_amount_relation']
    decision=next_step(c)
    assert decision==c['expected_next_step'],c['case_id']
    r=csv_by_id[c['case_id']]
    for name in ('deadline','provider_status_supplied','expected_next_step'):
        assert r[name]==str(c[name]),(c['case_id'],name)
    for name in ('required_litoshis','delivered_litoshis'):
        assert r[name]==('' if c[name] is None else str(c[name])),(c['case_id'],name)
    mutated=deepcopy(c)
    mutated['block_header_timestamp']='2030-01-01T00:00:00Z'
    assert next_step(mutated)==decision,'Header time must not decide provider observation timing'
    label=c['transaction_label']
    assert label is None or label.startswith('FICTIONAL-') and len(label)!=64
    computed.append(dict(case_id=c['case_id'],time_relation=c['expected_first_seen_relation'],
                         amount_relation=c['expected_amount_relation'],next_step=decision))

rows=valuations['rows']
assert len(rows)==3 and valuations['fictional'] is True
for r in rows:
    rate=Decimal(r['eur_per_ltc'])
    original=Decimal(r['original_litoshis'])/Decimal(100000000)
    assert original*rate==Decimal(r['original_eur_value'])
    calculated=Decimal(r['fresh_invoice_eur'])/rate*Decimal(100000000)
    assert calculated==Decimal(r['fresh_required_litoshis'])
    assert calculated==calculated.to_integral_value(),'No hidden rounding in these valuations'
with (ROOT/'fictional-valuations.csv').open(encoding='utf-8',newline='') as f:
    valuation_csv=list(csv.DictReader(f))
assert len(valuation_csv)==3
for r,cr in zip(rows,valuation_csv):
    assert all(cr[k]==str(v) for k,v in r.items())

case3=next(c for c in data['cases'] if c['case_id']=='I03')
deadline=instant(case3['deadline'])
assert (deadline-instant(case3['sender_reported_broadcast'])).total_seconds()==20
assert (instant(case3['provider_first_observed'])-deadline).total_seconds()==8
assert (instant(case3['provider_first_observed'])-instant(case3['sender_reported_broadcast'])).total_seconds()==28
print(json.dumps(dict(result='PASS',evidence='fictional teaching material only',case_count=10,
                     valuation_count=3,timezone_free_input_rejected=True,header_time_independent=True,
                     actual_provider_test=False,actual_payment=False,cases=computed),indent=2))