/** Test-only, CPU numerical reference. Never imported by the renderer.
 * Photo intersections use analytic per-triangle height planes and a bounded XY DDA;
 * the independent oracle uses Three's indexed PlaneGeometry and Ray.intersectTriangle.
 */
import * as THREE from 'three';
const EPS = 1e-10;
export const PHOTO_SEGMENTS = 128;
export const MAX_DDA_CELLS = 257;
export const v3 = (x=0,y=0,z=0) => new THREE.Vector3(x,y,z);

export function makeDepthTexture(width, height, sample) {
  const data = new Uint8Array(width*height*4);
  for(let y=0;y<height;y++) for(let x=0;x<width;x++) {
    const n=Math.round(255*THREE.MathUtils.clamp(sample(x,y),0,1)), i=4*(y*width+x);
    data[i]=data[i+1]=data[i+2]=n; data[i+3]=255;
  }
  const texture=new THREE.DataTexture(data,width,height);
  texture.minFilter=texture.magFilter=THREE.LinearFilter;
  texture.wrapS=texture.wrapT=THREE.ClampToEdgeWrapping;
  texture.generateMipmaps=false;
  return texture;
}

/** GL normalized LinearFilter sampling at explicit LOD zero; Uint8 -> [0,1]. */
export function depthAt(texture,u,v) {
  const {data,width,height}=texture.image;
  if(texture.flipY)v=1-v;
  const x=u*width-.5,y=v*height-.5,x0=Math.floor(x),y0=Math.floor(y),fx=x-x0,fy=y-y0;
  const fetch=(i,j)=>data[4*(THREE.MathUtils.clamp(j,0,height-1)*width+THREE.MathUtils.clamp(i,0,width-1))]/255;
  return THREE.MathUtils.lerp(THREE.MathUtils.lerp(fetch(x0,y0),fetch(x0+1,y0),fx),THREE.MathUtils.lerp(fetch(x0,y0+1),fetch(x0+1,y0+1),fx),fy);
}

export function photoSurface(texture,{segments=128,depthScale=.25,depthBias=0,matrix=new THREE.Matrix4()}={}) {
  if(!Number.isInteger(segments)||segments<1||segments>128) throw new Error('Photo grid must be 1..128');
  const heights=new Float64Array((segments+1)**2);
  for(let y=0;y<=segments;y++) for(let x=0;x<=segments;x++) heights[y*(segments+1)+x]=(depthAt(texture,x/segments,y/segments)-depthBias)*depthScale;
  const geometry=new THREE.PlaneGeometry(1,1,segments,segments),p=geometry.attributes.position,uv=geometry.attributes.uv;
  for(let i=0;i<p.count;i++) p.setZ(i,(depthAt(texture,uv.getX(i),uv.getY(i))-depthBias)*depthScale);
  return {texture,segments,heights,geometry,matrix:matrix.clone(),inverse:matrix.clone().invert(),minZ:Math.min(...heights),maxZ:Math.max(...heights)};
}

export function localRay(surface,origin,direction) {
  return {origin:origin.clone().applyMatrix4(surface.inverse),direction:direction.clone().applyMatrix3(new THREE.Matrix3().setFromMatrix4(surface.inverse))};
}

export function triangleOracle(surface,origin,direction) {
  const local=localRay(surface,origin,direction),ray=new THREE.Ray(local.origin,local.direction),p=surface.geometry.attributes.position,indices=surface.geometry.index;
  const a=v3(),b=v3(),c=v3(),hit=v3();let result=null,minT=Infinity;
  for(let i=0;i<indices.count;i+=3) {
    a.fromBufferAttribute(p,indices.getX(i));b.fromBufferAttribute(p,indices.getX(i+1));c.fromBufferAttribute(p,indices.getX(i+2));
    if(!ray.intersectTriangle(a,b,c,true,hit))continue;
    const t=hit.clone().sub(local.origin).dot(local.direction)/local.direction.lengthSq();
    if(t>=-EPS&&t<minT) {minT=t;result={t,local:hit.clone(),point:hit.clone().applyMatrix4(surface.matrix),uv:new THREE.Vector2(hit.x+.5,hit.y+.5),triangle:i/3};}
  }
  return result;
}

