"""Reproduce the frozen2027outlook. Python3 standard library; reads local inputs, prints JSON."""
from pathlib import Path
from datetime import date,timedelta,datetime,timezone
from statistics import mean,median
import json,math,hashlib,zipfile,sys

def drawdown(values):
 peak=values[0];worst=0.0
 for value in values:
  peak=max(peak,value);worst=min(worst,value/peak-1)
 return worst

def regression(x,y):
 assert len(x)==len(y) and len(x)>1
 mx=mean(x);my=mean(y);xx=sum((a-mx)**2 for a in x);yy=sum((a-my)**2 for a in y);xy=sum((a-mx)*(b-my) for a,b in zip(x,y))
 assert xx>0 and yy>0
 beta=xy/xx
 return dict(pearson_correlation=xy/math.sqrt(xx*yy),ols_beta=beta,intercept=my-beta*mx)

def calculate(data,inputs,manifest,rawzip):
 products=data['products'];ltc=products['LTC-USD'];btc=products['BTC-USD']
 start=date.fromisoformat(data['start']);end=date.fromisoformat(data['end_exclusive'])
 expected=[(start+timedelta(days=i)).isoformat() for i in range((end-start).days)]
 assert [r['date'] for r in ltc]==expected==[r['date'] for r in btc]
 raw_verified=0
 with zipfile.ZipFile(rawzip) as archive:
  maps={p:{} for p in products}
  for page in manifest:
   raw=archive.read(page['raw_file']);assert hashlib.sha256(raw).hexdigest()==page['sha256']
   rows=json.loads(raw);inside=0;overall=0
   for r in rows:
    t=int(r[0]);day=datetime.fromtimestamp(t,timezone.utc).date().isoformat()
    if page['start']<=day<page['end_exclusive']:inside+=1
    if data['start']<=day<data['end_exclusive']:
     overall+=1
     value=dict(date=day,timestamp=t,low=float(r[1]),high=float(r[2]),open=float(r[3]),close=float(r[4]),volume=float(r[5]))
     assert 0<value['low']<=value['close']<=value['high'] and value['low']<=value['open']<=value['high'] and value['volume']>=0
     old=maps[page['product']].get(day)
     if old is not None:assert old==value
     maps[page['product']][day]=value
   assert inside==page['rows_in_requested_end_exclusive_window']
   assert overall==page['returned_rows_within_overall_study'];raw_verified+=1
  for p,rows in products.items():assert rows==[maps[p][d] for d in expected]
 joined=[dict(date=x['date'],ltc_close=x['close'],btc_close=y['close'],ratio=x['close']/y['close']) for x,y in zip(ltc,btc)]
 last=joined[-1];rolling=[]
 for n in [30,90,365]:
  rr=joined[-n-1:];x=[math.log(rr[i]['btc_close']/rr[i-1]['btc_close']) for i in range(1,len(rr))];y=[math.log(rr[i]['ltc_close']/rr[i-1]['ltc_close']) for i in range(1,len(rr))]
  rolling.append(dict(return_observations=n,closes=n+1,first_close=rr[0]['date'],last_close=rr[-1]['date'],**regression(x,y)))
 annual=[]
 for year in sorted(set(int(r['date'][:4]) for r in joined)):
  rr=[r for r in joined if r['date'].startswith(str(year))];lc=[r for r in ltc if r['date'].startswith(str(year))]
  high=max(lc,key=lambda r:r['high']);low=min(lc,key=lambda r:r['low'])
  prior=next((r for r in joined if r['date']==str(year-1)+'-12-31'),None)
  annual.append(dict(year=year,first_close=rr[0]['date'],last_close_date=rr[-1]['date'],high=high['high'],high_date=high['date'],low=low['low'],low_date=low['date'],last_close=rr[-1]['ltc_close'],period_end_vs_intraday_high=rr[-1]['ltc_close']/high['high']-1,ratio_return_first_to_last_close=rr[-1]['ratio']/rr[0]['ratio']-1,ratio_return_prior_dec31_to_period_end=(rr[-1]['ratio']/prior['ratio']-1 if prior else None),reset_close_drawdown=drawdown([r['ltc_close'] for r in rr])))
 trail=joined[-365:]
 history=dict(dates=dict(first=expected[0],last=expected[-1],paired_daily_rows=len(joined)),last=last,annual=annual,rolling=rolling,trailing365_ratio=dict(first=trail[0]['date'],last=trail[-1]['date'],minimum=min(r['ratio'] for r in trail),maximum=max(r['ratio'] for r in trail),median=median(r['ratio'] for r in trail),empirical_fraction_at_or_below_last=sum(r['ratio']<=last['ratio'] for r in trail)/365),max_sample_close_drawdown=drawdown([r['ltc_close'] for r in joined]))
 base=inputs['base_assumption_box'];assert math.isclose(base['btc_usd'][0]*base['ltc_btc'][0],inputs['central_editorial_range'][0]);assert math.isclose(base['btc_usd'][1]*base['ltc_btc'][1],inputs['central_editorial_range'][1])
 cases=[]
 for item in inputs['scenario_cases']:
  value=item['btc']*item['ratio'];upper=item['upper_exclusive']
  assert value>=item['lower'] and (upper is None or value<upper)
  cases.append(dict(**item,example_price=value))
 assert cases[0]['lower']==0 and cases[-1]['upper_exclusive'] is None
 assert all(cases[i]['upper_exclusive']==cases[i+1]['lower'] for i in range(len(cases)-1))
 matrix=[dict(btc_price=b,ratio=r,ltc_price=b*r) for b in inputs['btc_grid'] for r in inputs['ratio_grid']]
 hurdles=[dict(target=t,btc_price=b,required_ratio=t/b,relative_to_last_ratio=(t/b)/last['ratio'],return_from_frozen_ltc_close=t/last['ltc_close']-1) for t in inputs['price_targets'] for b in inputs['reverse_btc']]
 valuations=[dict(price=t,assumed_supply=inputs['illustrative_ltc_supply'],implied_capitalization=t*inputs['illustrative_ltc_supply']) for t in inputs['price_targets']]
 capshares=[dict(ratio=r,assumed_ltc_supply=inputs['illustrative_ltc_supply'],assumed_btc_supply=inputs['illustrative_btc_supply'],ltc_to_btc_market_value=(inputs['illustrative_ltc_supply']/inputs['illustrative_btc_supply'])*r) for r in inputs['ratio_grid']]
 issuance=[]
 for day in inputs['halving_dates']:
  h=date.fromisoformat(day);pre=(h-date(2027,1,1)).days;post=(date(2028,1,1)-h).days;assert pre+post==365
  total=pre*inputs['pre_daily']+post*inputs['post_daily'];baseline=365*inputs['pre_daily']
  issuance.append(dict(hypothetical_halving_date=day,pre_days=pre,post_days=post,calendar2027_ltc=total,no_halving_baseline=baseline,removed_ltc=baseline-total,reduction_fraction=(baseline-total)/baseline,post_halving_annual_run_rate=365*inputs['post_daily']))
 sale=[dict(price=p,sales_fraction=s,modeled_daily_gross_sales_reduction=(inputs['pre_daily']-inputs['post_daily'])*s*p) for p in inputs['sales_prices'] for s in inputs['sales_fraction']]
 paths=[dict(name=k,listed_prices=v,end_return=v[-1]/v[0]-1,largest_listed_point_drawdown=drawdown(v)) for k,v in inputs['synthetic_paths'].items()]
 weights=inputs['toy_weighted_forecasts'];assert math.isclose(sum(r['weight'] for r in weights),1)
 average=sum(r['price']*r['weight'] for r in weights);cum=0;med=None
 for r in sorted(weights,key=lambda x:x['price']):
  cum+=r['weight']
  if med is None and cum>=.5:med=r['price']
 distribution=dict(explicitly_uncalibrated=True,inputs=weights,mean=average,median=med,tail_contribution=weights[-1]['price']*weights[-1]['weight'],tail_fraction_of_mean=weights[-1]['price']*weights[-1]['weight']/average)
 august=next(r for r in issuance if r['hypothetical_halving_date']=='2027-08-01')
 fund=[dict(chosen_monthly_net_coin_addition=n,annualized_ltc=n*12,fraction_of_post_halving_run_rate=n*12/(inputs['post_daily']*365),fraction_of_august_example_calendar_output=n*12/august['calendar2027_ltc']) for n in inputs['monthly_fund_additions']]
 assert august['calendar2027_ltc']==1038600 and august['removed_ltc']==275400
 assert math.isclose(average,187) and med==80
 assert all(math.isclose(r['end_return'],1) for r in paths)
 assert math.isclose(next(r for r in paths if r['name']=='blow_off')['largest_listed_point_drawdown'],-13/18)
 assert math.isclose(next(r for r in sale if r['price']==120 and r['sales_fraction']==.5)['modeled_daily_gross_sales_reduction'],108000)
 assert math.isclose(250000*.004,1000)
 return dict(scope='Frozen venue-specific history plus chosen conditional scenarios; no fitted2027probabilities, causal claim, backtested trading strategy or execution guarantee.',historical=history,models=dict(central_editorial_range=inputs['central_editorial_range'],base_assumption_box=inputs['base_assumption_box'],cases=cases,matrix=matrix,hurdles=hurdles,valuation=valuations,relative_valuation=capshares,calendar_issuance=issuance,miner_sales=sale,fund_additions=fund,price_paths=paths,toy_distribution=distribution),checks=dict(raw_pages_sha256_verified=raw_verified,paired_daily_rows=len(joined),historical_regression_windows=3,annual_periods=len(annual),chosen_cases=len(cases),matrix_cells=len(matrix),target_hurdles=len(hurdles),calendar_halving_cases=len(issuance),price_paths=len(paths),calibrated_future_probabilities=False))

if __name__=='__main__':
 base=Path(__file__).resolve().parent
 data_path=Path(sys.argv[1]) if len(sys.argv)>1 else base/'daily-candles.json'
 inputs_path=Path(sys.argv[2]) if len(sys.argv)>2 else base/'model-inputs.json'
 result=calculate(json.loads(data_path.read_text(encoding='utf-8')),json.loads(inputs_path.read_text(encoding='utf-8')),json.loads((data_path.parent/'acquisition-manifest.json').read_text(encoding='utf-8')),data_path.parent/'source-candles.zip')
 print(json.dumps(result,indent=2))