use std::sync::OnceLock;
use std::path::{Path, PathBuf};
use std::os::raw::c_char;
use std::ffi::CString;
use libloading::Library;

pub fn blend_pixels(dst: [u8; 4], src: [u8; 4], mode: hcie_protocol::BlendMode, opacity: f32) -> [u8; 4] {
    hcie_blend::blend_pixels(dst, src, mode.into(), opacity)
}
pub fn blend_buffers(dst: &mut [u8], src: &[u8], mode: hcie_protocol::BlendMode, opacity: f32) {
    hcie_blend::blend_buffers(dst, src, mode.into(), opacity)
}

pub fn apply_filter(filter_id: &str, params: &serde_json::Value, pixels: &mut [u8], width: u32, height: u32) -> Result<(), String> {
    let mut fl = hcie_protocol::Layer::new_transparent("", width, height);
    fl.pixels.copy_from_slice(pixels);
    hcie_filter::apply_filter(&mut fl, filter_id, params);
    let len = pixels.len().min(fl.pixels.len());
    pixels[..len].copy_from_slice(&fl.pixels[..len]);
    Ok(())
}

pub fn draw_line(layer: &mut hcie_protocol::Layer, x0: f32, y0: f32, x1: f32, y1: f32, color: [u8; 4], stroke_size: f32, mask: Option<&[u8]>) {
    hcie_draw::draw_line(layer, x0, y0, x1, y1, color, stroke_size, mask); layer.dirty = true;
}
pub fn draw_filled_rect(layer: &mut hcie_protocol::Layer, x1: f32, y1: f32, x2: f32, y2: f32, color: [u8; 4], mask: Option<&[u8]>) {
    hcie_draw::draw_filled_rect(layer, x1, y1, x2, y2, color, mask); layer.dirty = true;
}
pub fn draw_filled_ellipse(layer: &mut hcie_protocol::Layer, cx: f32, cy: f32, rx: f32, ry: f32, color: [u8; 4], mask: Option<&[u8]>) {
    hcie_draw::draw_filled_ellipse(layer, cx, cy, rx, ry, color, mask); layer.dirty = true;
}
pub fn flood_fill(layer: &mut hcie_protocol::Layer, x: u32, y: u32, color: [u8; 4], tolerance: u8, mask: Option<&[u8]>) {
    hcie_draw::flood_fill(layer, x, y, color, tolerance, mask); layer.dirty = true;
}
pub fn draw_brush_stroke(layer: &mut hcie_protocol::Layer, points: &[(f32, f32, f32)], color: [u8; 4], tip: &hcie_protocol::BrushTip, is_eraser: bool, mask: Option<&[u8]>, stroke_mask: Option<&mut [u8]>, bg_pixels: Option<&[u8]>) {
    let ct = hcie_brush_engine::BrushTip {
        style: unsafe { std::mem::transmute::<i32, hcie_brush_engine::BrushStyle>(tip.style as i32) },
        size: tip.size, opacity: tip.opacity, hardness: tip.hardness,
        spacing: tip.spacing, flow: tip.flow,
        jitter_amount: tip.jitter_amount, scatter_amount: tip.scatter_amount,
        angle: tip.angle, roundness: tip.roundness,
        spray_particle_size: tip.spray_particle_size, spray_density: tip.spray_density,
        bitmap_pixels: tip.bitmap_pixels.clone(), bitmap_w: tip.bitmap_w, bitmap_h: tip.bitmap_h,
    };
    hcie_draw::draw_brush_stroke(layer, points, color, &ct, is_eraser, mask, stroke_mask, bg_pixels); layer.dirty = true;
}
pub fn draw_specialized_stroke(pixels: &mut [u8], width: u32, height: u32, points: &[(f32, f32, f32)], brush_style: hcie_protocol::BrushStyle, size: f32, hardness: f32, color: [u8; 4], opacity: f32, spacing_ratio: f32, is_eraser: bool, sketch_history: Option<&mut Vec<(f32, f32)>>, spray_particle_size: f32, spray_density: u32, mask: Option<&[u8]>, stroke_mask: Option<&mut [u8]>, bg_pixels: Option<&[u8]>) {
    let bs: hcie_brush_engine::BrushStyle = unsafe { std::mem::transmute_copy(&brush_style) };
    hcie_brush_engine::draw_specialized_stroke(pixels, width, height, points, bs, size, hardness, color, opacity, spacing_ratio, is_eraser, sketch_history, spray_particle_size, spray_density, mask, stroke_mask, bg_pixels)
}

