//! Certificación de la **capa 3**: una foto real → **busto voxel** estilizado
//! (`photo_to_grid`), renderizado con el kit sub-voxel (bisel) para que se lea como
//! parte del mundo de bloques y no como una malla fotorreal — la cuantización es lo
//! que lo saca del valle de inquietud.
//!
//! Genera un retrato sintético (con recorte alpha) → busto → render frontal. Certifica
//! por STATS (recorte, relieve, fidelidad de color). Si existe `pluma.png` en el cwd,
//! también lo voxeliza y rinde (imagen real, a modo de muestra).
//!
//! `cargo run -p llimphi-voxel --example foto_ser --release -- [imagen.png]`

use std::fs::File;
use std::io::{BufReader, BufWriter};

use llimphi_3d::glam::Vec3;
use llimphi_3d::{Camera3d, VoxelGrid, VoxelRenderer};
use llimphi_hal::{wgpu, Hal};
use llimphi_raster::peniko::Color;
use llimphi_raster::{vello, Renderer};
use llimphi_voxel::{photo_to_grid, FotoOpts, Relieve};

const W: u32 = 720;
const H: u32 = 720;
const FMT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
const BG: [u8; 3] = [16, 18, 26];

fn main() {
    let hal = pollster::block_on(Hal::new(None)).expect("hal");
    let mut renderer = Renderer::new(&hal).expect("renderer");
    let dir = std::env::var("CLAUDE_JOB_DIR").map(|d| format!("{d}/tmp")).unwrap_or("/tmp".into());

    // --- Certificación: retrato sintético con recorte alpha ---
    let (rw, rh) = (96u32, 112u32);
    let img = retrato(rw, rh);
    let opts = FotoOpts { ancho: 64, profundidad: 16, relieve: Relieve::Domo, alpha_min: 128, grano: 0.05 };
    let (grid, s) = photo_to_grid(&img, rw, rh, &opts);

    println!("foto_ser — retrato sintético {rw}x{rh} → busto voxel");
    println!("  grilla: {:?}", s.dim);
    println!("  recorte (foreground): {} px de {}", s.recorte, s.dim[0] * s.dim[1]);
    println!("  voxels colocados: {}", s.voxeles);
    println!("  grosor del relieve: {}..{} voxels (domo)", s.grosor_min, s.grosor_max);
    println!("  color medio: {:?}", s.color_medio);

    // Render frontal con bisel (compone con la capa 2b) + rugosidad leve.
    let px = render_bust(&hal, &mut renderer, &grid, s.dim, 0.65, 0.25);
    write_png(&px, &format!("{dir}/foto_ser.png"));
    let covered = coverage(&px);
    println!("  render: {covered} px cubiertos → {dir}/foto_ser.png");

    // Asserts de la certificación (los detalles finos ya están en los unit tests).
    assert!(s.recorte > 0 && (s.recorte as f32) < (s.dim[0] * s.dim[1]) as f32 * 0.9, "recortó el fondo");
    assert!(s.grosor_max > s.grosor_min && s.grosor_max >= 12, "hay relieve de domo ({}..{})", s.grosor_min, s.grosor_max);
    assert!(s.color_medio[0] > s.color_medio[2], "conserva el tono cálido de la piel: {:?}", s.color_medio);
    assert!(covered > 5000, "el busto se renderizó (cubrió {covered} px)");

    // --- Muestra opcional: imagen real (pluma.png) si está en el cwd ---
    let arg = std::env::args().nth(1);
    let ruta = arg.as_deref().unwrap_or("pluma.png");
    match load_png_rgba(ruta) {
        Some((rgba, w, h)) => {
            // Sin alpha real: recorte por luminancia (fondo claro fuera). alpha_min=1
            // deja pasar casi todo; el relieve por luminancia da volumen a la imagen.
            let o = FotoOpts { ancho: 72, profundidad: 14, relieve: Relieve::Luminancia, alpha_min: 1, grano: 0.05 };
            let (g2, s2) = photo_to_grid(&rgba, w, h, &o);
            let p2 = render_bust(&hal, &mut renderer, &g2, s2.dim, 0.6, 0.2);
            write_png(&p2, &format!("{dir}/foto_ser_real.png"));
            println!("imagen real '{ruta}' {w}x{h} → {} voxels → {dir}/foto_ser_real.png", s2.voxeles);
        }
        None => println!("(sin imagen real en '{ruta}' — omitido)"),
    }

    println!("✓ certificado: foto → busto voxel con recorte, relieve y color del original.");
}

