"""Independent exact-rational check of the frozen sample.
Uses all earlier/later point pairs rather than the running-peak implementation.
No imports from reproduce.py.txt; no network access or file writes.
"""
from pathlib import Path
from datetime import datetime,timezone
from fractions import Fraction
import csv,hashlib,json

ROOT=Path(__file__).resolve().parent
raw_bytes=(ROOT/'coinbase-response.json').read_bytes()
raw=json.loads(raw_bytes,parse_float=Fraction)
p=json.loads((ROOT/'provenance.json').read_text(encoding='utf-8'))
saved=json.loads((ROOT/'results.json').read_text(encoding='utf-8'))
start=int(datetime.fromisoformat(p['window_start_utc'].replace('Z','+00:00')).timestamp())
end=int(datetime.fromisoformat(p['window_end_exclusive_utc'].replace('Z','+00:00')).timestamp())
assert hashlib.sha256(raw_bytes).hexdigest()==p['raw_sha256']
rows=sorted((r for r in raw if start<=r[0] and r[0]<end and r[0]+900<=end),key=lambda r:r[0])
assert [r[0] for r in rows]==list(range(start,end,900))
assert len(rows)==96 and len(raw)==97
assert len({r[0] for r in rows})==96
for r in raw:
    assert len(r)==6 and type(r[0]) is int and r[0]%900==0
    assert min(r[1:5])>0 and r[5]>=0
    assert r[1]<=r[3]<=r[2] and r[1]<=r[4]<=r[2]
with (ROOT/'candles.csv').open(encoding='utf-8',newline='') as f:
    csv_rows=list(csv.DictReader(f))
assert len(csv_rows)==96
for r,c in zip(rows,csv_rows):
    assert int(c['start_epoch'])==r[0]
    assert all(Fraction(c[name])==r[i] for i,name in enumerate(['low','high','open','close','volume'],1))

def exact(v):return Fraction(v['exact_numerator'],v['exact_denominator'])
def check_percent(value,record):
    assert exact(record)==value
    assert abs(Fraction(record['percent_decimal_rounded_8'])-value)<=Fraction(1,200000000)

closes=[Fraction(r[4]) for r in rows]
observed=saved['observed']
check_percent((closes[-1]/closes[0]-1)*100,observed['close_to_close_return'])
pairs=[(max(Fraction(0),(closes[i]-closes[j])/closes[i])*100,i,j)
       for i in range(len(closes)) for j in range(i,len(closes))]
worst,i,j=max(pairs,key=lambda v:v[0])
check_percent(worst,observed['maximum_close_drawdown'])
assert Fraction(observed['drawdown_peak']['price'])==closes[i]
assert Fraction(observed['drawdown_trough']['price'])==closes[j]
assert Fraction(observed['highest_bucket_high']['price'])==max(r[2] for r in rows)
assert Fraction(observed['lowest_bucket_low']['price'])==min(r[1] for r in rows)
assert Fraction(observed['highest_recorded_close']['price'])==max(closes)
assert Fraction(observed['lowest_recorded_close']['price'])==min(closes)
assert rows[-1][0]-rows[0][0]==85500==observed['bucket_end_boundary_separation_seconds']
assert observed['actual_last_trade_timestamps_available'] is False

paths=json.loads((ROOT/'fictional-paths.json').read_text(encoding='utf-8'))['cases']
outputs=saved['fictional_paths']
for path,out in zip(paths,outputs):
    assert path['fictional'] is True
    prices=[Fraction(x) for x in path['ordered_prices']]
    assert [prices[0],max(prices),min(prices),prices[-1]]==[60,66,54,62]
    check_percent((prices[-1]/prices[0]-1)*100,out['first_to_last_return'])
    dd=max(max(Fraction(0),(prices[a]-prices[b])/prices[a])*100
           for a in range(len(prices)) for b in range(a,len(prices)))
    check_percent(dd,out['maximum_ordered_point_drawdown'])
assert exact(outputs[0]['maximum_ordered_point_drawdown'])==Fraction(200,11)
assert exact(outputs[1]['maximum_ordered_point_drawdown'])==Fraction(10,1)
print(json.dumps(dict(result='PASS',method='independent Fraction arithmetic; all earlier/later pairs',
    observed_buckets=96,raw_rows=97,nominal_bucket_end_separation_seconds=85500,
    exact_return_percent=str((closes[-1]/closes[0]-1)*100),exact_close_drawdown_percent=str(worst),
    fictional_paths=2,actual_trade=False),indent=2))