pub fn composite_layers(layers: &[hcie_protocol::Layer], cw: u32, ch: u32) -> Vec<u8> { hcie_composite::composite_layers(layers, cw, ch) }
pub fn composite_layers_region(layers: &[hcie_protocol::Layer], cw: u32, ch: u32, x0: u32, y0: u32, x1: u32, y1: u32, out: &mut [u8]) { hcie_composite::composite_layers_region(layers, cw, ch, x0, y0, x1, y1, out) }
pub mod tiled {
    use super::*;
    pub fn composite_tiled_into(layers: &[hcie_protocol::Layer], tile_layers: &[Option<hcie_tile::TiledLayer>], cw: u32, ch: u32, x0: u32, y0: u32, x1: u32, y1: u32, out: &mut [u8]) {
        hcie_composite::tiled::composite_tiled_into(layers, tile_layers, cw, ch, x0, y0, x1, y1, out)
    }
}

pub fn load_image(path: &Path) -> Result<hcie_protocol::Layer, String> { hcie_io::load_image(path) }
pub fn save_image(layer: &hcie_protocol::Layer, path: &Path, format: &str) -> Result<(), String> { hcie_io::save_image(layer, path, format) }
pub fn import_psd(path: &Path) -> Result<Vec<hcie_protocol::Layer>, String> { hcie_psd::import_psd(path) }
pub fn export_psd(layers: &[hcie_protocol::Layer], cw: u32, ch: u32, composited: &[u8], path: &Path) -> Result<(), String> { hcie_psd::save_psd(layers, cw, ch, composited, path) }
pub fn import_kra(path: &Path) -> Result<Vec<hcie_protocol::Layer>, String> { hcie_kra::import_kra(path) }
pub fn export_kra(layers: &[hcie_protocol::Layer], cw: u32, ch: u32, composited: &[u8], path: &Path) -> Result<(), String> { hcie_kra::export_kra(layers, cw, ch, composited, path) }
pub fn load_native(path: &Path) -> Result<Vec<hcie_protocol::Layer>, String> { hcie_native::load_native(path) }
pub fn save_native(layers: &[hcie_protocol::Layer], path: &Path) -> Result<(), String> { hcie_native::save_native(layers, path) }

pub mod svg_import {
    use super::*;
    pub fn import_svg(data: &[u8]) -> Result<Vec<hcie_protocol::Layer>, String> { hcie_io::svg_import::import_svg(data) }
}

pub mod vector {
    use super::*;
    pub fn render_vector_shapes(layer: &mut hcie_protocol::Layer) { hcie_vector::render_vector_shapes(layer) }
    #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
    pub enum BooleanOp { Union, Intersect, Subtract, Xor }
    pub fn boolean_shapes(op: BooleanOp, a: &hcie_protocol::VectorShape, b: &hcie_protocol::VectorShape) -> Option<hcie_protocol::VectorShape> {
        let vop = match op { BooleanOp::Union => hcie_vector::path_boolean::BooleanOp::Union, BooleanOp::Intersect => hcie_vector::path_boolean::BooleanOp::Intersect, BooleanOp::Subtract => hcie_vector::path_boolean::BooleanOp::Subtract, BooleanOp::Xor => hcie_vector::path_boolean::BooleanOp::Xor };
        hcie_vector::path_boolean::boolean_shapes(vop, a, b)
    }
}

// ─────────────────────────────────────────────────────────────────────────────
// FFI — only hcie-ai and hcie-vision
// ─────────────────────────────────────────────────────────────────────────────

fn find_plugin_path(name: &str) -> Result<PathBuf, String> {
    let filename = if cfg!(target_os = "windows") { format!("{}.dll", name) } else if cfg!(target_os = "macos") { format!("lib{}.dylib", name) } else { format!("lib{}.so", name) };
    for base in &[PathBuf::from("plugins"), std::env::current_exe().ok().and_then(|p| p.parent().map(|d| d.join("plugins"))).unwrap_or_default()] {
        let p = base.join(&filename); if p.exists() { return Ok(p); }
    }
    if let Ok(cwd) = std::env::current_dir() { let mut c = cwd; for _ in 0..5 { let p = c.join("plugins").join(&filename); if p.exists() { return Ok(p); } if !c.pop() { break; } } }
    Err(format!("Plugin '{}' not found", name))
}

