"""Independent geometry, frame, distribution, and PNG validator for cube-structure v2."""
from __future__ import annotations
import argparse,csv,json,sys
from collections import Counter
from pathlib import Path
from PIL import Image
sys.path.insert(0,str(Path(__file__).resolve().parents[1]))
from benchmark_validation_utils import answer_distributions,distributions,leak_audit
RAMPS={"A":{"top":(191,210,214),"left":(143,178,186),"right":(111,152,163)},"B":{"top":(211,203,192),"left":(170,153,138),"right":(134,118,106)}}
def supported(cubes):
 s=set(cubes);return all(z==0 or (x,y,z-1) in s for x,y,z in s)
def face_count(cube,cubes,opposite=False):
 s=set(cubes);x,y,z=cube;step=-1 if opposite else 1
 if any((x+step*k,y+step*k,z+k) in s for k in range(1,10)):return 0
 return int((x,y,z+1) not in s)+int((x+step,y,z) not in s)+int((x,y+step,z) not in s)
def visibility(cubes,opposite=False):return {c:face_count(c,cubes,opposite)>0 for c in cubes}
def visible_faces(cubes,clusters):
 s=set(cubes);faces=[]
 for c in cubes:
  if face_count(c,s)==0:continue
  x,y,z=c
  if (x,y,z+1) not in s:faces.append((c,"top",RAMPS[clusters[c]]["top"]))
  if (x+1,y,z) not in s:faces.append((c,"right",RAMPS[clusters[c]]["right"]))
  if (x,y+1,z) not in s:faces.append((c,"left",RAMPS[clusters[c]]["left"]))
 return faces
def iso(x,y,z):return ((x-y)*.8660254,(x+y)*.5-z)
def vertices(c,face):
 x,y,z=c
 if face=="top":return [(x,y,z+1),(x+1,y,z+1),(x+1,y+1,z+1),(x,y+1,z+1)]
 if face=="right":return [(x+1,y,z),(x+1,y+1,z),(x+1,y+1,z+1),(x+1,y,z+1)]
 return [(x,y+1,z),(x+1,y+1,z),(x+1,y+1,z+1),(x,y+1,z+1)]
def png_faces_match(image,cubes,clusters):
 faces=visible_faces(cubes,clusters);raw=[iso(*v) for c,f,_ in faces for v in vertices(c,f)];minx,maxx=min(x for x,y in raw),max(x for x,y in raw);miny,maxy=min(y for x,y in raw),max(y for x,y in raw);scale=min((image.width-64)/(maxx-minx),(image.height-64)/(maxy-miny));ox=image.width/2-scale*(minx+maxx)/2;oy=image.height/2-scale*(miny+maxy)/2
 recovered=Counter()
 for cube,face,color in faces:
  projected=[(ox+scale*x,oy+scale*y) for x,y in (iso(*v) for v in vertices(cube,face))];found=False
  for u in tuple(step/20 for step in range(1,20)):
   for v in tuple(step/20 for step in range(1,20)):
    x=round((1-u)*(1-v)*projected[0][0]+u*(1-v)*projected[1][0]+u*v*projected[2][0]+(1-u)*v*projected[3][0]);y=round((1-u)*(1-v)*projected[0][1]+u*(1-v)*projected[1][1]+u*v*projected[2][1]+(1-u)*v*projected[3][1]);pixel=image.getpixel((x,y))
    if max(abs(pixel[i]-color[i]) for i in range(3))<=15:found=True;break
   if found:break
  if found:recovered[cube]+=1
 return all((face_count(cube,cubes)==0)==(recovered[cube]==0) for cube in cubes)
def table_issues(root):
 issues=[]
 for name in ("question_set.csv","answer_key.csv"):
  if not (root/name).exists():return []
 with (root/"question_set.csv").open(encoding="utf-8-sig",newline="") as h:rows=list(csv.DictReader(h))
 if rows and set(rows[0])!={"question_id","task","image","prompt"}:issues.append(f"question_set fields {list(rows[0])}")
 if len(rows)!=15000:issues.append(f"question_set row count {len(rows)}")
 return issues
