"""Independent analytic, question, distribution, and rendered-PNG validation."""
import argparse,json,math
from collections import Counter
from pathlib import Path
from PIL import Image

RAY=(83,190,205);ARC=(242,174,75);SCENES=('single','comparison','triangle')
def angle(v,p1,p2):
    a=(p1[0]-v[0],p1[1]-v[1]);b=(p2[0]-v[0],p2[1]-v[1]);return math.degrees(math.acos(max(-1,min(1,(a[0]*b[0]+a[1]*b[1])/(math.hypot(*a)*math.hypot(*b))))))
def marked(v,p1,p2,reflex):
    m=angle(v,p1,p2);return 360-m if reflex else m
def triangle_angles(vertices):return [angle(vertices[0],vertices[1],vertices[2]),angle(vertices[1],vertices[0],vertices[2]),angle(vertices[2],vertices[0],vertices[1])]
def nearest(x,step):return int(math.floor(x/step+.5)*step)
def class90(x):return 'right' if abs(x-90)<=2 else 'acute' if x<90 else 'obtuse'
def color_near(im,p,target,radius=3):
    x,y=p
    for yy in range(max(0,round(y)-radius),min(im.height,round(y)+radius+1)):
        for xx in range(max(0,round(x)-radius),min(im.width,round(x)+radius+1)):
            q=im.getpixel((xx,yy))
            if sum((q[i]-target[i])**2 for i in range(3))<85**2:return True
    return False
def line_samples(a,b):return [(a[0]+(b[0]-a[0])*t,a[1]+(b[1]-a[1])*t) for t in (.15,.35,.55,.75,.92)]
def arc_samples(v,p1,sweep,radius):
    theta=math.atan2(p1[1]-v[1],p1[0]-v[0]);return [(v[0]+radius*math.cos(theta+math.radians(sweep)*t),v[1]+radius*math.sin(theta+math.radians(sweep)*t)) for t in (.15,.35,.55,.75,.9)]
def verify_angle_png(im,v,p1,p2,sweep):
    if sum(color_near(im,p,RAY) for p in line_samples(v,p1))<3 or sum(color_near(im,p,RAY) for p in line_samples(v,p2))<3:return 'ray segment missing'
    radius=min(math.dist(v,p1),math.dist(v,p2))*.23
    if sum(color_near(im,p,ARC,4) for p in arc_samples(v,p1,sweep,radius))<4:return 'marked arc/sweep mismatch'
    return None
def expected_question(q,row):
    t=q['question_type'];scene=row['scene_type']
    if scene=='single':
        a=row['angle_degrees'];values={'single_angle_class':class90(a),'single_angle_nearest_15':str(nearest(a,15)),'single_vs_right':'approximately equal to' if abs(a-90)<=5 else 'less than' if a<90 else 'greater than','distance_from_straight_angle':str(round(abs(a-180))),'single_doubled':'less than 180' if a*2<180 else 'exceeds 180'}
    elif scene=='comparison':
        a,b=row['angle_1_degrees'],row['angle_2_degrees'];s=a+b;small,large=sorted((a,b));values={'shown_angle_count':'2','larger_angle':'Angle 1' if a>b else 'Angle 2','angle_difference_nearest_10':str(nearest(abs(a-b),10)),'angle_sum_bucket':'right' if abs(s-90)<=15 else 'straight' if abs(s-180)<=15 else 'neither','double_smaller_angle_compare':'larger' if 2*small>large else 'equal to' if abs(2*small-large)<1e-9 else 'smaller'}
    else:values={'triangle_vertex_count':'3','triangle_class':row['triangle_class'],'largest_triangle_angle':row['largest_angle_vertex'],'triangle_angle_sum':'180','increase_triangle_angle_validity':'190,no'}
    return values[t]
