#!/usr/bin/env python3
"""Convert batch_{NNN} folders with EN, en-ES, en-EU JSON into evaluation-only JSONL.
No web calls, no train split, no generated human references. Rerunning is deterministic.
"""
from pathlib import Path
from collections import Counter
import argparse, csv, hashlib, json, re, sys

TOPICS={'ai':'artificial_intelligence','bio':'biology','chem':'chemistry','math':'mathematics','phys':'physics'}
LANGS=('es','eu')

def sha(s): return hashlib.sha256(s.encode('utf-8')).hexdigest()
def emit(path,rows):
 path.parent.mkdir(parents=True,exist_ok=True)
 with path.open('w',encoding='utf-8') as f:
  for row in rows: f.write(json.dumps(row,ensure_ascii=False,separators=(',',':'))+'\n')
def read(path):
 if path.suffix == '.jsonl':
  obj=[json.loads(line) for line in path.read_text(encoding='utf-8').splitlines() if line.strip()]
 else:
  obj=json.loads(path.read_text(encoding='utf-8'))
 if not isinstance(obj,list): raise ValueError(f'Not a JSON array: {path}')
 mapping={}
 for v in obj:
  if not isinstance(v,dict) or not isinstance(v.get('id'),str) or not isinstance(v.get('text'),str) or not v['text'].strip():
   raise ValueError(f'Invalid sample in {path}')
  if v['id'] in mapping: raise ValueError(f'Duplicate ID {v["id"]} in {path}')
  mapping[v['id']]=v
 return mapping

def files_in(folder,n):
 files=[p for p in folder.iterdir() if p.is_file() and p.suffix in ('.json','.jsonl')]
 result={}
 for suffix,lang in (('EN','en'),('en-ES','es'),('en-EU','eu')):
  matches=[p for p in files if re.search(r'_batch_'+str(n).zfill(3)+r'_'+re.escape(suffix)+r'\.jsonl?$',p.name,re.I)]
  if len(matches)!=1:raise ValueError(f'{folder}: expected exactly one *batch_{n:03d}_{suffix}.json or .jsonl; got {matches}')
  result[lang]=matches[0]
 return result

def classify(id):
 m=re.match(r'^(arx|crx)_([a-z]+)_(.+)$',id)
 if not m or m[2] not in TOPICS:raise ValueError('Unrecognized topic/source in ID: '+id)
 repo={'arx':'arxiv','crx':'chemrxiv'}[m[1]]
 # source document key only a provisional grouping derived from the supplied IDs;
 # validate against publisher IDs/DOIs once metadata is available.
 doc=re.sub(r'_?v\d+$','',m[3])
 return repo,TOPICS[m[2]],f'{m[1]}:{doc}'

def make(batch_dir,n,post_edit_root):
 fs=files_in(batch_dir,n)
 raw={lang:read(path) for lang,path in fs.items()}
 base=set(raw['en'])
 for lang in LANGS:
  if set(raw[lang])!=base:raise ValueError(f'Batch {n:03d} mismatched {lang}: missing={sorted(base-set(raw[lang]))} extra={sorted(set(raw[lang])-base)}')
 # Optional approved post-edits are loaded from a separate directory and never modify MT.
 edits={}
 for lang in LANGS:
  ep=post_edit_root/f'batch_{n:03d}'/(lang+'.json')
  edits[lang]=read(ep) if ep.exists() else {}
  if not set(edits[lang]).issubset(base):
   raise ValueError(f'Unknown post-edit IDs in {ep}: {sorted(set(edits[lang])-base)}')
 rows=[]
 for id in raw['en']: # preserve EN ordering
  src=raw['en'][id]; repo,topic,doc=classify(id)
  translated={}
  for lang in LANGS:
   obj=raw[lang][id]; meta=obj.get('translation_metadata')
   if not isinstance(meta,dict):raise ValueError(f'Missing metadata {id} {lang}')
   for key in ('system','prompt_version','translated_date','status','human_reviewed'):
    if key not in meta:raise ValueError(f'Missing metadata {key} {id} {lang}')
   pe=edits[lang].get(id)
   post_edit=None
   if pe is not None:
    post_edit={key:pe[key] for key in ('text','status','reviewed_date','reviewer_id','revision')}
    if 'notes' in pe:post_edit['notes']=pe['notes']
   translated[lang]={'mt':{'text':obj['text'],'metadata':meta},'post_edit':post_edit}
  rows.append({'schema_version':'1.1.0','id':id,'batch_id':f'batch_{n:03d}',
   'source':{'language':'en','text':src['text'],'repository':repo,'topic':topic,
             'source_identifier':id,'source_document_key':doc,'source_document_key_status':'provisional_from_id',
             'source_sha256':sha(src['text']),'article_doi':None,'article_url':None,'license':None,
             'excerpt_location':None},
   'translations':translated})
 return rows

