#!/usr/bin/env python3
"""Paired frozen-model Level-1/Level-2 ModeBench pass@8 evaluation."""
from __future__ import annotations
import argparse,hashlib,itertools,json,os,re,sys,tempfile
from datetime import datetime,timezone
from pathlib import Path
from typing import Any
ROOT=Path(__file__).resolve().parents[1]
sys.path.insert(0,str(ROOT/'src'))

def sha(value:Any)->str:
    return hashlib.sha256(json.dumps(value,sort_keys=True,separators=(',',':')).encode()).hexdigest()
def file_sha(path:Path)->str:
    h=hashlib.sha256()
    with path.open('rb') as f:
        for chunk in iter(lambda:f.read(1<<20),b''): h.update(chunk)
    return h.hexdigest()
def atomic(path:Path,payload:Any)->None:
    path.parent.mkdir(parents=True,exist_ok=True)
    fd,tmp=tempfile.mkstemp(prefix='.'+path.name+'.',dir=path.parent)
    try:
        with os.fdopen(fd,'w') as f: json.dump(payload,f,indent=2,sort_keys=True); f.write('\n')
        os.replace(tmp,path)
    except BaseException:
        os.unlink(tmp); raise

def args():
    ap=argparse.ArgumentParser(description=__doc__)
    ap.add_argument('--domain',required=True)
    ap.add_argument('--model',type=Path,required=True)
    ap.add_argument('--model-label',required=True,choices=('qwen-0.5b','falcon-1b'))
    ap.add_argument('--level2-root',type=Path,default=ROOT/'var/data/modebench_harder_v2_matched')
    ap.add_argument('--output',type=Path,required=True)
    ap.add_argument('--seed',type=int,required=True)
    ap.add_argument('--temperature',type=float,default=1.0)
    ap.add_argument('--top-p',type=float,default=1.0)
    ap.add_argument('--max-tokens',type=int,default=192)
    ap.add_argument('--max-model-len',type=int,default=1024)
    ap.add_argument('--batch-size',type=int,default=8)
    ap.add_argument('--dtype',choices=('float16','bfloat16'),default='float16')
    ap.add_argument('--prompt-profile',choices=('boxed_direct_v1','deliberate_domain_v2','structured_solver_v3','hybrid_solver_v4','countdown_fewshot_v5','countdown_shallow_v6'),default='boxed_direct_v1')
    ap.add_argument('--row-limit',type=int,default=0,help='development-only calibration limit; zero means all 128 rows')
    ap.add_argument('--syntax-profile',choices=('none','pantry_legal_v1','domain_legal_v1','domain_legal_v2','countdown_legal_v3'),default='none')
    return ap.parse_args()

def prompt_messages(domain:str,problem:str,profile:str)->list[dict[str,str]]:
    if profile=='countdown_shallow_v6':
        if domain!='countdown':
            raise ValueError('countdown_shallow_v6 is Countdown-only')
        system=('Use every supplied number exactly once and hit the target exactly. '
                'First test permutations of paired products a*b+c*d or a*b-c*d, '
                'paired sums (a+b)*(c+d) or (a+b)*(c-d), and one product '
                'a*b followed by adding or subtracting c and d. '
                'Return only one fully parenthesized expression inside \\boxed{}.')
        return [{'role':'system','content':system},{'role':'user','content':problem}]
    if profile=='countdown_fewshot_v5':
        if domain!='countdown':
            raise ValueError('countdown_fewshot_v5 is Countdown-only')
        system=('Solve the arithmetic target exactly. Use every supplied number exactly once. '
                'Return only one fully parenthesized expression inside \\boxed{}.')
        return [
          {'role':'system','content':system},
          {'role':'user','content':'Using the numbers [2, 3, 4], create an arithmetic expression that equals 14. Use each given number exactly once.'},
          {'role':'assistant','content':'\\boxed{(2 + (3 * 4))}'},
          {'role':'user','content':'Using the numbers [2, 3, 4, 5], create an arithmetic expression that equals 26. Use each given number exactly once.'},
          {'role':'assistant','content':'\\boxed{((2 * 3) + (4 * 5))}'},
          {'role':'user','content':problem},
        ]
    if profile=='boxed_direct_v1':
        system='Return only the final answer inside \\boxed{}. Do not explain.'
        return [{'role':'system','content':system},{'role':'user','content':problem}]
    deliberate={
      'countdown':'Systematically combine every supplied number exactly once using +, -, *, /, and parentheses. Check the exact target before answering.',
      'python_factors':'Construct one allowed lambda expression. Test small divisors with nested conditional expressions, for example 2 if n % 2 == 0 else 3 if n % 3 == 0 else 5, but adapt the tests to every listed case.',
      'mathir':'Execute candidate menu actions exactly on both sides, simplify after each action, and check that the final state isolates x. Return action IDs, not x.',
      'pantry':'Silently enumerate allowed stepped quantities for 2 to 4 non-forbidden ingredients, total every nutrient exactly, and check all bounds.',
      'graph_coloring':'Check every edge after assigning the hidden vertices.',
    }
    structured={
      'countdown':'Search systematically over pairwise combinations until every number is used exactly once. Verify the arithmetic and output exactly the boxed expression.',
      'python_factors':'Output exactly a boxed lambda. A reliable form is d1 if n == c1 else d2 if n == c2 else d3 if n == c3 else d4, choosing each di as a proper divisor of ci.',
      'mathir':'Use algebraic isolation: move the right-side x term left, remove the left constant, then divide by the combined coefficient. Match those operations to the shuffled menu IDs.',
      'pantry':'Prefer allowed high-energy/protein, very-low-sodium ingredients, especially seeds or oats. Choose stepped amounts, check every bound, and output 2 to 4 ingredient_id=grams pairs.',
      'graph_coloring':'Check every edge after assigning the hidden vertices.',
    }
    if profile=='deliberate_domain_v2':
        guidance=deliberate[domain]
    elif profile=='structured_solver_v3':
        guidance=structured[domain]
    else:
        guidance={
          'countdown':deliberate['countdown']+' Output exactly the boxed expression.',
          'python_factors':deliberate['python_factors']+' You may instead dispatch on each listed value. Output exactly the boxed lambda.',
          'mathir':structured['mathir'],
          'pantry':structured['pantry'],
          'graph_coloring':deliberate['graph_coloring'],
        }[domain]
    system=('Solve the executable constraint problem carefully. You may reason briefly, but end with exactly one final answer inside \\boxed{}. '+guidance)
    return [{'role':'system','content':system},{'role':'user','content':problem}]