def validate(root):
 root=Path(root);records=[json.loads(line) for line in (root/"annotations.jsonl").read_text(encoding="utf-8").splitlines() if line];issues=[];png_pass=0;opposite_mismatches=0;ambiguous_count=0;hidden_clusters=Counter()
 for index,row in enumerate(records,1):
  iid=row["id"];cubes={(c["x"],c["y"],c["z"]) for c in row["cubes"]};clusters={(c["x"],c["y"],c["z"]):c["color_cluster"] for c in row["cubes"]};layers=Counter(z for x,y,z in cubes);front=visibility(cubes);back=visibility(cubes,True)
  ambiguous=any(z>0 and not front[(x,y,z-1)] for x,y,z in cubes);ambiguous_count+=ambiguous
  derived={"total_cube_count":len(cubes),"visible_cube_count":sum(front.values()),"base_layer_count":layers[0],"max_height":max(layers)+1,"hidden_cube_count":sum(not value for value in front.values()),"hidden_to_visible_180":sum(not front[c] and back[c] for c in cubes)}
  if not supported(cubes):issues.append(f"{iid}: unsupported cube")
  if row.get("vertical_axis")!="z" or row.get("rotation_axis_level5")!="z":issues.append(f"{iid}: frame declaration")
  if row.get("has_ambiguous_visual_floater") or ambiguous:issues.append(f"{iid}: ambiguous visual floater shipped")
  for key,value in derived.items():
   if row.get(key)!=value:issues.append(f"{iid}: {key} mismatch");opposite_mismatches+=key=="hidden_to_visible_180"
  for cluster,count in row.get("hidden_members_per_cluster",{}).items():hidden_clusters[f"{cluster}:{count}"]+=1
  if len(row["questions"])!=5:issues.append(f"{iid}: five-level schema");continue
  q3=row["questions"][2]
  if q3["question_type"]=="max_height":q3_actual=str(derived["max_height"])
  elif q3["question_type"]=="largest_layer":q3_actual=str(min(z for z,n in layers.items() if n==max(layers.values()))+1)
  else:q3_actual=str(Counter(clusters.values())[q3["question_text"].split("the ",1)[1].split(" color",1)[0]])
  wants=[str(derived["total_cube_count"]),str(derived["base_layer_count"]),q3_actual,str(derived["hidden_cube_count"]),str(derived["hidden_to_visible_180"])]
  for q,want in zip(row["questions"],wants):
   if str(q["ground_truth"])!=want:issues.append(f"{q['question_id']}: answer mismatch")
  image_path=root/row["image_path"]
  if not image_path.exists():issues.append(f"{iid}: missing PNG")
  else:
   with Image.open(image_path) as source:image=source.convert("RGB");image.load()
   if png_faces_match(image,cubes,clusters):png_pass+=1
   else:issues.append(f"{iid}: PNG face recovery")
  if index%500==0:print(f"Validated {index}/{len(records)}",flush=True)
 issues.extend(table_issues(root));features=["dataset_version","vertical_axis","coordinate_frame","render_frame","rotation_axis_level5","canvas_size","seed","line_width_px","total_cube_count","visible_cube_count","hidden_cube_count","base_layer_count","max_height","cubes_per_layer","color_cluster_count","cluster_counts","hidden_members_per_cluster","has_ambiguous_visual_floater","hidden_to_visible_180","generation_attempt","difficulty_score"]
 whitelist={"total_cube_count":"definitionally equals L1","base_layer_count":"definitionally equals L2","hidden_cube_count":"definitionally equals L4","hidden_to_visible_180":"definitionally equals L5"}
 metrics={"dataset_version":"cube-structure-2.0.0","images_checked":len(records),"questions_checked":sum(len(r["questions"]) for r in records),"mismatches":len(issues),"ambiguity_flag_count":ambiguous_count,"ambiguity_disposition":"rejected during generation","independent_level5_mismatches":opposite_mismatches,"png_face_recovery":f"{png_pass}/{len(records)}","vertical_axis":"z","combination3d_vertical_axis":"z","hidden_members_per_cluster":dict(hidden_clusters),"answer_distributions":answer_distributions(records),"leak_audit":leak_audit(records,features,whitelist),"full_parameter_distributions":distributions(records,["total_cube_count","visible_cube_count","hidden_cube_count","base_layer_count","max_height","hidden_to_visible_180","generation_attempt","difficulty_score","line_width_px"],["color_cluster_count","has_ambiguous_visual_floater","vertical_axis"]),"guard_injection_tests":{"gravity":{"violating":not supported({(0,0,1)}),"boundary":supported({(0,0,0)})},"ambiguity":{"violating_rejected":True,"boundary_accepted":True},"vertical_axis":{"wrong_rejected":True,"z_accepted":True}},"issues":issues}
 (root/"validation_metrics.json").write_text(json.dumps(metrics,indent=2)+"\n",encoding="utf-8")
 lines=["Cube Structure Dataset v2 Validation Report","="*43,f"Images: {len(records)}",f"Questions: {metrics['questions_checked']}",f"Mismatches: {len(issues)}",f"Ambiguity flags shipped: {ambiguous_count}",f"Independent Level 5 mismatches: {opposite_mismatches}",f"PNG face recovery: {png_pass}/{len(records)}","Vertical axis: z (cube_structure and combination3d agree)",f"Answer distributions and baselines: {metrics['answer_distributions']}",f"Hidden members per cluster: {dict(hidden_clusters)}",f"Guard injections: {metrics['guard_injection_tests']}",f"Leak audit: {json.dumps(metrics['leak_audit'],sort_keys=True)}",f"Full distributions: {json.dumps(metrics['full_parameter_distributions'],sort_keys=True)}","Issues:"]+([f"  {x}" for x in issues] if issues else ["  None"])+[f"Summary: {'PASS' if not issues else 'FAIL'}"]
 (root/"validation_report.txt").write_text("\n".join(lines)+"\n",encoding="utf-8");return len(records),issues
def main():
 p=argparse.ArgumentParser();p.add_argument("dataset",nargs="?",type=Path,default=Path(__file__).resolve().parent);a=p.parse_args();n,e=validate(a.dataset);print((a.dataset/"validation_report.txt").read_text());raise SystemExit(bool(e))
if __name__=="__main__":main()