"""Load NarrativeBench, prepare model inputs, and reproduce citation-based scores."""
from __future__ import annotations
import argparse
import collections
import hashlib
import json
from pathlib import Path
import re
import sys

TASKS = ('NI','NE','MNI','BP','DP')
LANGUAGE_STATUSES = {'same','different','mixed','no_answer','unknown'}

def text_sha(text):
    return hashlib.sha256(text.encode('utf-8')).hexdigest()

def file_sha(path):
    h=hashlib.sha256()
    with Path(path).open('rb') as stream:
        for chunk in iter(lambda:stream.read(1024*1024),b''):h.update(chunk)
    return h.hexdigest()

def digest(value):
    return text_sha(json.dumps(value,sort_keys=True,ensure_ascii=False,separators=(',',':'),allow_nan=False))

def read_jsonl(path):
    with Path(path).open(encoding='utf-8') as stream:
        for line in stream:
            if line.strip():yield json.loads(line)

def write_jsonl(path,rows):
    with Path(path).open('w',encoding='utf-8') as stream:
        for row in rows:stream.write(json.dumps(row,ensure_ascii=False,allow_nan=False)+'\n')

def parquet_rows(path):
    import pyarrow.parquet as pq
    for batch in pq.ParquetFile(path).iter_batches(batch_size=512):
        yield from batch.to_pylist()

def verify_files(root):
    root=Path(root).resolve()
    manifest=json.loads((root/'manifest.json').read_text())
    for name,expected in manifest['files'].items():
        p=(root/name).resolve()
        if not p.is_relative_to(root) or not p.is_file() or file_sha(p)!=expected:
            raise ValueError('release file does not match manifest: '+name)
    return manifest

def load_data(root):
    root=Path(root)
    docs={r['document_id']:r for r in parquet_rows(root/'data/documents.parquet')}
    cases={r['case_id']:r for r in parquet_rows(root/'data/evaluation.parquet')}
    return docs,cases

def messages(case,documents):
    parts=['DOCUMENTS:']
    for did in case['document_ids']:
        d=documents[did]
        parts.append(f"[{did}]\nSource: {d['url']}\n{d['text']}")
    body='\n\n---\n'.join(parts)
    if case.get('query_context'):body+='\n\n'+case['query_context']
    result=[{'role':'system','content':case['system_instruction']},
            {'role':'user','content':body+'\n\nQUESTION:\n'+case['query']}]
    if case['task']=='MNI':
        if not case.get('prior_answer') or not case.get('followup_instruction'):
            raise ValueError('missing fixed prior answer or follow-up instruction')
        result.extend([{'role':'assistant','content':case['prior_answer']},
                       {'role':'user','content':case['followup_instruction']}])
    return result

def validate_case(case,documents):
    if case['task'] not in TASKS:raise ValueError('unknown task')
    ids=case['document_ids']
    if not ids or len(ids)!=len(set(ids)) or not set(ids)<=set(documents):
        raise ValueError('invalid document context')
    group=case.get('target_narrative_id')
    target={d for d in ids if documents[d]['narrative_id']==group}
    expected=target if case['task']=='NI' else set(ids)-target if case['task'] in {'NE','MNI'} else set(ids)
    if case['task'] in {'NI','NE','MNI'} and not target:raise ValueError('target narrative absent from context')
    if set(case['expected_document_ids'])!=expected:raise ValueError('incorrect narrative targets')
    if case['input_sha256']!=digest(messages(case,documents)):
        raise ValueError('evaluation input has changed: '+case['case_id'])

def score(case,response,language_status,documents):
    if language_status not in LANGUAGE_STATUSES:raise ValueError('unknown response-language label')
    if language_status=='unknown':language_status='same'
    if language_status!='same':return 0.0
    ids=set(re.findall(r'\bD\d{4}\b',response or ''))
    context=set(case['document_ids'])
    expected={documents[d]['narrative_id'] for d in case['expected_document_ids']}
    cited={documents[d]['narrative_id'] for d in ids & context}
    tp=len(cited & expected)
    if case['task'] in {'NI','NE'}:
        fp=len(cited-expected)+len(ids-context)
        fn=len(expected-cited)
        return 2*tp/max(2*tp+fp+fn,1)
    return tp/max(len(expected),1)