def countdown_legal_choices(row:dict)->list[str]:
    """Enumerate syntax-legal expressions without consulting the target or verifier."""
    numbers=tuple(str(int(x)) for x in json.loads(str(row['answer']))['numbers'])
    operators=('+','-','*','/')
    choices=set()
    def trees(values,ops):
        if len(values)==1:
            return (values[0],)
        out=[]
        for split in range(1,len(values)):
            for left in trees(values[:split],ops[:split-1]):
                for right in trees(values[split:],ops[split:]):
                    out.append(f'({left} {ops[split-1]} {right})')
        return tuple(out)
    for values in set(itertools.permutations(numbers)):
        for ops in itertools.product(operators,repeat=len(values)-1):
            choices.update(f'\\boxed{{{expression}}}' for expression in trees(values,ops))
    return sorted(choices)

def countdown_legal_regex(row:dict)->str:
    """Compact target-blind regex for every operand permutation and tree shape."""
    numbers=tuple(str(int(x)) for x in json.loads(str(row['answer']))['numbers'])
    operator=r'[+*/-]'
    def trees(values):
        if len(values)==1:
            return (re.escape(values[0]),)
        out=[]
        for split in range(1,len(values)):
            for left in trees(values[:split]):
                for right in trees(values[split:]):
                    out.append(r'\('+left+' '+operator+' '+right+r'\)')
        return tuple(out)
    expressions=set()
    for values in set(itertools.permutations(numbers)):
        expressions.update(trees(values))
    return r'\\boxed\{(?:'+'|'.join(sorted(expressions))+r')\}'

def sampling_params(a,domain:str,row:dict):
    import vllm
    guided=None
    if a.syntax_profile=='countdown_legal_v3' and domain=='countdown':
        from vllm.sampling_params import GuidedDecodingParams
        guided=GuidedDecodingParams(regex=countdown_legal_regex(row))
    elif a.syntax_profile in ('pantry_legal_v1','domain_legal_v1','domain_legal_v2') and domain=='pantry':
        from vllm.sampling_params import GuidedDecodingParams
        spec=json.loads(str(row['answer']))
        alternatives=[]
        for ingredient in spec['ingredients']:
            ident=str(ingredient['id'])
            minimum=int(ingredient['min_if_used_g'])
            available=int(ingredient['available_g'])
            step=int(ingredient['step_g'])
            for grams in range(minimum,available+1,step):
                alternatives.append(f'{ident}={grams}')
        atom='(?:'+'|'.join(re.escape(x) for x in alternatives)+')'
        regex=r'\\boxed\{'+atom+'(?:;'+atom+r'){1,3}\}'
        guided=GuidedDecodingParams(regex=regex)
    elif a.syntax_profile in ('domain_legal_v1','domain_legal_v2'):
        from vllm.sampling_params import GuidedDecodingParams
        boxed={
          'countdown':r'\\boxed\{[0-9 +*/().-]+\}',
          'python_factors':r'\\boxed\{lambda n: [A-Za-z0-9 _%<>=!+*/().-]+\}',
          'mathir':r'\\boxed\{[A-F](?:;[A-F]){0,3}\}',
        }
        optional={
          'countdown':r'(?:\\boxed\{[0-9 +*/().-]+\}|[0-9][0-9 +*/().-]*)',
          'python_factors':boxed['python_factors'],
          'mathir':r'(?:\\boxed\{[A-F](?:;[A-F]){0,3}\}|[A-F](?:;[A-F]){0,3})',
        }
        regex=(boxed if a.syntax_profile=='domain_legal_v1' else optional).get(domain)
        if regex is not None:
            guided=GuidedDecodingParams(regex=regex)
    return vllm.SamplingParams(n=8,temperature=a.temperature,top_p=a.top_p,max_tokens=a.max_tokens,seed=a.seed,guided_decoding=guided)