macro_rules! sym { ($lib:ident, $name:literal) => { *$lib.get(concat!($name, "\0").as_bytes()).expect(concat!("Failed to resolve ", $name)) }; }

struct AiPlugins {
    _lib_ai: Library, _lib_vision: Library,
    ai_chat_complete_fn: unsafe extern "C" fn(*const c_char, *const c_char, *mut *mut u8, *mut usize) -> bool,
    ai_session_create_fn: unsafe extern "C" fn(*const c_char) -> i64,
    ai_session_push_user_fn: unsafe extern "C" fn(i64, *const c_char) -> bool,
    ai_session_push_assistant_fn: unsafe extern "C" fn(i64, *const c_char) -> bool,
    ai_session_clear_fn: unsafe extern "C" fn(i64) -> bool,
    ai_session_destroy_fn: unsafe extern "C" fn(i64),
    ai_session_serialize_fn: unsafe extern "C" fn(i64, *mut *mut u8, *mut usize) -> bool,
    ai_template_names_fn: unsafe extern "C" fn(*mut *mut u8, *mut usize) -> bool,
    ai_template_get_fn: unsafe extern "C" fn(*const c_char, *mut *mut u8, *mut usize) -> bool,
    ai_template_search_fn: unsafe extern "C" fn(*const c_char, *mut *mut u8, *mut usize) -> bool,
    ai_template_execute_fn: unsafe extern "C" fn(*const c_char, *const c_char, *mut *mut u8, *mut usize) -> bool,
    ai_execute_action_fn: unsafe extern "C" fn(*const c_char, *mut *mut u8, *mut usize) -> bool,
    ai_free_buffer_fn: unsafe extern "C" fn(*mut u8, usize),
    vision_background_removal_fn: unsafe extern "C" fn(*const u8, usize, u32, u32, *mut *mut u8, *mut usize) -> bool,
    vision_object_segment_fn: unsafe extern "C" fn(*const u8, usize, u32, u32, u32, u32, u32, u32, u32, u32, *mut *mut u8, *mut usize) -> bool,
    vision_super_resolution_fn: unsafe extern "C" fn(*const u8, usize, u32, u32, *mut *mut u8, *mut usize) -> bool,
    vision_inpaint_fn: unsafe extern "C" fn(*mut u8, usize, u32, u32, *const u8, usize, i32) -> bool,
    vision_build_polygon_mask_fn: unsafe extern "C" fn(*const c_char, u32, u32, *mut *mut u8, *mut usize) -> bool,
    vision_build_stroke_mask_fn: unsafe extern "C" fn(*const c_char, *const u8, usize, f32, u32, u32, *mut *mut u8, *mut usize) -> bool,
    vision_free_buffer_fn: unsafe extern "C" fn(*mut u8, usize),
}

static AI: OnceLock<AiPlugins> = OnceLock::new();

