import argparse,json,random
from pathlib import Path
from PIL import Image,ImageDraw,ImageFont

BG=(26,26,26);INK=(220,222,224);AA=3;CHOICES='ABCD';DIRS=((1,0),(-1,0),(0,1),(0,-1))
def canonical(cells):
 cells=set(map(tuple,cells));mx=min(x for x,y in cells);my=min(y for x,y in cells);return tuple(sorted((x-mx,y-my) for x,y in cells))
def rotations(cells,reflect=False):
 base=[(-x,y) if reflect else (x,y) for x,y in cells];out=set()
 for k in range(4):
  q=[]
  for x,y in base:
   for _ in range(k):x,y=-y,x
   q.append((x,y))
  out.add(canonical(q))
 return sorted(out)
def all_orientations(cells,allow_reflection):
 out=set(rotations(cells,False))
 if allow_reflection:out.update(rotations(cells,True))
 return sorted(out)
def placements(piece,target,allow_reflection):
 target=set(target);out=set()
 for shape in all_orientations(piece,allow_reflection):
  anchor=shape[0]
  for tx,ty in target:
   placed=frozenset((x-anchor[0]+tx,y-anchor[1]+ty) for x,y in shape)
   if placed<=target:out.add(placed)
 return sorted(out,key=lambda x:sorted(x))
def try_assemble(pieces,target,allow_reflection=False):
 target=frozenset(target)
 if sum(len(p) for p in pieces)!=len(target):return False
 opts=[placements(p,target,allow_reflection) for p in pieces]
 if any(not x for x in opts):return False
 order=sorted(range(len(pieces)),key=lambda i:len(opts[i]))
 def rec(k,used):
  if k==len(order):return used==target
  return any(rec(k+1,used|p) for p in opts[order[k]] if not used&p)
 return rec(0,frozenset())
def connected(cells):
 cells=set(cells);seen={next(iter(cells))};stack=list(seen)
 while stack:
  x,y=stack.pop()
  for dx,dy in DIRS:
   q=(x+dx,y+dy)
   if q in cells and q not in seen:seen.add(q);stack.append(q)
 return len(seen)==len(cells)
def grow_polyomino(n,rng):
 if n==1:return ((0,0),)
 while True:
  cells={(0,0)}
  while len(cells)<n:
   x,y=rng.choice(tuple(cells));dx,dy=rng.choice(DIRS);cells.add((x+dx,y+dy))
  c=canonical(cells);w=max(x for x,y in c)+1;h=max(y for x,y in c)+1
  if n==2 or (w>=2 and h>=2):return c
def partition(target,k,rng):
 target=set(target);root=rng.choice(tuple(target));seen={root};tree=[];stack=[root]
 while stack:
  p=stack[-1];nbr=[(p[0]+dx,p[1]+dy) for dx,dy in DIRS if (p[0]+dx,p[1]+dy) in target and (p[0]+dx,p[1]+dy) not in seen]
  if nbr:q=rng.choice(nbr);seen.add(q);tree.append((p,q));stack.append(q)
  else:stack.pop()
 cuts=set(rng.sample(range(len(tree)),k-1));adj={p:[] for p in target}
 for i,(a,b) in enumerate(tree):
  if i not in cuts:adj[a].append(b);adj[b].append(a)
 comps=[];left=set(target)
 while left:
  s=left.pop();comp={s};todo=[s]
  while todo:
   p=todo.pop()
   for q in adj[p]:
    if q in left:left.remove(q);comp.add(q);todo.append(q)
  comps.append(canonical(comp))
 return comps if len(comps)==k and min(map(len,comps))>=1 else partition(target,k,rng)
def reflected_pieces(pieces):return [canonical([(-x,y) for x,y in p]) for p in pieces]
def near_miss(total,target,rng):
 for _ in range(2000):
  k=rng.randint(2,min(4,total-1));cuts=sorted(rng.sample(range(1,total),k-1));sizes=[b-a for a,b in zip([0]+cuts,cuts+[total])]
  p=[grow_polyomino(n,rng) for n in sizes]
  if not try_assemble(p,target,False) and not try_assemble(p,target,True):return p
 raise RuntimeError('unable to create equal-area near miss')