def validate(root,report):
    root=Path(root);rows=[];errors=[]
    for n,line in enumerate((root/'annotations.jsonl').open(encoding='utf8'),1):
        try:rows.append(json.loads(line))
        except Exception as exc:errors.append(f'line {n}: invalid JSON: {exc}')
    scenes=Counter();classes=Counter();templates=Counter()
    for row in rows:
        iid=row.get('id','unknown');scene=row.get('scene_type');scenes[scene]+=1
        def fail(msg):errors.append(f'{iid}: {msg}')
        path=root/row.get('image_path','')
        if not path.is_file():fail('image missing');continue
        im=Image.open(path).convert('RGB')
        if list(im.size)!=row['canvas_size']:fail('canvas size mismatch')
        if scene=='single':
            v=tuple(row['vertex']);p1,p2=map(tuple,row['ray_endpoints']);actual=marked(v,p1,p2,row['marked_sweep']=='reflex')
            if abs(actual-row['angle_degrees'])>1e-5 or abs(actual-row['arc_sweep_degrees'])>1e-5:fail('single angle geometry mismatch')
            issue=verify_angle_png(im,v,p1,p2,row['arc_sweep_degrees'])
            if issue:fail(issue)
        elif scene=='comparison':
            computed=[]
            for j,a in enumerate(row['angles']):
                v=tuple(a['vertex']);p1,p2=map(tuple,a['ray_endpoints']);actual=angle(v,p1,p2);computed.append(actual)
                if abs(actual-a['angle_degrees'])>1e-5:fail(f'comparison angle {j+1} geometry mismatch')
                issue=verify_angle_png(im,v,p1,p2,a['arc_sweep_degrees'])
                if issue:fail(f'angle {j+1}: {issue}')
            if abs(computed[0]-row['angle_1_degrees'])>1e-5 or abs(computed[1]-row['angle_2_degrees'])>1e-5 or abs(computed[0]-computed[1])<5:fail('comparison metadata/separation mismatch')
        elif scene=='triangle':
            vertices=list(map(tuple,row['triangle_vertices']));computed=triangle_angles(vertices);classes[row['triangle_class']]+=1
            if max(abs(a-b) for a,b in zip(computed,row['interior_angles_degrees']))>1e-5:fail('triangle angle geometry mismatch')
            if abs(sum(computed)-180)>1e-7:fail('triangle angles do not sum to 180')
            klass='right' if any(abs(x-90)<=2 for x in computed) else 'acute' if max(computed)<90 else 'obtuse'
            if klass!=row['triangle_class']:fail('triangle class mismatch')
            labels='ABC'
            if labels[max(range(3),key=lambda i:computed[i])]!=row['largest_angle_vertex'] or labels[min(range(3),key=lambda i:computed[i])]!=row['smallest_angle_vertex']:fail('largest/smallest vertex mismatch')
            for a,b in zip(vertices,vertices[1:]+vertices[:1]):
                if sum(color_near(im,p,RAY) for p in line_samples(a,b))<3:fail('rendered triangle edge missing');break
        else:fail('invalid scene_type')
        qs=row.get('questions',[])
        if len(qs)!=5 or [q.get('difficulty_level') for q in qs]!=[1,2,3,4,5]:fail('question structure mismatch')
        for q in qs:
            templates[(q.get('difficulty_level'),q.get('question_type'))]+=1
            try:expected=expected_question(q,row)
            except Exception as exc:fail(f"{q.get('question_id')} cannot be checked: {exc}");continue
            if str(q.get('ground_truth'))!=expected:fail(f"{q.get('question_id')} answer mismatch")
    if len(rows)==3000:
        expected={'single':1200,'comparison':1050,'triangle':750}
        if dict(scenes)!=expected:errors.append(f'dataset: scene distribution mismatch {dict(scenes)}')
        if classes!=Counter({'acute':250,'right':250,'obtuse':250}):errors.append(f'dataset: triangle class distribution mismatch {dict(classes)}')
    lines=[f'Total images checked: {len(rows)}',f'Total mismatches found: {len(errors)}',f'Scene distribution: {dict(sorted(scenes.items()))}',f'Triangle-class distribution: {dict(sorted(classes.items()))}','Question template counts:']
    lines.extend(f'  Level {l} / {t}: {n}' for (l,t),n in sorted(templates.items()));lines+=['','Mismatches:'];lines.extend(errors or ['  None']);lines+=['',f"Summary: {'PASS' if not errors else 'FAIL'}"]
    Path(report).write_text('\n'.join(lines)+'\n',encoding='utf8');print('\n'.join(lines[:4]));print(lines[-1]);return not errors
def main():
    p=argparse.ArgumentParser();p.add_argument('--dataset-dir',default='.');p.add_argument('--report',default='validation_report.txt');a=p.parse_args();root=Path(a.dataset_dir);report=Path(a.report);report=report if report.is_absolute() else root/report;raise SystemExit(0 if validate(root,report) else 1)
if __name__=='__main__':main()