"""Independent V3 validator. Does not import build.py or transformation functions."""
import json,re,html,hashlib,sys,copy,importlib.util
from pathlib import Path
from collections import Counter,defaultdict
from html.parser import HTMLParser
from jsonschema import Draft202012Validator
from huggingface_hub import hf_hub_download
def encoded(x):return json.dumps(x,sort_keys=True,ensure_ascii=False,separators=(',',':'),allow_nan=False)
def digest(x):return hashlib.sha256((x if isinstance(x,str) else encoded(x)).encode()).hexdigest()
def strict(s):
    def pairs(xs):
        d={}
        for k,v in xs:
            if k in d:raise ValueError('duplicate JSON key')
            d[k]=v
        return d
    return json.loads(s,object_pairs_hook=pairs,parse_constant=lambda s:(_ for _ in ()).throw(ValueError('nonfinite number')))
def readrows(p):return [strict(s) for s in p.read_text('utf-8').splitlines() if s.strip()]
def require(v,message):
    if not v:raise ValueError(message)
def module(path,name):
    spec=importlib.util.spec_from_file_location(name,path);m=importlib.util.module_from_spec(spec);spec.loader.exec_module(m);return m
def originals(folder):
    result={};lock=json.loads((folder/'SOURCE_LOCK.json').read_text())
    wanted=defaultdict(set)
    for r in readrows(folder/'dataset.jsonl'):wanted[r['provenance']['source_dataset']].add(r['provenance']['source_record_id'])
    for s in lock:
        repo=s['repo_id']
        if repo:
            p=Path(hf_hub_download(repo,s['data_file'],repo_type='dataset',revision=s['commit']))
            expected=s['files']['dataset.jsonl']['sha256'];require(hashlib.sha256(p.read_bytes()).hexdigest()==expected,'source snapshot hash mismatch')
        else:p=folder/s['data_file'];repo='RegalFire/'+s['name']
        for line in p.open(encoding='utf-8'):
            r=strict(line);key=str(r.get('id',r.get('record_id',r.get('thread_id'))))
            if key in wanted[repo]:result[(repo,key)]=r
    return result
def thread(s):return s.get('thread',s)
def question(s):t=thread(s);return t.get('question_text'),t.get('question_html'),t.get('source_url',t.get('thread_url'))
class Links(HTMLParser):
    def __init__(self):super().__init__(convert_charrefs=True);self.urls=[]
    def handle_starttag(self,tag,attrs):
        if tag=='a':
            self.urls.extend(v for k,v in attrs if k=='href' and v and v.startswith(('http://','https://')))
def literal_blocks(body):
    result=[]
    for raw in re.findall(r'<pre\b[^>]*>(.*?)</pre\s*>',body,re.S|re.I):
        raw=re.sub(r'<br\s*/?>','\n',raw,flags=re.I)
        result.append(html.unescape(re.sub(r'<[^>]+>','',raw)))
    return result
