#![allow(unreachable_patterns, unused_assignments, unused_must_use)]
#![allow(dead_code, unused_imports, unused_variables, unused_macros)]
use std::io::Write;

const SHADOW_RS: &str = "hcie-fx/src/shadow.rs";

fn main() {
    let original = std::fs::read_to_string(SHADOW_RS).expect("read shadow.rs");

    let mut best_mae = f64::MAX;
    let mut best_code = String::new();
    let mut best_params = (0, 0.0, 0.0);

    // Grid search in Rust
    for blur in vec![2, 4, 6, 8, 10, 12] {
        for hl_scale in vec![0.5, 1.0, 1.5, 2.0, 2.5, 3.0] {
            for sh_scale in vec![1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0] {
                // Generate patched code
                let code_patch = format!(
                    r#"    // BEGIN_TUNING_ZONE
    let lighting_blur = {};
    lighting = box_blur_f32(&lighting, w, h, lighting_blur);

    for i in 0..px {{
        let is_inner = alpha[i] > 0;
        let show = match style {{
            crate::types::BevelStyle::InnerBevel => is_inner,
            crate::types::BevelStyle::OuterBevel => !is_inner,
            crate::types::BevelStyle::Emboss => true,
            _ => is_inner,
        }};
        if !show {{ continue; }}
        let dist_abs = if is_inner {{ dist_inside_sq[i].sqrt() }} else {{ dist_outside_sq[i].sqrt() }};
        if !is_inner && dist_abs > radius {{ continue; }}
        let technique_show = match technique {{
            crate::types::Technique::Smooth => true,
            _ => dist_abs <= radius,
        }};
        if !technique_show {{ continue; }}

        let ndl = lighting[i];
        let is_flat = is_inner && dist_abs > radius;

        if is_flat {{
            if style == crate::types::BevelStyle::Emboss && depth > 100.0 {{
                shadow_buf[i * 4 + 3] = alpha[i];
            }}
            continue;
        }}

        let hl_pred = (ndl * {:.4}).clamp(0.0, 1.0);
        let sh_pred = (-ndl * {:.4}).clamp(0.0, 1.0);

        highlight_buf[i * 4 + 3] = (alpha[i] as f32 * hl_pred).round() as u8;
        shadow_buf[i * 4 + 3] = (alpha[i] as f32 * sh_pred).round() as u8;
    }}
    // END_TUNING_ZONE"#,
                    blur, hl_scale, sh_scale
                );

                // Replace tuning zone
                let start_tag = "    // BEGIN_TUNING_ZONE";
                let end_tag = "    // END_TUNING_ZONE";
                if let (Some(start_idx), Some(end_idx)) = (original.find(start_tag), original.find(end_tag)) {
                    let mut new_content = String::new();
                    new_content.push_str(&original[..start_idx]);
                    new_content.push_str(&code_patch);
                    new_content.push_str(&original[end_idx + end_tag.len()..]);

                    std::fs::write(SHADOW_RS, &new_content).expect("write shadow.rs");

                    let mae = measure_layer2_mae();
                    println!("blur={}, hl_scale={:.1}, sh_scale={:.1} => MAE={:.4}", blur, hl_scale, sh_scale, mae);

                    if mae < best_mae {
                        best_mae = mae;
                        best_code = new_content.clone();
                        best_params = (blur, hl_scale, sh_scale);
                        println!("*** NEW BEST: {:.4} (params: {:?})", best_mae, best_params);
                        // Save immediately so intermediate progress is preserved
                        std::fs::write(SHADOW_RS, &best_code).expect("write best");

                        // Update sultan_results.txt to show the best results of all layers
                        let _ = std::fs::copy("sultan_results_temp.txt", "sultan_results.txt");
                        if let Ok(mut file) = std::fs::OpenOptions::new().append(true).open("sultan_results.txt") {
                            let _ = writeln!(file, "\n=== Best Bevel/Emboss Tuned (So Far) ===\n  Params: blur={}, hl_scale={:.1}, sh_scale={:.1}\n  MAE: {:.4}", blur, hl_scale, sh_scale, mae);
                        }
                    }
                }
            }
        }
    }

    if best_mae < f64::MAX {
        println!("Completed. Best code saved with MAE = {:.4} (params: {:?})", best_mae, best_params);
        let _ = std::fs::remove_file("sultan_results_temp.txt");
    } else {
        std::fs::write(SHADOW_RS, &original).expect("restore original");
    }
}

fn measure_layer2_mae() -> f64 {
    let output = std::process::Command::new("cargo")
        .args(["run", "-p", "hcie-io", "--example", "test_sultan", "-q"])
        .env("SULTAN_RESULTS_FILE", "sultan_results_temp.txt")
        .output()
        .expect("run test_sultan");

    if !output.status.success() {
        return f64::MAX;
    }

    let results = std::fs::read_to_string("sultan_results_temp.txt").expect("read results");
    let lines: Vec<&str> = results.lines().collect();
    for i in 0..lines.len() {
        if lines[i].contains("Layer 2.psd") {
            for j in i+1..lines.len() {
                if lines[j].starts_with("  Avg diff per channel:") {
                    let value = lines[j].trim_start_matches("  Avg diff per channel:").trim();
                    return value.parse::<f64>().unwrap_or(f64::MAX) / 4.0;
                }
            }
        }
    }
    f64::MAX
}