fn ai_plugins() -> &'static AiPlugins {
    AI.get_or_init(|| {
        let ap = find_plugin_path("hcie_ai").expect("Critical: hcie_ai plugin not found");
        let vp = find_plugin_path("hcie_vision").expect("Critical: hcie_vision plugin not found");
        unsafe {
            let la = Library::new(ap).expect("Failed hcie_ai");
            let lv = Library::new(vp).expect("Failed hcie_vision");
            let ai_chat_complete_fn = *la.get(b"hcie_ai_chat_complete_c\0").unwrap();
            let ai_session_create_fn = *la.get(b"hcie_ai_session_create_c\0").unwrap();
            let ai_session_push_user_fn = *la.get(b"hcie_ai_session_push_user_c\0").unwrap();
            let ai_session_push_assistant_fn = *la.get(b"hcie_ai_session_push_assistant_c\0").unwrap();
            let ai_session_clear_fn = *la.get(b"hcie_ai_session_clear_c\0").unwrap();
            let ai_session_destroy_fn = *la.get(b"hcie_ai_session_destroy_c\0").unwrap();
            let ai_session_serialize_fn = *la.get(b"hcie_ai_session_serialize_c\0").unwrap();
            let ai_template_names_fn = *la.get(b"hcie_ai_template_names_c\0").unwrap();
            let ai_template_get_fn = *la.get(b"hcie_ai_template_get_c\0").unwrap();
            let ai_template_search_fn = *la.get(b"hcie_ai_template_search_c\0").unwrap();
            let ai_template_execute_fn = *la.get(b"hcie_ai_template_execute_c\0").unwrap();
            let ai_execute_action_fn = *la.get(b"hcie_ai_execute_action_c\0").unwrap();
            let ai_free_buffer_fn = *la.get(b"free_buffer_c\0").unwrap();
            let vision_background_removal_fn = *lv.get(b"hcie_vision_background_removal_c\0").unwrap();
            let vision_object_segment_fn = *lv.get(b"hcie_vision_object_segment_c\0").unwrap();
            let vision_super_resolution_fn = *lv.get(b"hcie_vision_super_resolution_c\0").unwrap();
            let vision_inpaint_fn = *lv.get(b"hcie_vision_inpaint_c\0").unwrap();
            let vision_build_polygon_mask_fn = *lv.get(b"hcie_vision_build_polygon_mask_c\0").unwrap();
            let vision_build_stroke_mask_fn = *lv.get(b"hcie_vision_build_stroke_mask_c\0").unwrap();
            let vision_free_buffer_fn = *lv.get(b"free_buffer_c\0").unwrap();
            AiPlugins {
                _lib_ai: la, _lib_vision: lv,
                ai_chat_complete_fn, ai_session_create_fn, ai_session_push_user_fn, ai_session_push_assistant_fn,
                ai_session_clear_fn, ai_session_destroy_fn, ai_session_serialize_fn, ai_template_names_fn,
                ai_template_get_fn, ai_template_search_fn, ai_template_execute_fn, ai_execute_action_fn, ai_free_buffer_fn,
                vision_background_removal_fn, vision_object_segment_fn, vision_super_resolution_fn,
                vision_inpaint_fn, vision_build_polygon_mask_fn, vision_build_stroke_mask_fn, vision_free_buffer_fn,
            }
        }
    })
}

macro_rules! ai { ($fn:ident, $($a:expr),*) => { unsafe { (ai_plugins().$fn)($($a),*) } }; }

pub mod ai {
    use super::*;
    macro_rules! c { ($e:expr) => { CString::new($e).unwrap() }; }
    pub fn chat_complete(config: &str, messages: &str) -> Result<Vec<u8>, String> {
        let (mut op, mut ol) = (std::ptr::null_mut(), 0);
        if ai!(ai_chat_complete_fn, c!(config).as_ptr(), c!(messages).as_ptr(), &mut op, &mut ol) {
            let data = unsafe { std::slice::from_raw_parts(op, ol).to_vec() }; ai!(ai_free_buffer_fn, op, ol); Ok(data)
        } else { Err("AI chat failed".into()) }
    }
    pub fn session_create(s: &str) -> i64 { ai!(ai_session_create_fn, c!(s).as_ptr()) }
    pub fn session_push_user(sid: i64, t: &str) -> bool { ai!(ai_session_push_user_fn, sid, c!(t).as_ptr()) }
    pub fn session_push_assistant(sid: i64, t: &str) -> bool { ai!(ai_session_push_assistant_fn, sid, c!(t).as_ptr()) }
    pub fn session_clear(sid: i64) -> bool { ai!(ai_session_clear_fn, sid) }
    pub fn session_destroy(sid: i64) { ai!(ai_session_destroy_fn, sid) }
    pub fn session_serialize(sid: i64) -> Option<Vec<u8>> {
        let (mut op, mut ol) = (std::ptr::null_mut(), 0);
        if ai!(ai_session_serialize_fn, sid, &mut op, &mut ol) { let d = unsafe { std::slice::from_raw_parts(op, ol).to_vec() }; ai!(ai_free_buffer_fn, op, ol); Some(d) } else { None }
    }
    pub fn template_names() -> Option<Vec<u8>> { let (mut op, mut ol) = (std::ptr::null_mut(), 0);
        if ai!(ai_template_names_fn, &mut op, &mut ol) { let d = unsafe { std::slice::from_raw_parts(op, ol).to_vec() }; ai!(ai_free_buffer_fn, op, ol); Some(d) } else { None } }
    pub fn template_get(name: &str) -> Option<Vec<u8>> { let (mut op, mut ol) = (std::ptr::null_mut(), 0); let n = CString::new(name).ok()?;
        if ai!(ai_template_get_fn, n.as_ptr(), &mut op, &mut ol) { let d = unsafe { std::slice::from_raw_parts(op, ol).to_vec() }; ai!(ai_free_buffer_fn, op, ol); Some(d) } else { None } }
    pub fn template_execute(name: &str, params: &str) -> Option<Vec<u8>> { let (mut op, mut ol) = (std::ptr::null_mut(), 0);
        let (n, j) = (CString::new(name).ok()?, CString::new(params).ok()?);
        if ai!(ai_template_execute_fn, n.as_ptr(), j.as_ptr(), &mut op, &mut ol) { let d = unsafe { std::slice::from_raw_parts(op, ol).to_vec() }; ai!(ai_free_buffer_fn, op, ol); Some(d) } else { None } }
    pub fn execute_action(json: &str) -> Option<Vec<u8>> { let (mut op, mut ol) = (std::ptr::null_mut(), 0); let j = CString::new(json).ok()?;
        if ai!(ai_execute_action_fn, j.as_ptr(), &mut op, &mut ol) { let d = unsafe { std::slice::from_raw_parts(op, ol).to_vec() }; ai!(ai_free_buffer_fn, op, ol); Some(d) } else { None } }
}