def scientific(r,s):
    t=thread(s);text,body,url=question(s);aa=t['answers'];require(r['provenance']['source_url']==url,'thread URL mismatch')
    require(r['provenance']['original_provenance']==t['provenance'],'original provenance changed')
    require(r['provenance']['revision_attribution']==t['revision_attribution'],'revision contributors changed')
    require(r['content_license']==t['question_license']=='CC BY-SA 4.0','question license mismatch')
    require(all(a['content_license']=='CC BY-SA 4.0' for a in aa),'answer license not approved')
    if r['id'].startswith('SCT'):
        require(r['problem_text']==text and r['question_html']==body and r['question_title']==t['title'],'question content changed')
        require(bool(r['code_blocks']),'no code')
        posts={str(t.get('question_id',t.get('thread_id'))):body,**{str(a['answer_id']):a['answer_html'] for a in aa}}
        for b in r['code_blocks']:
            source=posts.get(str(b['post_id']),body)
            blocks=literal_blocks(source);require(b['block_index']<len(blocks) and b['code_text']==blocks[b['block_index']],'code extraction mismatch')
            require(digest(b['code_text'])==b['sha256'],'code hash mismatch')
        expected_error=[line.strip() for line in text.splitlines() if re.match(r'^\s*(?:[A-Za-z]+Error:|Error(?: in .*?)?:|Warning:|Traceback \(most recent call last\):)',line)] or None
        require(r['error_text_if_explicit']==expected_error,'fabricated error')
        if r['attempted_method_if_explicit'] is not None:require(r['attempted_method_if_explicit'] in text and r['attempted_method_if_explicit'].startswith(('I tried ','I attempted ')),'fabricated attempt')
        require(r['answer_scores']==[{'answer_id':a['answer_id'],'score':a['score']} for a in aa],'answer scores mismatch')
        require(r['author_attribution']['question_author']==t['question_author'] and r['author_attribution']['question_author_url']==t['question_author_url'],'question attribution changed')
        answers=r['answers'];accepted=r['accepted_answer']
    else:
        require(r['query']==t['title']+'\n'+text,'query changed')
        expected=[text]+[a['answer_text'] for a in aa]
        require([c['text'] for c in r['contexts']]==expected,'context changed')
        require(len(r['context_sources'])==len(expected),'missing context attribution')
        for c in r['context_sources']:require(c['content_license']=='CC BY-SA 4.0' and c['author'] is not None and 'revision_attribution' in c,'missing attribution')
        accepted=next((a for a in aa if a['is_accepted']),None);families=[]
        parser=Links();parser.feed(body)
        for a in aa:parser.feed(a['answer_html'])
        citations=sorted(set(parser.urls));require(r['external_citations']==citations,'citations invented or dropped')
        if not accepted:families.append('no_accepted_answer')
        if accepted and max(a['score'] for a in aa)>accepted['score']:families.append('accepted_vs_highest_score_disagreement')
        if len(citations)>=2:families.append('multiple_sources')
        if len(citations)>=5:families.append('citation_heavy')
        if len(aa)>=2:families.append('multiple_answer_candidates')
        if int(t['question_created_at'][:4])<=2021:families.append('old_thread_metadata')
        require(r['hard_case_family']==families,'unsupported family')
        require(r['accepted_status']['accepted_answer_id']==(accepted['answer_id'] if accepted else None),'acceptance mismatch')
        require(r['ground_truth_type']=='metadata_grounded' and r['oracle']['canonical_answer'] is None and r['accepted_status']['scientific_correctness_verified'] is False,'unsupported scientific truth')
        require(r['scores']==[{'answer_id':a['answer_id'],'score':a['score']} for a in aa],'scores mismatch')
        answers=r['candidate_answers']
    require(len(answers)==len(aa),'answer count mismatch')
    for a,b in zip(answers,aa):
        for key in ['answer_id','question_id','answer_text','answer_html','content_license','answer_url','score','is_accepted','revision_attribution','provenance']:
            require(a[key]==b[key],'answer field mismatch: '+key)
        require(a['author']==b.get('author',b.get('author_display_name')) and a['author_url']==b.get('author_url',b.get('author_profile_url')),'answer attribution mismatch')
    if r['id'].startswith('SCT'):
        expected=next((a for a in answers if a['is_accepted']),None);require(accepted==expected,'accepted answer invented')