def wrong_area(pieces,rng):
 p=[list(x) for x in pieces];i=max(range(len(p)),key=lambda j:len(p[j]));cells=set(p[i]);removable=[c for c in cells if len(cells)>1 and connected(cells-{c})]
 if removable:cells.remove(rng.choice(removable));p[i]=list(canonical(cells))
 else:p.append([(0,0)])
 return [canonical(x) for x in p]
def build_geometry(rng,n):
 for _ in range(400):
  target=grow_polyomino(n,rng);k=rng.randint(2,min(4,n-2));correct=partition(target,k,rng);mirror=reflected_pieces(correct)
  if try_assemble(correct,target,False) and not try_assemble(mirror,target,False) and try_assemble(mirror,target,True):
   miss=near_miss(n,target,rng);wrong=wrong_area(correct,rng)
   if not try_assemble(miss,target,False) and sum(map(len,wrong))!=n:return target,correct,miss,wrong,mirror
 raise RuntimeError('unable to construct verified puzzle')
def font(size):
 p=Path('C:/Windows/Fonts/arialbd.ttf');return ImageFont.truetype(str(p),size) if p.exists() else ImageFont.load_default()
def bounds(cells):return max(x for x,y in cells)+1,max(y for x,y in cells)+1
def draw_cells(d,cells,ox,oy,cell):
 for x,y in cells:d.rectangle((round((ox+x*cell)*AA),round((oy+y*cell)*AA),round((ox+(x+1)*cell)*AA),round((oy+(y+1)*cell)*AA)),outline=INK,width=max(2,round(.9*AA)))
def candidate_layout(pieces,panel):
 x0,y0,x1,y1=panel;dims=[bounds(p) for p in pieces];units=sum(w for w,h in dims)+len(pieces)-1
 cell=min(18.0,(x1-x0-42)/max(1,units),(y1-y0-40)/max(h for w,h in dims));gap=cell
 widths=[w*cell for w,h in dims];total=sum(widths)+gap*(len(pieces)-1);x=x0+(x1-x0-total)/2
 result=[]
 for p,pw,(pw_cells,ph_cells) in zip(pieces,widths,dims):
  result.append((p,x,y0+30+(y1-y0-35-ph_cells*cell)/2,cell));x+=pw+gap
 return result
def render(path,size,target,candidates):
 im=Image.new('RGB',(size[0]*AA,size[1]*AA),BG);d=ImageDraw.Draw(im);f=font(14*AA);tf=font(15*AA);d.text((22*AA,18*AA),'Target',font=tf,fill=INK);tw,th=bounds(target);cell=min(28,125/max(tw,th));draw_cells(d,target,size[0]/2-tw*cell/2,38,cell);d.line([(15*AA,174*AA),((size[0]-15)*AA,174*AA)],fill=(90,92,94),width=2)
 panels=[(0,180,size[0]/2,315),(size[0]/2,180,size[0],315),(0,315,size[0]/2,size[1]),(size[0]/2,315,size[0],size[1])]
 for cand,panel in zip(candidates,panels):
  x0,y0,x1,y1=panel;d.text((round((x0+12)*AA),round((y0+8)*AA)),cand['choice_label'],font=f,fill=INK);pieces=cand['pieces']
  for p,x,y,cell in candidate_layout(pieces,panel):draw_cells(d,p,x,y,cell)
 im.resize(size,Image.Resampling.LANCZOS).save(path)