/// Retrato sintético RGBA con recorte alpha: pelo + óvalo de piel + ojos + boca.
fn retrato(w: u32, h: u32) -> Vec<u8> {
    let cx = w as f32 / 2.0;
    let cy = h as f32 * 0.52;
    let rx = w as f32 * 0.34;
    let ry = h as f32 * 0.42;
    let mut px = vec![0u8; (w * h * 4) as usize];
    for y in 0..h {
        for x in 0..w {
            let i = ((y * w + x) * 4) as usize;
            let nx = (x as f32 - cx) / rx;
            let ny = (y as f32 - cy) / ry;
            if nx * nx + ny * ny > 1.0 {
                continue; // fuera del óvalo → transparente
            }
            // Piel cálida con leve sombreado vertical.
            let sh = 1.0 - 0.15 * ny;
            let mut c = [(228.0 * sh) as u8, (186.0 * sh) as u8, (150.0 * sh) as u8];
            // Pelo: banda superior.
            if ny < -0.45 {
                c = [92, 62, 44];
            }
            // Ojos: dos elipses oscuras.
            for ex in [-0.42f32, 0.42] {
                let ox = (x as f32 - (cx + ex * rx)) / (rx * 0.16);
                let oy = (y as f32 - (cy - 0.12 * ry)) / (ry * 0.10);
                if ox * ox + oy * oy < 1.0 {
                    c = [40, 32, 30];
                }
            }
            // Boca: arco oscuro.
            let mox = (x as f32 - cx) / (rx * 0.42);
            let moy = (y as f32 - (cy + 0.5 * ry)) / (ry * 0.08);
            if mox * mox + moy * moy < 1.0 {
                c = [150, 70, 66];
            }
            px[i] = c[0];
            px[i + 1] = c[1];
            px[i + 2] = c[2];
            px[i + 3] = 255;
        }
    }
    px
}

/// Renderiza un busto voxel centrado, de frente, con `bisel`/`rugosidad` dados.
fn render_bust(hal: &Hal, renderer: &mut Renderer, grid: &VoxelGrid, dim: [u32; 3], bisel: f32, rug: f32) -> Vec<u8> {
    let mut vr = VoxelRenderer::new(&hal.device, &hal.queue, FMT, grid);
    vr.bisel = bisel;
    vr.rugosidad_amp = rug;
    vr.sun_dir = normalize([0.35, 0.55, 0.75]); // luz desde el frente-arriba
    // El relieve sobresale hacia +Z → cámara al frente (mirando -Z), leve picado.
    let alto = dim[1].max(dim[0]) as f32;
    let camera = Camera3d::orbit(Vec3::ZERO, 0.0, 8_f32.to_radians(), alto * 1.9);

    let inter = hal.device.create_texture(&wgpu::TextureDescriptor {
        label: Some("inter"),
        size: wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
        mip_level_count: 1,
        sample_count: 1,
        dimension: wgpu::TextureDimension::D2,
        format: FMT,
        usage: wgpu::TextureUsages::STORAGE_BINDING
            | wgpu::TextureUsages::TEXTURE_BINDING
            | wgpu::TextureUsages::RENDER_ATTACHMENT
            | wgpu::TextureUsages::COPY_SRC,
        view_formats: &[],
    });
    let view = inter.create_view(&wgpu::TextureViewDescriptor::default());
    let base = vello::Scene::new();
    renderer
        .render_to_view(hal, &base, &view, W, H, Color::from_rgba8(BG[0], BG[1], BG[2], 255))
        .expect("base");
    let mut enc = hal.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
    vr.render(&hal.device, &hal.queue, &mut enc, &view, (W, H), &camera);
    hal.queue.submit(std::iter::once(enc.finish()));
    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
    readback(hal, &inter)
}