def agent(r,s,nav,physics,horizon):
    domain=r['domain'];available=True
    if domain=='navigation':
        nav.nav(s['input'],s['expected']);i=s['input'];before=s['expected']['before'];after=s['expected']['after'];grid=list(i['grid']);y,x=i['edit'];line=list(grid[y]);line[x]='#';grid[y]=''.join(line)
        require(i['grid'][y][x]=='.' and i['edit'] in before['path'],'no explicit invalid legacy path')
        require(r['initial_state']=={'grid':i['grid'],'costs':i['costs'],'position':i['start']},'initial state mismatch')
        failed={'grid':grid,'costs':i['costs'],'position':i['start']};require(r['failure_state']==failed,'failure state mismatch')
        require(r['action_history']==[{'action':'submit_path','path':before['path'],'result':'rejected_atomically_blocked_cell','state_unchanged':True}],'history mismatch')
        available=after['path'] is not None;seq=after['path'][1:] if available else [];action={'action':'follow_path','path':after['path']} if available else None;final={**failed,'position':i['goal']} if available else failed;cost={'cost':after['cost'],'steps':len(seq) if available else None};failure='legacy_path_blocked_by_critical_edit';goal={'position':i['goal']}
    elif domain=='multi_agent':
        nav.coord(s['input'],s['expected']);i=s['input'];plan=s['expected']['plan'];available=plan is not None
        initial={'grid':i['grid'],'positions':i['starts']};require(r['initial_state']==initial and r['failure_state']==initial,'joint state mismatch')
        require(i['starts']!=i['goals'],'stop was not a failure')
        require(r['action_history']==[{'action':'stop','result':'rejected_goals_unsatisfied','state_unchanged':True}],'joint history mismatch')
        seq=plan[1:] if plan else [];action={'action':'execute_joint_plan','plan':plan} if plan else None;final={'grid':i['grid'],'positions':i['goals']} if plan else initial;cost={'cost':s['expected']['optimal_makespan'],'steps':len(seq) if plan else None};failure='premature_stop_goals_unsatisfied';goal={'positions':i['goals'],'vertex_collision_forbidden':True,'edge_swap_forbidden':True,'absorbing_goals':True}
    elif domain=='counterfactual':
        truth=physics.truth(s);require(physics.compare(truth,s['expected_state_t1']) and not physics.compare(truth,s['counterfactual_state_t1']),'physics source labels invalid')
        require(r['initial_state']=={'state_t0':s['state_t0'],'action':s['action'],'dt':s['dt']},'physics initial mismatch')
        require(r['failure_state']=={'predicted_state_t1':s['counterfactual_state_t1']},'physics failure mismatch')
        require(r['action_history']==[{'action':'submit_prediction','prediction':s['counterfactual_state_t1'],'result':'rejected_analytical_inconsistency'}],'physics history mismatch')
        action={'action':'replace_prediction','prediction':s['expected_state_t1']};seq=[action];final={'predicted_state_t1':s['expected_state_t1']};cost={'cost':1,'steps':1};failure='analytically_inconsistent_'+s['counterfactual_changed_field'];goal={'prediction_matches_analytical_transition':True}
    elif domain=='planning':
        correct,final=horizon.oracle(s);require(correct==s['optimal_action'] and final==s['expected_state_t1'],'planning source oracle mismatch')
        require(r['initial_state']==s['observation']['state'] and r['failure_state']==s['observation']['state'],'planning initial/failure mismatch')
        h=r['action_history'];require(len(h)==1 and h[0]['action'] in s['available_actions'] and h[0]['action']!=correct and h[0]['result']=='rejected_policy_mismatch' and h[0]['state_unchanged'] is True,'failure action not a wrong policy action')
        action={'action':correct};seq=[action];cost={'cost':1,'steps':1};failure='next_step_policy_mismatch';goal={'short_horizon':s['success_condition'],'full_long_horizon_goal_claimed':False}
    else:raise ValueError('unknown agent domain')
    require(r['goal']==goal and r['failure_type']==failure,'failure/goal labels mismatch')
    require(r['recovery_available'] is available and r['success'] is available,'success/availability mismatch')
    require(r['recovery_action']==action and r['recovery_sequence']==seq and r['final_state']==final and r['cost_or_steps']==cost,'recovery trajectory mismatch')
    require(r['oracle']['source_family']==s['family'] and r['oracle']['source_input']==s.get('input') and r['oracle']['source_expected']==s.get('expected'),'oracle metadata mismatch')