def questions(iid,row,rng):
 qs=[{'question_id':iid+'_q1','question_text':'How many unit cells make up the target shape?','question_type':'target_cell_count','ground_truth':str(row['target_cell_count']),'answer_format':'numeric','difficulty_level':1},{'question_id':iid+'_q2','question_text':'Which set of pieces (A, B, C, or D) can be assembled using only translation and rotation, with no mirroring, to exactly form the target?','question_type':'assembly_choice','ground_truth':row['correct_answer_choice'],'answer_format':'letter','difficulty_level':2}]
 if rng.random()<.5:
  c=rng.choice(row['candidates']);text=f"How many separate pieces are shown in candidate {c['choice_label']}?";typ='candidate_piece_count';gt=str(len(c['pieces']));fmt='numeric';extra={'candidate_label':c['choice_label']}
 else:
  c=rng.choice([x for x in row['candidates'] if not x['is_valid_assembly']]);text=f"Does candidate {c['choice_label']} have the same total number of unit cells as the target? Answer yes or no.";typ='candidate_same_area';gt='yes' if c['total_cell_count']==row['target_cell_count'] else 'no';fmt='yes_no';extra={'candidate_label':c['choice_label']}
 qs.append({'question_id':iid+'_q3','question_text':text,'question_type':typ,'ground_truth':gt,'answer_format':fmt,'difficulty_level':3,**extra})
 t=rng.choice(('mirror','wrong','connectivity'))
 if t=='mirror':text='Which candidate has the correct area but would require flipping (mirroring) its pieces to form the target?';typ='requires_reflection_choice';gt=next(c['choice_label'] for c in row['candidates'] if c['failure_reason']=='requires_reflection');fmt='letter'
 elif t=='wrong':text='Which candidate has the wrong total number of unit cells compared with the target?';typ='wrong_area_choice';gt=next(c['choice_label'] for c in row['candidates'] if c['failure_reason']=='wrong_area');fmt='letter'
 else:text='If one extra unit cell were attached along an edge of the correctly assembled connected target, would the result remain connected? Answer yes or no.';typ='extra_cell_connectivity';gt='yes';fmt='yes_no'
 qs.append({'question_id':iid+'_q4','question_text':text,'question_type':typ,'ground_truth':gt,'answer_format':fmt,'difficulty_level':4});return qs
def generate_one(i,images):
 rng=random.Random(i);w=rng.randint(550,600);h=rng.randint(400,450);n=rng.randint(6,10);target,correct,miss,wrong,mirror=build_geometry(rng,n);correct_label=CHOICES[(i-1)%4];roles=[('valid',correct,None),('gap',miss,'gap_or_overlap'),('wrong',wrong,'wrong_area'),('mirror',mirror,'requires_reflection')];other=[x for x in CHOICES if x!=correct_label];rng.shuffle(other);labels=[correct_label]+other;cands=[]
 for lab,(role,pieces,reason) in zip(labels,roles):cands.append({'choice_label':lab,'pieces':[[list(c) for c in p] for p in pieces],'total_cell_count':sum(map(len,pieces)),'is_valid_assembly':role=='valid','failure_reason':reason})
 cands.sort(key=lambda x:CHOICES.index(x['choice_label']));iid=f'combination_{i:04d}';render(images/f'{iid}.png',(w,h),target,cands);row={'id':iid,'image_path':f'images/{iid}.png','canvas_size':[w,h],'target_cells':[list(c) for c in target],'target_cell_count':n,'candidates':cands,'correct_answer_choice':correct_label,'seed':i,'difficulty_score':round(.3+.055*(n-6)+.06*(len(correct)-2),4)};row['questions']=questions(iid,row,rng);return row
def generate_dataset(n,out,sample=False):
 out=Path(out);images=out/'images';images.mkdir(parents=True,exist_ok=True);count=5 if sample else n
 with (out/'annotations.jsonl').open('w',encoding='utf8',newline='\n') as f:
  for i in range(1,count+1):
   f.write(json.dumps(generate_one(i,images),sort_keys=True,separators=(',',':'))+'\n')
   if i%250==0 or i==count:print(f'Generated {i}/{count}')
def main():
 p=argparse.ArgumentParser();p.add_argument('--n',type=int,default=3000);p.add_argument('--output-dir',default='combination_dataset_3000');p.add_argument('--sample',action='store_true');a=p.parse_args();generate_dataset(a.n,a.output_dir,a.sample)
if __name__=='__main__':main()