#!/usr/bin/env python3
"""AhaSignals company PIT release selection, verification and offline replay."""
import argparse,datetime as dt,hashlib,json,re,time,urllib.request
from pathlib import Path
import sys
sys.dont_write_bytecode=True
import packet

PAGE='https://ahasignals.com/research/company-pit-observations/'
ROOT='https://ahasignals.com/data/company-pit/v1/'
FILES={'snapshot.json','screen.json','study.json','coverage.json','review-candidates.jsonl','replay.py','packet.py','README.md','citation.bib'}
def encode(v):return (json.dumps(v,ensure_ascii=False,sort_keys=True,separators=(',',':'))+'\n').encode()
def digest(b):return hashlib.sha256(b).hexdigest()
def check(ok,why):
 if not ok:raise ValueError(why)
def select(index,as_of):
 cutoff=packet.instant(as_of)
 rows=index['releases'];seen=set();previous=None
 for r in rows:
  check(packet.sha(r['sha256']) and r['sha256'] not in seen,'Invalid or duplicate release hash');seen.add(r['sha256'])
  clock=packet.instant(r['frozenAt']);check(previous is None or clock>previous,'Unordered release catalog');previous=clock
  check(r['releaseUrl']==ROOT+'releases/'+r['sha256']+'/release.json','Unexpected release URL')
 eligible=[r for r in rows if packet.instant(r['frozenAt'])<=cutoff]
 return eligible[-1] if eligible else None

def verify(folder,expected):
 folder=Path(folder);raw=(folder/'release.json').read_bytes()
 check(packet.sha(expected) and digest(raw)==expected,'Release SHA-256 mismatch')
 r=json.loads(raw)
 check(set(r)=={'version','publisher','frozenAt','sourceAsOf','sourceIndexSha256','previousReleaseSha256','builderSha256','files','boundary'},'Unknown release fields')
 check(r['version']=='1.0.0' and r['publisher']=='AhaSignals','Unknown release contract')
 clock=packet.instant(r['frozenAt']);check(packet.instant(r['sourceAsOf'])<=clock,'Future source snapshot')
 check(set(r['files'])==FILES and packet.sha(r['builderSha256']),'Unexpected release files')
 check(r['previousReleaseSha256'] is None or packet.sha(r['previousReleaseSha256']),'Invalid release parent')
 for name,sha in r['files'].items():check(packet.sha(sha) and digest((folder/name).read_bytes())==sha,'File hash mismatch: '+name)
 i=json.loads((folder/'snapshot.json').read_bytes());c=json.loads((folder/'coverage.json').read_bytes())
 check(digest(encode(i))==r['sourceIndexSha256'] and i['asOf']==r['sourceAsOf'],'Source index mismatch')
 check(i['screenSha256']==digest((folder/'screen.json').read_bytes()) and i['studySha256']==digest((folder/'study.json').read_bytes()),'Source report mismatch')
 check(len(i['companies'])==c['companyCount'] and len(c['companies'])==c['companyCount'],'Coverage count mismatch')
 check(len({x['cik'] for x in i['companies']})==len(i['companies']),'Duplicate issuer')
 for e in i['companies']:
  check(re.fullmatch(r'\d{10}',e['cik']) and packet.sha(e['sha256']),'Invalid company identity')
  check(e['packetUrl']=='/data/company-evidence/v1/packets/'+e['sha256']+'.json','Unexpected packet URL')
  check(packet.instant(e['updatedAt'])<=clock and packet.instant(e['lastCheckedAt'])<=clock,'Company clock after release')
 check(c['frozenAt']==r['frozenAt'],'Coverage clock mismatch')
 return r,i,c