def validate(folder,records=None):
    folder=Path(folder);data=readrows(folder/'dataset.jsonl') if records is None else records
    sources=originals(folder);schema=Draft202012Validator(json.loads((folder/'schema.json').read_text()))
    vendor=folder/'validator'/'vendor';sys.path.insert(0,str(vendor))
    nav=module(vendor/'nav_check.py','nav_check') if (vendor/'nav_check.py').exists() else None
    physics=module(vendor/'physics.py','physics') if (vendor/'physics.py').exists() else None
    horizon=module(vendor/'horizon.py','horizon') if (vendor/'horizon.py').exists() else None
    gcc=module(vendor/'gcc.py','gcc') if (vendor/'gcc.py').exists() else None
    ids=set();semantic=set();groups={};templates={};procedural={};textsplits={};errors=[];question_grams=[]
    for index,r in enumerate(data):
        try:
            schema.validate(r);require(r['id'] not in ids,'duplicate id');ids.add(r['id'])
            body={k:v for k,v in r.items() if k not in ['id','provenance','group_id','split']};h=digest(body);require(h not in semantic,'exact semantic duplicate');semantic.add(h)
            p=r['provenance'];key=(p['source_dataset'],p['source_record_id']);require(key in sources,'missing source relation');s=sources[key];require(digest(s)==p['source_record_sha256'],'source record hash mismatch')
            require(r['content_license']==p['source_license'],'license mismatch')
            require(groups.setdefault(r['group_id'],r['split'])==r['split'],'group leakage')
            if r['id'].startswith('AFR'):
                require(templates.setdefault((r['domain'],r['task_type']),r['split'])==r['split'],'template leakage')
                if p.get('procedural_group_id'):require(procedural.setdefault(p['procedural_group_id'],r['split'])==r['split'],'procedural grid leakage')
                agent(r,s,nav,physics,horizon)
            elif p['source_dataset'].endswith('GCC-RAG-HardCases'):
                truth=gcc.oracle(s)
                require(all(s['expected'][k]==v for k,v in truth.items()),'independent GCC oracle mismatch')
                require(r['query']==s['query'] and r['oracle']==s['expected'],'GCC source oracle/query mismatch')
                require(r['hard_case_family']==['gcc_'+s['family']] and r['ground_truth_type']=='deterministic_source_grounded','GCC family/truth mismatch')
                require([c['text'] for c in r['contexts']]==[d['content'] for d in s['documents']],'GCC context mismatch')
                require(r['candidate_answers']==([{'answer_text':s['expected']['answer']}] if s['expected']['answerable'] else []),'GCC answer mismatch')
                require(r['external_citations']==[] and len(r['context_sources'])==len(s['documents']) and all(c['synthetic'] and c['content_license']=='MIT' for c in r['context_sources']),'GCC sources/citations invalid')
                require(templates.setdefault(s['family'],r['split'])==r['split'],'GCC template leakage')
            else:
                scientific(r,s)
                t=thread(s)
                words=re.sub(r'[^\w]+',' ',t['question_text'].lower()).split();grams={tuple(words[j:j+5]) for j in range(len(words)-4)}
                for prior,split in question_grams:
                    if prior and grams and len(prior&grams)/len(prior|grams)>=.85:require(split==r['split'],'near-duplicate question split leakage')
                question_grams.append((grams,r['split']))
                for text in [t['question_text']]+[a['answer_text'] for a in t['answers']]:
                    normal=re.sub(r'[^\w]+',' ',text.lower()).strip()
                    if len(normal)>=50:require(textsplits.setdefault(digest(normal),r['split'])==r['split'],'shared text leakage')
        except Exception as e:errors.append({'id':r.get('id'),'line':index+1,'reason':str(e)})
    if records is None:
        splitrows=[r for name in ['train','validation','test','holdout'] for r in readrows(folder/(name+'.jsonl'))]
        require(Counter(encoded(r) for r in splitrows)==Counter(encoded(r) for r in data),'split files do not partition dataset exactly')
    return {'status':'PASS' if not errors else 'FAIL','records':len(data),'independently_checked':len(data)-len(errors),'unique_ids':len(ids),'semantic_duplicates':len(data)-len(semantic),'group_count':len(groups),'splits':dict(Counter(r['split'] for r in data)),'errors':errors,'validation_scope':'Schema, strict UTF-8/JSON, identities, exact semantic duplicates, source hashes/relationships, attribution, labels, independent computational oracles, recovery replay and grouped split leakage','near_duplicate_policy':'Scientific normalized text and question 5-shingle grouping; synthetic whole-template groups plus source symmetry-grid grouping. No claim of exhaustive semantic deduplication.'}
if __name__=='__main__':
    folder=Path(sys.argv[1]) if len(sys.argv)>1 else Path(__file__).resolve().parents[1]
    report=validate(folder);(folder/'validation_report.json').write_text(json.dumps(report,indent=2)+'\n',encoding='utf-8');print(json.dumps({k:v for k,v in report.items() if k!='errors'}));sys.exit(0 if report['status']=='PASS' else 1)