def language_for(prediction,label):
    for key in ['case_id','model_id']:
        if prediction[key]!=label[key]:raise ValueError('language label belongs to another response')
    if label['response_sha256']!=text_sha(prediction['response']):
        raise ValueError('response changed after its language assessment')
    if label['language_status'] not in LANGUAGE_STATUSES:raise ValueError('invalid language assessment')
    return label['language_status']

def summarize(rows,cases=None,documents=None):
    values=collections.defaultdict(list);violations=collections.Counter()
    for row in rows:
        if row['score'] is None:raise ValueError('each response requires a numeric score')
        values[(row['model_id'],row['task'])].append(row['score'])
        if row['language_status'] in {'different','mixed'}:violations[row['model_id']]+=1
    models=sorted({m for m,_ in values})
    result={'models':{m:{'tasks':{t:{'mean':sum(values[(m,t)])/len(values[(m,t)]),'cases':len(values[(m,t)])} for t in TASKS if values[(m,t)]},
                         'language_violations':violations[m]} for m in models}}
    if cases is not None and documents is not None:
        def mean(items):return sum(items)/len(items) if items else None
        def disparity(groups,reference):
            if not groups.get(reference):return None
            base=mean(groups[reference]);gaps=[abs(mean(v)-base) for k,v in groups.items() if k!=reference and v]
            return 100*mean(gaps) if gaps else None
        for model in models:
            query=collections.defaultdict(list);target=collections.defaultdict(list);framing=collections.defaultdict(list)
            for row in rows:
                if row['model_id']!=model or row['score'] is None:continue
                case=cases[row['case_id']];value=row['score'];query[case['query_language']].append(value)
                if row['task'] in {'BP','DP'}:framing[case['query_type']].append(value)
                if row['task'] in {'NI','NE'}:
                    languages={documents[d]['publication_language'] for d in case['document_ids'] if documents[d]['narrative_id']==case['target_narrative_id']}
                    if len(languages)!=1:raise ValueError('target narrative has inconsistent publication language')
                    target[next(iter(languages))].append(value)
            tasks=result['models'][model]['tasks']
            result['models'][model]['higher_capabilities']={
                'diversity_prompt_gain_pp':100*(tasks['DP']['mean']-tasks['BP']['mean']) if 'BP' in tasks and 'DP' in tasks else None,
                'confirmatory_absolute_gap_pp':100*abs(mean(framing['neutral'])-mean(framing['confirmatory'])) if framing['neutral'] and framing['confirmatory'] else None,
                'query_language_gap_pp':disparity(query,'en'),
                'target_language_gap_pp':disparity(target,'English')}
        keys=['diversity_prompt_gain_pp','confirmatory_absolute_gap_pp','query_language_gap_pp','target_language_gap_pp']
        result['higher_capabilities']={key:mean([result['models'][m]['higher_capabilities'][key] for m in models if result['models'][m]['higher_capabilities'][key] is not None]) for key in keys}
    return result

def validate(root):
    root=Path(root);manifest=verify_files(root);docs,cases=load_data(root)
    queries=list(parquet_rows(root/'data/queries.parquet'))
    models=json.loads((root/'models.json').read_text())
    counts=manifest['counts']
    for key,n in [('documents',len(docs)),('queries',len(queries)),('evaluation',len(cases)),('model_configurations',len(models))]:
        if n!=counts[key]:raise ValueError('release count mismatch: '+key)
    if len({q['question_id'] for q in queries})!=len(queries):raise ValueError('duplicate query identifier')
    known={q['question_id'] for q in queries}
    for case in cases.values():
        if case['question_id'] not in known:raise ValueError('unknown query identifier')
        validate_case(case,docs)
    opportunities=collections.defaultdict(set)
    for case in cases.values():opportunities[(case['question_id'],case['query_language'])].add(case['task'])
    if any(tasks!=set(TASKS) for tasks in opportunities.values()):raise ValueError('incomplete five-task question/language set')
    return counts|{'input_hashes_verified':len(cases),'network_calls':0}