def replay(folder,expected,as_of,cik,cache):
 r,i,c=verify(folder,expected);cutoff=packet.instant(as_of)
 check(packet.instant(r['frozenAt'])<=cutoff,'Release unavailable at cutoff; select an older retained release. No backdating.')
 entry=next((e for e in i['companies'] if e['cik']==cik),None)
 check(entry is not None,'Issuer absent from this frozen universe; do not use current membership')
 p=packet.verify((Path(cache)/(entry['sha256']+'.json')).read_bytes(),entry['sha256'])
 check(p['cik']==cik and p['recordedAt']==entry['updatedAt'],'Wrong issuer or packet clock')
 check(packet.instant(p['recordedAt'])<=packet.instant(r['frozenAt']),'Packet created after release')
 result=packet.replay(p,as_of)
 result.update(releaseSha256=expected,releaseFrozenAt=r['frozenAt'],sourceIndexSha256=r['sourceIndexSha256'],packetSha256=entry['sha256'],screenStatus=entry['status'],collectionError=entry['collectionError'],boundary='Facts and membership of this pinned release, not a live query. Select the latest retained release no later than the requested cutoff. A later cutoff does not refresh these observations; no proof of first public web availability.')
 return result

def fetch(folder,expected,cache,cik=None,all_companies=False):
 _,i,_=verify(folder,expected)
 check(bool(cik)!=bool(all_companies),'Choose exactly one CIK or --all')
 entries=i['companies'] if all_companies else [e for e in i['companies'] if e['cik']==cik]
 check(bool(entries),'Issuer absent from frozen universe')
 cache=Path(cache);cache.mkdir(parents=True,exist_ok=True)
 class NoRedirect(urllib.request.HTTPRedirectHandler):
  def redirect_request(self,*args,**kwargs):return None
 opener=urllib.request.build_opener(NoRedirect)
 for e in entries:
  dest=cache/(e['sha256']+'.json')
  if dest.exists():
   p=packet.verify(dest.read_bytes(),e['sha256']);check(p['cik']==e['cik'],'Cached issuer mismatch');continue
  # Only AhaSignals normalized public packets; never request SEC or a supplied host.
  req=urllib.request.Request('https://ahasignals.com'+e['packetUrl'],headers={'User-Agent':'AhaSignals-PIT-replay/1.0'})
  with opener.open(req,timeout=30) as response:raw=response.read(10_000_001)
  check(len(raw)<=10_000_000,'Packet exceeds size limit');p=packet.verify(raw,e['sha256']);check(p['cik']==e['cik'],'Issuer mismatch')
  dest.write_bytes(raw);time.sleep(.5)
 return {'verifiedPackets':len(entries),'boundary':'Previously cached valid packets are reused. No credentials or SEC requests.'}

def main():
 a=argparse.ArgumentParser(description=__doc__);a.add_argument('command',choices=['select','verify','fetch','replay']);a.add_argument('--catalog',type=Path);a.add_argument('--release',type=Path);a.add_argument('--sha256');a.add_argument('--as-of');a.add_argument('--cik');a.add_argument('--all',action='store_true');a.add_argument('--cache',type=Path,default=Path('packets'));v=a.parse_args()
 try:
  if v.command=='select':
   check(v.catalog is not None and v.as_of is not None,'--catalog and --as-of required');result=select(json.loads(v.catalog.read_bytes()),v.as_of);check(result is not None,'No retained release at or before cutoff')
  else:
   check(v.release is not None and v.sha256 is not None,'--release and externally pinned --sha256 required')
   if v.command=='verify':r,i,c=verify(v.release,v.sha256);result={'verified':True,'frozenAt':r['frozenAt'],'companyCount':len(i['companies']),'coverageStatus':c['status']}
   elif v.command=='fetch':result=fetch(v.release,v.sha256,v.cache,v.cik,v.all)
   else:
    check(v.as_of is not None and v.cik is not None,'--as-of and --cik required');result=replay(v.release,v.sha256,v.as_of,v.cik,v.cache)
  print(json.dumps(result,ensure_ascii=False,indent=2))
 except (ValueError,KeyError,FileNotFoundError,TypeError) as e:a.exit(2,'Unavailable: '+str(e)+'\n')
if __name__=='__main__':main()