"""Reproducible AgentFEM small-problem dataset factory. SI units; serial MPI."""
import argparse, hashlib, json, time
from pathlib import Path
import numpy as np
import ufl
from mpi4py import MPI
from scipy.stats import qmc
from agentfem import mesh, models, fields, studies, constitutive, constraints
from agentfem.solvers import LinearSolverOptions

ROOT = Path(__file__).resolve().parent
SOLVER = LinearSolverOptions(ksp_type="preonly", pc_type="lu")

def run(kind, p, folder, refinement=1, analytical=False):
    folder.mkdir(parents=True, exist_ok=True)
    started = time.monotonic()
    if kind == "heat":
        L,H,k,x1,y1,x2,y2,s1,s2,q1,q2 = p
        domain = mesh.rectangle((0,0),(L,H),(48*refinement,32*refinement),cell_type="triangle")
        model = models.create(study=studies.steady_heat_transfer(dimension=2),mesh=domain)
        f = model.field(fields.temperature(domain,value=300.))
        model.material(constitutive.thermoelastic(young=200e9,poisson=.3,density=7800,
            thermal_expansion=12e-6,conductivity=k,specific_heat=500,reference_temperature=300))
        boundary = mesh.boundary(domain,lambda x: np.isclose(x[0],0)|np.isclose(x[0],L)|np.isclose(x[1],0)|np.isclose(x[1],H),tag=1)
        model.fix(f,on=boundary,value=300.)
        x=ufl.SpatialCoordinate(domain)
        source = (k*((np.pi/L)**2+(np.pi/H)**2)*10*ufl.sin(np.pi*x[0]/L)*ufl.sin(np.pi*x[1]/H)
            if analytical else q1*ufl.exp(-((x[0]-x1*L)**2+(x[1]-y1*H)**2)/(2*s1*s1))+q2*ufl.exp(-((x[0]-x2*L)**2+(x[1]-y2*H)**2)/(2*s2*s2)))
        model.heat_source(source)
    else:
        if kind == "cylinder":
            a,b,E,nu,pressure = p
            domain=mesh.rectangle((a,0),(b,.02),(24*refinement,2*refinement),cell_type="quadrilateral")
            study=studies.static_solid(dimension=2,assumption="axisymmetric")
        else:
            import gmsh
            L,H,r,E,nu,traction=p
            if not gmsh.isInitialized(): gmsh.initialize()
            gmsh.clear(); gmsh.option.setNumber("General.Terminal",0)
            gmsh.model.add("double_edge_notch")
            plate=gmsh.model.occ.addRectangle(0,0,0,L,H)
            c1=gmsh.model.occ.addDisk(L/2,0,0,r,r)
            c2=gmsh.model.occ.addDisk(L/2,H,0,r,r)
            surfaces,_=gmsh.model.occ.cut([(2,plate)],[(2,c1),(2,c2)])
            gmsh.model.occ.synchronize()
            gmsh.model.addPhysicalGroup(2,[t for d,t in surfaces],1)
            gmsh.option.setNumber("Mesh.MeshSizeMin",H/(40*refinement))
            gmsh.option.setNumber("Mesh.MeshSizeMax",H/(20*refinement))
            gmsh.model.mesh.generate(2)
            domain=mesh.import_gmsh_model(gmsh.model,gdim=2).domain
            study=studies.static_solid(dimension=2,assumption="plane_stress")
        model=models.create(study=study,mesh=domain)
        f=model.field(fields.displacement(domain,degree=2))
        model.material(constitutive.isotropic_elastic(young=E,poisson=nu,density=7800))
        if kind=="cylinder":
            model.constraint(constraints.axisymmetric_plane_strain(f))
            boundary=mesh.face(domain,axis="x",value=a,tag=1)
            model.pressure(pressure,on=boundary)
        else:
            left=mesh.boundary(domain,lambda x:np.isclose(x[0],0),tag=1)
            right=mesh.boundary(domain,lambda x:np.isclose(x[0],L),tag=2)
            model.fix(f,on=left,value=0.)
            model.traction((traction,0.),on=right)
    result=model.step(target=f,solver_options=SOLVER,output=folder/"fields.xdmf").solve_result()
    result.verify("engineering").require()
    result.write_manifest(folder/"result.json")
    coords=f.value.function_space.tabulate_dof_coordinates()
    values=f.value.x.array.reshape(len(coords),-1).copy()
    assert np.isfinite(values).all()
    np.savez_compressed(folder/"field.npz",coordinates_m=coords,values=values)
    info={"parameters":list(map(float,p)),"refinement":refinement,"seconds":time.monotonic()-started,
          "field_dofs":int(values.size),"max_field":float(np.max(np.linalg.norm(values,axis=1))) if kind!="heat" else float(values.max()),
          "min_field":float(values.min())}
    if kind=="cylinder":
        r=coords[:,0]; A=pressure*a*a/(b*b-a*a); B=pressure*a*a*b*b/(b*b-a*a)
        exact=(1+nu)/E*((1-2*nu)*A*r+B/r)
        info["relative_nodal_l2_error"]=float(np.linalg.norm(values[:,0]-exact)/np.linalg.norm(exact))
        assert info["relative_nodal_l2_error"]<.001
    if kind=="heat" and analytical:
        exact=10*np.sin(np.pi*coords[:,0]/L)*np.sin(np.pi*coords[:,1]/H)
        info["relative_nodal_l2_error"]=float(np.linalg.norm(values[:,0]-300-exact)/np.linalg.norm(exact))
        assert info["relative_nodal_l2_error"]<.01
    (folder/"sample.json").write_text(json.dumps(info,indent=2))
    return info