def provider_payload(conversation,configuration):
    """Prepare provider request fields without credentials or network access."""
    from urllib.parse import quote
    provider=configuration['provider'];model=configuration['api_model'];generation=configuration['generation']
    tokens=generation['max_output_tokens'];temperature=generation.get('temperature',0)
    if provider=='google':
        systems=[m['content'] for m in conversation if m['role'] in {'system','developer'}]
        contents=[{'role':'model' if m['role']=='assistant' else 'user','parts':[{'text':m['content']}]} for m in conversation if m['role'] in {'user','assistant'}]
        config={'temperature':temperature,'maxOutputTokens':tokens}
        if 'thinking_budget' in generation:config['thinkingConfig']={'thinkingBudget':generation['thinking_budget']}
        if 'thinking_level' in generation:config['thinkingConfig']={'thinkingLevel':generation['thinking_level']}
        body={'contents':contents,'generationConfig':config}
        if systems:body['systemInstruction']={'parts':[{'text':'\n\n'.join(systems)}]}
        return {'url':'https://generativelanguage.googleapis.com/v1beta/models/'+quote(model,safe='')+':generateContent','body':body}
    if provider=='openai':
        body={'model':model,'input':conversation,'max_output_tokens':tokens,'reasoning':{'effort':generation.get('reasoning_effort','none')}}
        if temperature is not None:body['temperature']=temperature
        return {'url':'https://api.openai.com/v1/responses','body':body}
    if provider=='moonshot':
        # Kimi's evaluated nonthinking condition has a fixed temperature of0.6.
        # Its batch payload omits the fixed parameter and explicitly disables thinking.
        body={'model':model,'messages':conversation,'max_tokens':tokens}
        body.update(configuration['request_options'])
        return {'url':'https://api.moonshot.cn/v1/chat/completions','body':body}
    if provider=='huggingface':
        body={'model':model,'messages':conversation,'temperature':temperature,'max_tokens':tokens,
              'chat_template_kwargs':configuration.get('chat_template_kwargs',{}),'stream':False}
        if 'stop_token_ids' in generation:body['stop_token_ids']=generation['stop_token_ids']
        if 'reasoning_effort' in body['chat_template_kwargs']:body['reasoning_effort']=body['chat_template_kwargs']['reasoning_effort']
        return {'path':'/v1/chat/completions','body':body}
    raise ValueError('unknown model provider')

def export(root,out,model_id,limit=None):
    if limit is not None and limit<1:raise ValueError('--limit must be positive')
    root=Path(root);validate(root);docs,cases=load_data(root)
    models=json.loads((root/'models.json').read_text())
    if model_id not in models:raise ValueError('unknown model configuration')
    selected=list(cases.values())[:limit] if limit else list(cases.values())
    def rows():
        for case in selected:
            conversation=messages(case,docs)
            yield {'case_id':case['case_id'],'model_id':model_id,'messages':conversation,'model_configuration':models[model_id],'provider_request':provider_payload(conversation,models[model_id])}
    write_jsonl(out,rows())
    return {'prepared_cases':len(selected),'model_id':model_id,'network_calls':0}

def replay(root,out=None):
    root=Path(root);validate(root);docs,cases=load_data(root)
    seen=set();scored=[]
    for row in parquet_rows(root/'data/responses.parquet'):
        key=(row['model_id'],row['case_id'])
        if key in seen:raise ValueError('duplicate model/case response')
        seen.add(key)
        status=language_for(row,row)
        case=cases[row['case_id']]
        actual=score(case,row['response'],status,docs)
        if actual is None or abs(actual-row['score'])>1e-12:raise ValueError('score replay mismatch: '+str(key))
        scored.append({'model_id':row['model_id'],'case_id':row['case_id'],'task':case['task'],'language_status':status,'score':actual})
    expected=json.loads((root/'manifest.json').read_text())['counts']['responses']
    model_ids=set(json.loads((root/'models.json').read_text()))
    if len(seen)!=expected or seen!={(m,c) for m in model_ids for c in cases}:raise ValueError('incomplete model/case response set')
    result=summarize(scored,cases,docs)|{'responses_verified':len(seen),'score_mismatches':0,'network_calls':0}
    if out:Path(out).write_text(json.dumps(result,indent=2)+'\n')
    return result