fn normalize(v: [f32; 3]) -> [f32; 3] {
    let l = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt().max(1e-6);
    [v[0] / l, v[1] / l, v[2] / l]
}

fn coverage(px: &[u8]) -> usize {
    (0..(W * H) as usize)
        .filter(|&i| {
            let o = i * 4;
            (px[o] as i32 - BG[0] as i32).abs()
                + (px[o + 1] as i32 - BG[1] as i32).abs()
                + (px[o + 2] as i32 - BG[2] as i32).abs()
                > 12
        })
        .count()
}

/// Decodifica un PNG a RGBA `w×h`. `None` si no existe o no se pudo leer.
fn load_png_rgba(path: &str) -> Option<(Vec<u8>, u32, u32)> {
    let file = File::open(path).ok()?;
    let dec = png::Decoder::new(BufReader::new(file));
    let mut reader = dec.read_info().ok()?;
    let mut buf = vec![0u8; reader.output_buffer_size()?];
    let info = reader.next_frame(&mut buf).ok()?;
    let (w, h) = (info.width, info.height);
    let rgba = match info.color_type {
        png::ColorType::Rgba => buf[..info.buffer_size()].to_vec(),
        png::ColorType::Rgb => {
            let mut out = Vec::with_capacity((w * h * 4) as usize);
            for c in buf[..info.buffer_size()].chunks(3) {
                out.extend_from_slice(&[c[0], c[1], c[2], 255]);
            }
            out
        }
        png::ColorType::Grayscale => {
            let mut out = Vec::with_capacity((w * h * 4) as usize);
            for &g in &buf[..info.buffer_size()] {
                out.extend_from_slice(&[g, g, g, 255]);
            }
            out
        }
        _ => return None, // paleta/gris-alfa: fuera de alcance del demo
    };
    Some((rgba, w, h))
}

fn readback(hal: &Hal, target: &wgpu::Texture) -> Vec<u8> {
    let unpadded = (W * 4) as usize;
    let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
    let padded = unpadded.div_ceil(align) * align;
    let buf = hal.device.create_buffer(&wgpu::BufferDescriptor {
        label: Some("readback"),
        size: (padded * H as usize) as u64,
        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
        mapped_at_creation: false,
    });
    let mut enc = hal.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
    enc.copy_texture_to_buffer(
        wgpu::TexelCopyTextureInfo {
            texture: target,
            mip_level: 0,
            origin: wgpu::Origin3d::ZERO,
            aspect: wgpu::TextureAspect::All,
        },
        wgpu::TexelCopyBufferInfo {
            buffer: &buf,
            layout: wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(padded as u32), rows_per_image: Some(H) },
        },
        wgpu::Extent3d { width: W, height: H, depth_or_array_layers: 1 },
    );
    hal.queue.submit(std::iter::once(enc.finish()));
    let slice = buf.slice(..);
    let (tx, rx) = std::sync::mpsc::channel();
    slice.map_async(wgpu::MapMode::Read, move |r| {
        let _ = tx.send(r);
    });
    let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
    rx.recv().unwrap().unwrap();
    let data = slice.get_mapped_range();
    let mut pixels = Vec::with_capacity((W * H * 4) as usize);
    for row in 0..H as usize {
        let sst = row * padded;
        pixels.extend_from_slice(&data[sst..sst + unpadded]);
    }
    drop(data);
    buf.unmap();
    pixels
}

fn write_png(pixels: &[u8], path: &str) {
    let file = File::create(path).expect("png");
    let mut enc = png::Encoder::new(BufWriter::new(file), W, H);
    enc.set_color(png::ColorType::Rgba);
    enc.set_depth(png::BitDepth::Eight);
    let mut w = enc.write_header().unwrap();
    w.write_image_data(pixels).unwrap();
}