def main():
    a=args()
    if a.output.exists(): raise FileExistsError(f'fresh receipt required: {a.output}')
    import vllm
    from datasets import load_from_disk
    from oat_drgrpo.math_grader import validated_modebench_outcome_key
    identity=json.loads((a.level2_root/'identity.json').read_text())
    if identity.get('decision')!='structurally_admitted_pending_frozen_base_model_viability':
        raise RuntimeError('Level-2 structural admission is not frozen and passing')
    if a.domain not in identity['domains']: raise ValueError(a.domain)
    level1=ROOT/identity['level1_reference'][a.domain]['dev']
    rows_by_level={
      'level1':[dict(x) for x in load_from_disk(str(level1))['multi_answer']],
      'level2':[dict(x) for x in load_from_disk(str(a.level2_root/a.domain/'dev'))['multi_answer']],
    }
    if a.row_limit < 0: raise ValueError('row-limit must be nonnegative')
    if a.row_limit: rows_by_level={level:rows[:a.row_limit] for level,rows in rows_by_level.items()}
    llm=vllm.LLM(model=str(a.model.resolve()),dtype=a.dtype,max_model_len=a.max_model_len,gpu_memory_utilization=.82,swap_space=16.0,enable_prefix_caching=True)
    tokenizer=llm.get_tokenizer()
    system='Return only the final answer inside \\boxed{}. Do not explain.'
    results={}
    for level,rows in rows_by_level.items():
        prompts=[tokenizer.apply_chat_template(prompt_messages(a.domain,str(row['problem']),a.prompt_profile),tokenize=False,add_generation_prompt=True) for row in rows]
        outputs=[]
        for start in range(0,len(prompts),a.batch_size):
            batch_rows=rows[start:start+a.batch_size]
            batch_params=[sampling_params(a,a.domain,row) for row in batch_rows]
            outputs.extend(llm.generate(prompts[start:start+a.batch_size],batch_params))
        if len(outputs)!=len(rows): raise RuntimeError('vLLM output count mismatch')
        prompt_results=[]
        for index,(row,out) in enumerate(zip(rows,outputs)):
            if len(out.outputs)!=8: raise RuntimeError(f'{level}/{index}: expected 8 samples')
            attempts=[]
            for sample in out.outputs:
                text=str(sample.text); key=validated_modebench_outcome_key(text,row['answer'])
                attempts.append({'text':text,'verified':key is not None,'canonical_key':key,'token_count':len(sample.token_ids)})
            prompt_results.append({'row_index':index,'passed':any(x['verified'] for x in attempts),'verified_count':sum(x['verified'] for x in attempts),'attempts':attempts})
        success=sum(x['passed'] for x in prompt_results)
        results[level]={'rows':len(rows),'success_prompts':success,'pass_at_8':success/len(rows),'rows_sha256':sha(rows),'prompt_results':prompt_results}
    l1=results['level1']['pass_at_8']; l2=results['level2']['pass_at_8']
    admitted=.10<=l2<=.90 and l2<l1
    payload={'schema':'modebench-level2-paired-base-viability-v1','generated_at':datetime.now(timezone.utc).isoformat(),'status':'pass' if admitted else 'fail','decision':'admit_domain_for_treatment_training' if admitted else 'reject_or_revise_domain_before_training','domain':a.domain,'model_label':a.model_label,'model':str(a.model.resolve()),'model_config_sha256':file_sha(a.model/'config.json'),'level2_identity_sha256':file_sha(a.level2_root/'identity.json'),'sampling':{'sample_count':8,'temperature':a.temperature,'top_p':a.top_p,'max_tokens':a.max_tokens,'max_model_len':a.max_model_len,'dtype':a.dtype,'seed':a.seed,'prompt_template':'model_native_chat_template','prompt_profile':a.prompt_profile,'row_limit':a.row_limit,'syntax_profile':a.syntax_profile},'criteria':{'minimum_level2_pass_at_8':.10,'maximum_level2_pass_at_8':.90,'level2_strictly_lower_than_level1':True},'results':results,'checks':{'level2_not_effectively_zero':l2>=.10,'level2_not_too_easy':l2<=.90,'level2_harder_than_level1':l2<l1},'information_boundary':{'development_only':True,'calibration_only':bool(a.row_limit),'evaluation_prompts_loaded':False,'treatment_training_started':False}}
    atomic(a.output,payload)
    print(json.dumps({'status':payload['status'],'domain':a.domain,'model':a.model_label,'level1_pass_at_8':l1,'level2_pass_at_8':l2,'output':str(a.output)},sort_keys=True))
if __name__=='__main__': main()