def main():
 ap=argparse.ArgumentParser()
 ap.add_argument('--input-dir',default='original_input',help='contains batch_001 through batch_010')
 ap.add_argument('--output-dir',default='data',help='generated canonical, pairs and reports files')
 ap.add_argument('--schema',default='schema/benchmark.schema.json')
 ap.add_argument('--post-edits-dir',default='post_edits',help='optional reviewed JSON by batch and language')
 ap.add_argument('--expected-batches',type=int,default=10,help='maximum number of batches (default: 10)')
 args=ap.parse_args()
 inp=Path(args.input_dir);out=Path(args.output_dir)
 folders=sorted(p for p in inp.glob('batch_*') if p.is_dir() and any(f.suffix in ('.json', '.jsonl') for f in p.iterdir() if f.is_file()))
 if not folders:raise ValueError(f'No batch directories under {inp}')
 if len(folders)>args.expected_batches:raise ValueError(f'Too many batches: {len(folders)} > {args.expected_batches}')
 for folder in folders:
  n=int(folder.name[-3:]) if re.fullmatch(r'batch_\d{3}',folder.name) else -1
  if not 1 <= n <= args.expected_batches:raise ValueError(f'Unexpected batch folder {folder.name}')
 # Remove obsolete per-batch outputs only after reading all inputs successfully.
 # Stale canonical files from a prior build are cleared after validation below.
 allrows=[];seen={};batch_summaries=[]; issues=[]
 for folder in folders:
  m=re.fullmatch(r'batch_(\d{3})',folder.name)
  if not m:raise ValueError('Invalid batch directory '+str(folder))
  n=int(m[1]);rows=make(folder,n,Path(args.post_edits_dir))
  for r in rows:
   if r['id'] in seen:raise ValueError(f'Global duplicate ID {r["id"]}: {seen[r["id"]]} and {folder.name}')
   seen[r['id']]=folder.name
  allrows+=rows
  batch_summaries.append({'batch_id':folder.name,'records':len(rows),'es_mt':len(rows),'eu_mt':len(rows),'es_post_edits':sum(r['translations']['es']['post_edit'] is not None for r in rows),'eu_post_edits':sum(r['translations']['eu']['post_edit'] is not None for r in rows)})
 schema=json.loads(Path(args.schema).read_text(encoding='utf8'))
 try:
  from jsonschema import Draft202012Validator
 except ImportError:
  raise SystemExit('Install jsonschema: pip install jsonschema')
 val=Draft202012Validator(schema)
 for r in allrows:
  errs=list(val.iter_errors(r))
  if errs:issues.append({'id':r['id'],'errors':[e.message for e in errs]})
 if issues:raise ValueError('Schema errors: '+json.dumps(issues[:10]))
 # Once all inputs and the schema pass, remove stale per-batch outputs.
 (out/'canonical').mkdir(parents=True,exist_ok=True)
 for old in (out/'canonical').glob('batch_*.jsonl'):old.unlink()
 for folder in folders:
  emit(out/'canonical'/(folder.name+'.jsonl'),[r for r in allrows if r['batch_id']==folder.name])
 emit(out/'canonical'/'all_languages.jsonl',allrows)
 # HF release files contain *only* test, no training or validation partition.
 for lang in LANGS:
  flat=[]
  for r in allrows:
   pair=r['translations'][lang]
   flat.append({'id':r['id'],'batch_id':r['batch_id'],'topic':r['source']['topic'],
    'repository':r['source']['repository'],'source_document_key':r['source']['source_document_key'],
    'source_text':r['source']['text'],'source_sha256':r['source']['source_sha256'],
    'target_lang':lang,'mt_text':pair['mt']['text'],
    'reference_text':pair['post_edit']['text'] if pair['post_edit'] else None,
    'reference_status':'pending' if pair['post_edit'] is None else 'human_post_edited',
    'mt_system':pair['mt']['metadata']['system'],
    'mt_prompt_version':pair['mt']['metadata']['prompt_version']})
  emit(out/'pairs'/f'en-{lang}'/'test.jsonl',flat)
 systems=Counter((lang,r['translations'][lang]['mt']['metadata']['system']) for r in allrows for lang in LANGS)
 topics=Counter(r['source']['topic'] for r in allrows)
 prov=Counter(r['source']['repository'] for r in allrows)
 report={'schema_version':'1.1.0','dataset_purpose':'evaluation_only',
  'loaded_batches':len(folders),'loaded_batch_ids':[p.name for p in folders],
  'records':len(allrows),'language_pairs':{'en-es':len(allrows),'en-eu':len(allrows)},
  'post_edits':{lang:sum(r['translations'][lang]['post_edit'] is not None for r in allrows) for lang in LANGS},'topics':dict(sorted(topics.items())),
  'repositories':dict(sorted(prov.items())),
  'mt_systems':{f'{k[0]}:{k[1]}':v for k,v in systems.items()},
  'schema_valid':True,'alignment_valid':True,'global_id_unique':True,
  'document_leakage_check':'deferred: no train split; full corpus/document IDs unavailable',
  'license_review':'pending article-level rights review',
  'hf_access_control':'not enabled by local file generation; must enable gating on Hub'}
 (out/'reports').mkdir(parents=True,exist_ok=True)
 (out/'reports'/'batch_validation.json').write_text(json.dumps({'batches':batch_summaries,'summary':report},indent=2,ensure_ascii=False)+'\n',encoding='utf8')
 print(json.dumps(report,ensure_ascii=False,indent=2))

if __name__=='__main__':main()