/** Returns nearest actual triangle hit, including multiple height crossings. */
export function tracePhotoDDA(surface,origin,direction) {
  const {origin:o,direction:d}=localRay(surface,origin,direction),n=surface.segments,h=surface.heights;
  let enter=0,leave=Infinity,cells=0;
  for(const [axis,lo,hi] of [['x',-.5,.5],['y',-.5,.5],['z',surface.minZ,surface.maxZ]]) {
    if(Math.abs(d[axis])<1e-14) {if(o[axis]<lo-EPS||o[axis]>hi+EPS)return {hit:null,cells};continue;}
    const a=(lo-o[axis])/d[axis],b=(hi-o[axis])/d[axis];enter=Math.max(enter,Math.min(a,b));leave=Math.min(leave,Math.max(a,b));
  }
  if(leave<enter-EPS)return {hit:null,cells};
  const at=o.clone().addScaledVector(d,enter),grid=(x)=>THREE.MathUtils.clamp(Math.floor((x+.5)*n),0,n-1);
  let ix=grid(at.x),iy=grid(at.y),t=enter;
  const sx=Math.sign(d.x),sy=Math.sign(d.y);
  const next=(axis,cell,step)=>step===0?Infinity:((cell+(step>0?1:0))/n-.5-o[axis])/d[axis];
  let tx=next('x',ix,sx),ty=next('y',iy,sy);
  for(let step=0;step<MAX_DDA_CELLS;step++) {
    cells++;
    const end=Math.min(tx,ty,leave),k=iy*(n+1)+ix,z00=h[k],z10=h[k+1],z01=h[k+n+1],z11=h[k+n+2];
    let best=Infinity;
    // The two exact PlaneGeometry triangles share the lower-left/upper-right diagonal.
    for(const lower of [true,false]) {
      const ax=lower?z10-z00:z11-z01,ay=lower?z11-z10:z01-z00;
      const fx0=(o.x+.5)*n-ix,fy0=(o.y+.5)*n-iy;
      const denom=d.z-n*(ax*d.x+ay*d.y);
      if(denom>=-1e-14)continue; // FrontSide: approach the displaced photo front.
      const candidate=(z00+ax*fx0+ay*fy0-o.z)/denom;
      const fx=fx0+n*d.x*candidate,fy=fy0+n*d.y*candidate;
      if(candidate<t-EPS||candidate>end+EPS||candidate<0||fx<-EPS||fy<-EPS||fx>1+EPS||fy>1+EPS)continue;
      if(lower?fy>fx+EPS:fx>fy+EPS)continue;
      best=Math.min(best,candidate);
    }
    if(Number.isFinite(best)) {const local=o.clone().addScaledVector(d,best);return {hit:{t:best,local,point:local.clone().applyMatrix4(surface.matrix),uv:new THREE.Vector2(local.x+.5,local.y+.5)},cells};}
    if(end>=leave-EPS)return {hit:null,cells};
    const crossX=tx<=ty+EPS,crossY=ty<=tx+EPS;t=end;
    if(crossX) {ix+=sx;tx=next('x',ix,sx);}if(crossY) {iy+=sy;ty=next('y',iy,sy);}
    if(ix<0||ix>=n||iy<0||iy>=n)return {hit:null,cells};
  }
  throw new Error(`DDA exceeded ${MAX_DDA_CELLS} cells`);
}

/** GLSL refract convention: normal opposes incident direction. */
export function snell(incident,normal,eta) {
  const i=incident.clone().normalize(),n=normal.clone().normalize(),dot=i.dot(n),k=1-eta*eta*(1-dot*dot);
  if(k<0)return null;
  return i.multiplyScalar(eta).addScaledVector(n,-eta*dot-Math.sqrt(k)).normalize();
}

/** Planar rear and finite side exits in local glass coordinates. */
export function exitGlass(entry,inside,{width,height,backZ}) {
  const candidates=[];
  for(const [axis,bounds] of [['x',[-width/2,width/2]],['y',[-height/2,height/2]],['z',[backZ]]]) {
    if(Math.abs(inside[axis])<1e-14)continue;
    for(const value of bounds) {const t=(value-entry[axis])/inside[axis];if(t>EPS)candidates.push({t,axis,value});}
  }
  candidates.sort((a,b)=>a.t-b.t);
  for(const c of candidates) {
    const point=entry.clone().addScaledVector(inside,c.t);
    if(Math.abs(point.x)>width/2+EPS||Math.abs(point.y)>height/2+EPS||point.z<backZ-EPS)continue;
    const normal=v3();normal[c.axis]=c.axis==='z'?-1:Math.sign(c.value);
    return {point,normal,t:c.t,face:c.axis==='z'?'rear':`${c.axis}${Math.sign(c.value)>0?'+':'-'}`};
  }
  return null;
}

export function traceGlass({entry,normal,incident,shape,ior=1.5,surface}) {
  const inside=snell(incident,normal,1/ior);if(!inside)return {status:'entry-tir'};
  const exit=exitGlass(entry,inside,shape);if(!exit)return {status:'no-exit'};
  const outgoing=snell(inside,exit.normal.clone().negate(),ior);if(!outgoing)return {status:'tir',inside,exit};
  const result=tracePhotoDDA(surface,exit.point,outgoing);
  return {status:result.hit?'hit':'miss',inside,exit,outgoing,...result};
}

/** Stock r169 only advances its refracted ray by material thickness, projects that
 * endpoint, and looks up the already camera-rendered scene at that screen point. */
export function stockR169PhotoHit({entry,normal,incident,camera,thickness,ior=1.5,surface}) {
  const inside=snell(incident,normal,1/ior);
  if(!inside)return null;
  const endpoint=entry.clone().addScaledVector(inside,thickness);
  return tracePhotoDDA(surface,camera,endpoint.sub(camera).normalize()).hit;
}

/** Actual mesh intersection and perspective-correct interpolated vertex normal. */
export function meshEntry(geometry,camera,target) {
  const material=new THREE.MeshBasicMaterial({side:THREE.FrontSide}),mesh=new THREE.Mesh(geometry,material);
  mesh.updateMatrixWorld(true);
  const incident=target.clone().sub(camera).normalize(),hit=new THREE.Raycaster(camera,incident).intersectObject(mesh,false)[0];
  material.dispose();
  if(!hit)return null;
  const p=geometry.attributes.position,n=geometry.attributes.normal,a=v3().fromBufferAttribute(p,hit.face.a),b=v3().fromBufferAttribute(p,hit.face.b),c=v3().fromBufferAttribute(p,hit.face.c);
  const bary=THREE.Triangle.getBarycoord(hit.point,a,b,c,v3());
  const normal=v3().fromBufferAttribute(n,hit.face.a).multiplyScalar(bary.x).addScaledVector(v3().fromBufferAttribute(n,hit.face.b),bary.y).addScaledVector(v3().fromBufferAttribute(n,hit.face.c),bary.z).normalize();
  return {entry:hit.point,normal,incident,bary,face:hit.face};
}