def score_predictions(root,predictions,labels=None,out=None,fallback_model=None):
    if out is None:raise ValueError('provide an output path')
    if labels is None:
        labels=Path(out).with_suffix('.languages.jsonl')
        detect_languages(root,predictions,labels,fallback_model=fallback_model)
    root=Path(root);validate(root);docs,cases=load_data(root)
    language_labels={}
    for label in read_jsonl(labels):
        key=(label['model_id'],label['case_id'])
        if key in language_labels:raise ValueError('duplicate language assessment for model/case')
        language_labels[key]=label
    rows=[];seen=set()
    for pred in read_jsonl(predictions):
        key=(pred['model_id'],pred['case_id'])
        if key in seen:raise ValueError('duplicate model/case response')
        seen.add(key);status=language_for(pred,language_labels[key]);case=cases[pred['case_id']]
        if status=='unknown':status='same'
        rows.append({'model_id':pred['model_id'],'case_id':pred['case_id'],'task':case['task'],'language_status':status,'score':score(case,pred['response'],status,docs)})
    write_jsonl(out,rows)
    return summarize(rows,cases,docs)

def detect_languages(root,predictions,out,fallback_model=None):
    # Optional detector packages are needed only for new responses, not replay.
    from lingua import LanguageDetectorBuilder
    try:
        from language_detection import classify,FastTextFallback
    except ModuleNotFoundError as exc:
        if exc.name != 'language_detection':raise
        from .public_language import classify,FastTextFallback
    root=Path(root);validate(root);_,cases=load_data(root)
    detector=LanguageDetectorBuilder.from_all_languages().build()
    fallback=FastTextFallback(fallback_model,Path(__file__).with_name('language_detector.json')) if fallback_model else None
    rows=[]
    for pred in read_jsonl(predictions):
        case=cases[pred['case_id']]
        if case['query_language'] in {'am','ti','ne','prs'} and fallback is None:
            raise ValueError('provide --fallback-model for Amharic, Tigrinya, Nepali or Dari responses')
        status,_=classify(detector,pred['response'],case['query_language'],fallback)
        rows.append({'model_id':pred['model_id'],'case_id':pred['case_id'],'response_sha256':text_sha(pred['response']),'language_status':status})
    write_jsonl(out,rows)
    return {'responses':len(rows),'language_statuses':dict(collections.Counter(r['language_status'] for r in rows))}

def main():
    parser=argparse.ArgumentParser(description=__doc__)
    sub=parser.add_subparsers(dest='command',required=True)
    for command in ['validate','replay','export','score','detect-language']:
        p=sub.add_parser(command);p.add_argument('--root',type=Path,default=Path(__file__).resolve().parent.parent)
        if command=='export':p.add_argument('--model',required=True);p.add_argument('--limit',type=int);p.add_argument('--out',type=Path,required=True)
        elif command=='replay':p.add_argument('--out',type=Path)
        elif command=='score':p.add_argument('--predictions',type=Path,required=True);p.add_argument('--language-labels',type=Path);p.add_argument('--fallback-model',type=Path);p.add_argument('--out',type=Path,required=True)
        elif command=='detect-language':p.add_argument('--predictions',type=Path,required=True);p.add_argument('--fallback-model',type=Path);p.add_argument('--out',type=Path,required=True)
    args=parser.parse_args()
    if args.command=='validate':result=validate(args.root)
    elif args.command=='replay':result=replay(args.root,args.out)
    elif args.command=='export':result=export(args.root,args.out,args.model,args.limit)
    elif args.command=='score':result=score_predictions(args.root,args.predictions,args.language_labels,args.out,args.fallback_model)
    else:result=detect_languages(args.root,args.predictions,args.out,args.fallback_model)
    print(json.dumps(result,ensure_ascii=False,indent=2))

if __name__=='__main__':main()