def parameters(kind,n):
    bounds={"heat":([.08,.05,15,.15,.15,.55,.55,.004,.004,1e6,1e6],[.16,.1,200,.45,.45,.85,.85,.012,.012,8e6,8e6]),
        "notch":([.12,.04,.12,70e9,.22,10e6],[.2,.07,.30,210e9,.34,50e6]),
        "cylinder":([.02,1.3,70e9,.22,1e6],[.08,2.8,210e9,.34,20e6])}
    low,high=bounds[kind]
    vals=qmc.scale(qmc.Sobol(len(low),scramble=True,seed=20260923).random_base2(int(np.log2(n))),low,high)
    if kind=="notch": vals[:,2]*=vals[:,1]
    if kind=="cylinder": vals[:,1]*=vals[:,0]
    return vals

if __name__=="__main__":
    ap=argparse.ArgumentParser(); ap.add_argument("kind",choices=["heat","notch","cylinder"])
    ap.add_argument("--count",type=int,default=256); ap.add_argument("--validate",action="store_true")
    ap.add_argument("--refinement",type=int,default=1)
    ap.add_argument("--start",type=int,default=0); ap.add_argument("--stop",type=int,default=None)
    args=ap.parse_args(); assert args.count>0 and args.count&(args.count-1)==0
    root=ROOT/"generated"/(args.kind if args.refinement==1 else args.kind+f"_r{args.refinement}")
    if args.validate:
        p=parameters(args.kind,4)[0]
        a=run(args.kind,p,root/"validation"/"coarse",analytical=args.kind=="heat")
        b=run(args.kind,p,root/"validation"/"fine",2,analytical=args.kind=="heat")
        report={"coarse":a,"fine":b,"relative_max_field_change":abs(a["max_field"]-b["max_field"])/abs(b["max_field"])}
        (root/"validation.json").write_text(json.dumps(report,indent=2)); print(json.dumps(report),flush=True)
    else:
        rows=[]
        order=np.random.default_rng(20260924).permutation(args.count)
        test=set(order[:args.count//8]); validation=set(order[args.count//8:args.count//4])
        for i,p in enumerate(parameters(args.kind,args.count)):
            if i<args.start or i>=(args.stop if args.stop is not None else args.count): continue
            dest=root/"samples"/f"{i:05d}"
            info=json.loads((dest/"sample.json").read_text()) if (dest/"sample.json").exists() else run(args.kind,p,dest,args.refinement)
            info={"id":f"{i:05d}","split":"test" if i in test else "validation" if i in validation else "train",**info}
            rows.append(info)
            if i%16==0: print(args.kind,i+1,"/",args.count,flush=True)
        paths=[root/"samples"/f"{i:05d}"/"sample.json" for i in range(args.count)]
        if all(p.exists() for p in paths):
            rows=[{"id":f"{i:05d}","split":"test" if i in test else "validation" if i in validation else "train",**json.loads(p.read_text())} for i,p in enumerate(paths)]
            (root/"index.json").write_text(json.dumps(rows,indent=2))
            print("COMPLETE",args.kind,len(rows),flush=True)
        else: print("SHARD COMPLETE",args.kind,args.start,args.stop,flush=True)