pub mod vision {
    use super::*;
    pub fn background_removal(img: &[u8], w: u32, h: u32) -> Option<Vec<u8>> {
        let (mut op, mut ol) = (std::ptr::null_mut(), 0);
        if ai!(vision_background_removal_fn, img.as_ptr(), img.len(), w, h, &mut op, &mut ol) { let d = unsafe { std::slice::from_raw_parts(op, ol).to_vec() }; ai!(vision_free_buffer_fn, op, ol); Some(d) } else { None }
    }
    pub fn object_segment(img: &[u8], w: u32, h: u32, px: u32, py: u32, bx0: u32, by0: u32, bx1: u32, by1: u32) -> Option<Vec<u8>> {
        let (mut op, mut ol) = (std::ptr::null_mut(), 0);
        if ai!(vision_object_segment_fn, img.as_ptr(), img.len(), w, h, px, py, bx0, by0, bx1, by1, &mut op, &mut ol) { let d = unsafe { std::slice::from_raw_parts(op, ol).to_vec() }; ai!(vision_free_buffer_fn, op, ol); Some(d) } else { None }
    }
    pub fn super_resolution(img: &[u8], w: u32, h: u32) -> Option<Vec<u8>> {
        let (mut op, mut ol) = (std::ptr::null_mut(), 0);
        if ai!(vision_super_resolution_fn, img.as_ptr(), img.len(), w, h, &mut op, &mut ol) { let d = unsafe { std::slice::from_raw_parts(op, ol).to_vec() }; ai!(vision_free_buffer_fn, op, ol); Some(d) } else { None }
    }
    pub fn inpaint(pixels: &mut [u8], w: u32, h: u32, mask: &[u8], r: i32) -> bool { ai!(vision_inpaint_fn, pixels.as_mut_ptr(), pixels.len(), w, h, mask.as_ptr(), mask.len(), r) }
    pub fn build_polygon_mask(json: &str, w: u32, h: u32) -> Option<Vec<u8>> {
        let (mut op, mut ol) = (std::ptr::null_mut(), 0); let j = CString::new(json).ok()?;
        if ai!(vision_build_polygon_mask_fn, j.as_ptr(), w, h, &mut op, &mut ol) { let d = unsafe { std::slice::from_raw_parts(op, ol).to_vec() }; ai!(vision_free_buffer_fn, op, ol); Some(d) } else { None }
    }
    pub fn build_stroke_mask(json: &str, sel: &[u8], r: f32, w: u32, h: u32) -> Option<Vec<u8>> {
        let (mut op, mut ol) = (std::ptr::null_mut(), 0); let j = CString::new(json).ok()?;
        if ai!(vision_build_stroke_mask_fn, j.as_ptr(), sel.as_ptr(), sel.len(), r, w, h, &mut op, &mut ol) { let d = unsafe { std::slice::from_raw_parts(op, ol).to_vec() }; ai!(vision_free_buffer_fn, op, ol); Some(d) } else { None }
    }
}