//! Cubism Model 加载与管理
//!
//! 封装 moc3 读取 → revive → model 初始化 → 参数更新 → drawable 数据提取。

use super::core_ffi::{
    alloc_aligned, AlignedBuffer, CubismCore, CsmVector2, CSM_ALIGNOF_MOC, CSM_ALIGNOF_MODEL,
};
use anyhow::{anyhow, Context, Result};
use std::path::Path;

/// 一个 drawable 的渲染所需数据快照
#[derive(Clone)]
pub struct DrawableSnapshot {
    /// 在 Core drawable 数组中的原始索引（用于查 mask 引用）
    pub index: usize,
    pub texture_index: i32,
    pub draw_order: i32,
    pub render_order: i32,
    pub opacity: f32,
    pub blend_mode: i32,
    pub constant_flags: u8,
    pub dynamic_flags: u8,
    pub vertex_positions: Vec<[f32; 2]>,
    pub vertex_uvs: Vec<[f32; 2]>,
    pub indices: Vec<u16>,
    pub multiply_color: [f32; 4],
    pub screen_color: [f32; 4],
    /// 本 drawable 依赖的 mask drawable 索引（空表示无遮罩）
    pub mask_indices: Vec<i32>,
    pub mask_counts: i32,
}

/// Canvas 信息
#[derive(Clone, Copy, Debug, Default)]
pub struct CanvasInfo {
    pub size: [f32; 2],
    pub origin: [f32; 2],
    pub pixels_per_unit: f32,
}

/// 参数信息
pub struct ParameterInfo {
    pub id: String,
    pub min_value: f32,
    pub max_value: f32,
    pub default_value: f32,
}

/// 活跃的 Cubism Model
pub struct CubismModel {
    /// Core 句柄（保持引用防止 .so 卸载）
    _core: std::sync::Arc<CubismCore>,
    /// moc3 原始数据（对齐 64）
    _moc_buf: AlignedBuffer,
    /// moc 指针
    moc: *mut std::ffi::c_void,
    /// model 内存（对齐 16）
    _model_buf: AlignedBuffer,
    /// model 指针
    model: *mut std::ffi::c_void,
    /// 参数数量
    pub param_count: usize,
    /// 参数 ID 列表（与 Core 内部顺序一致）
    pub param_ids: Vec<String>,
    /// 参数索引映射（id → index）
    pub param_index: std::collections::HashMap<String, usize>,
    /// Part 数量
    pub part_count: usize,
    /// Part ID 列表（与 Core 内部顺序一致）
    pub part_ids: Vec<String>,
    /// Part 索引映射（id → index）
    pub part_index: std::collections::HashMap<String, usize>,
    /// drawable 数量
    pub drawable_count: usize,
    /// canvas 信息
    pub canvas: CanvasInfo,
}

// model 指针可跨线程发送（渲染线程独占使用）
unsafe impl Send for CubismModel {}

impl CubismModel {
    /// 从 moc3 文件加载 model
    pub fn load(core: std::sync::Arc<CubismCore>, moc3_path: &Path) -> Result<Self> {
        let moc_data = std::fs::read(moc3_path)
            .with_context(|| format!("读取 moc3 失败: {}", moc3_path.display()))?;

        // 分配 64 对齐内存
        let mut moc_buf = alloc_aligned(moc_data.len(), CSM_ALIGNOF_MOC)?;
        unsafe {
            std::ptr::copy_nonoverlapping(moc_data.as_ptr(), moc_buf.as_ptr(), moc_data.len());
        }

        // 检查一致性
        let valid = unsafe {
            (core.csm_has_moc_consistency)(moc_buf.as_mut_void(), moc_data.len() as u32)
        };
        if valid != 1 {
            return Err(anyhow!("moc3 一致性检查失败（文件损坏或版本不支持）"));
        }

        // Revive moc
        let moc = unsafe {
            (core.csm_revive_moc_in_place)(moc_buf.as_mut_void(), moc_data.len() as u32)
        };
        if moc.is_null() {
            return Err(anyhow!("csmReviveMocInPlace 返回空指针"));
        }

        // 获取 model 所需大小
        let model_size = unsafe { (core.csm_get_sizeof_model)(moc) };
        if model_size == 0 {
            return Err(anyhow!("csmGetSizeofModel 返回 0"));
        }

        // 分配 16 对齐内存
        let mut model_buf = alloc_aligned(model_size as usize, CSM_ALIGNOF_MODEL)?;
        let model = unsafe {
            (core.csm_initialize_model_in_place)(
                moc,
                model_buf.as_mut_void(),
                model_size,
            )
        };
        if model.is_null() {
            return Err(anyhow!("csmInitializeModelInPlace 返回空指针"));
        }

        // 读取参数信息
        let param_count = unsafe { (core.csm_get_parameter_count)(model) } as usize;
        let param_ids_ptr = unsafe { (core.csm_get_parameter_ids)(model) };
        let mut param_ids = Vec::with_capacity(param_count);
        let mut param_index = std::collections::HashMap::new();
        for i in 0..param_count {
            let id = unsafe {
                super::core_ffi::cstr_ptr_to_string(*param_ids_ptr.add(i))
                    .unwrap_or_default()
            };
            param_index.insert(id.clone(), i);
            param_ids.push(id);
        }

        // 读取 part 信息（Pose 会按 PartOpacity 切换互斥部件，如 Haru 的两组手臂）
        let part_count = unsafe { (core.csm_get_part_count)(model) } as usize;
        let part_ids_ptr = unsafe { (core.csm_get_part_ids)(model) };
        let mut part_ids = Vec::with_capacity(part_count);
        let mut part_index = std::collections::HashMap::new();
        for i in 0..part_count {
            let id = unsafe {
                super::core_ffi::cstr_ptr_to_string(*part_ids_ptr.add(i))
                    .unwrap_or_default()
            };
            part_index.insert(id.clone(), i);
            part_ids.push(id);
        }

        // 读取 drawable 数量
        let drawable_count = unsafe { (core.csm_get_drawable_count)(model) } as usize;

        // 读取 canvas 信息
        let mut size = CsmVector2::default();
        let mut origin = CsmVector2::default();
        let mut ppu = 0.0f32;
        unsafe {
            (core.csm_read_canvas_info)(model, &mut size, &mut origin, &mut ppu);
        }

        let canvas = CanvasInfo {
            size: [size.x, size.y],
            origin: [origin.x, origin.y],
            pixels_per_unit: ppu,
        };

        println!(
            "[Live2D] 模型加载成功: 参数={} part={} drawable={} canvas={:?} origin=({:.1},{:.1})x{:.0}ppu",
            param_count, part_count, drawable_count, canvas.size, canvas.origin[0], canvas.origin[1], canvas.pixels_per_unit
        );

        Ok(Self {
            _core: core,
            _moc_buf: moc_buf,
            moc,
            _model_buf: model_buf,
            model,
            param_count,
            param_ids,
            param_index,
            part_count,
            part_ids,
            part_index,
            drawable_count,
            canvas,
        })
    }

    /// 获取参数最小值
    pub fn param_min_values(&self, core: &CubismCore) -> Vec<f32> {
        unsafe {
            let p = (core.csm_get_parameter_minimum_values)(self.model);
            std::slice::from_raw_parts(p, self.param_count).to_vec()
        }
    }

    /// 获取参数最大值
    pub fn param_max_values(&self, core: &CubismCore) -> Vec<f32> {
        unsafe {
            let p = (core.csm_get_parameter_maximum_values)(self.model);
            std::slice::from_raw_parts(p, self.param_count).to_vec()
        }
    }

    /// 获取参数默认值
    pub fn param_default_values(&self, core: &CubismCore) -> Vec<f32> {
        unsafe {
            let p = (core.csm_get_parameter_default_values)(self.model);
            std::slice::from_raw_parts(p, self.param_count).to_vec()
        }
    }

    /// 获取参数值缓冲区（可读写）
    pub fn param_values_mut(&self, core: &CubismCore) -> &mut [f32] {
        unsafe {
            let p = (core.csm_get_parameter_values)(self.model);
            std::slice::from_raw_parts_mut(p, self.param_count)
        }
    }

    /// 按参数 ID 设置值
    pub fn set_param(&self, core: &CubismCore, id: &str, value: f32) -> bool {
        if let Some(&idx) = self.param_index.get(id) {
            self.set_param_by_index(core, idx, value);
            true
        } else {
            false
        }
    }

    /// 按参数索引设置值
    pub fn set_param_by_index(&self, core: &CubismCore, index: usize, value: f32) {
        if index < self.param_count {
            let slice = self.param_values_mut(core);
            slice[index] = value;
        }
    }

    /// 按参数 ID 获取值
    pub fn get_param(&self, core: &CubismCore, id: &str) -> Option<f32> {
        let idx = *self.param_index.get(id)?;
        self.get_param_by_index(core, idx)
    }

    /// 按参数索引获取值
    pub fn get_param_by_index(&self, core: &CubismCore, index: usize) -> Option<f32> {
        if index >= self.param_count {
            return None;
        }
        let slice = self.param_values_mut(core);
        Some(slice[index])
    }

    /// 将所有参数重置为默认值
    pub fn reset_to_default(&self, core: &CubismCore) {
        let defaults = self.param_default_values(core);
        let slice = self.param_values_mut(core);
        for (i, v) in defaults.into_iter().enumerate() {
            slice[i] = v;
        }
    }

    /// 获取 PartOpacity 缓冲区（可读写）
    pub fn part_opacities_mut(&self, core: &CubismCore) -> &mut [f32] {
        unsafe {
            let p = (core.csm_get_part_opacities)(self.model);
            std::slice::from_raw_parts_mut(p, self.part_count)
        }
    }

    /// 按 Part ID 获取索引
    pub fn part_index(&self, id: &str) -> Option<usize> {
        self.part_index.get(id).copied()
    }

    /// 按 Part 索引设置 opacity
    pub fn set_part_opacity_by_index(&self, core: &CubismCore, index: usize, opacity: f32) {
        if index < self.part_count {
            let slice = self.part_opacities_mut(core);
            slice[index] = opacity.clamp(0.0, 1.0);
        }
    }

    /// 按 Part 索引获取 opacity
    pub fn get_part_opacity_by_index(&self, core: &CubismCore, index: usize) -> Option<f32> {
        if index >= self.part_count {
            return None;
        }
        let slice = self.part_opacities_mut(core);
        Some(slice[index])
    }

    /// 更新 model（应用参数变化，重新计算顶点/不透明度等）
    pub fn update(&self, core: &CubismCore) {
        unsafe { (core.csm_update_model)(self.model) };
    }

    /// 重置动态标志
    pub fn reset_dynamic_flags(&self, core: &CubismCore) {
        unsafe { (core.csm_reset_drawable_dynamic_flags)(self.model) };
    }

    /// 获取所有 drawable 的渲染数据快照（按 render order 排序）
    pub fn drawable_snapshots(&self, core: &CubismCore) -> Vec<DrawableSnapshot> {
        let count = self.drawable_count;
        unsafe {
            let render_orders = (core.csm_get_render_orders)(self.model);
            let texture_indices = (core.csm_get_drawable_texture_indices)(self.model);
            let draw_orders = (core.csm_get_drawable_draw_orders)(self.model);
            let opacities = (core.csm_get_drawable_opacities)(self.model);
            let blend_modes = (core.csm_get_drawable_blend_modes)(self.model);
            let const_flags = (core.csm_get_drawable_constant_flags)(self.model);
            let dyn_flags = (core.csm_get_drawable_dynamic_flags)(self.model);
            let mask_counts = (core.csm_get_drawable_mask_counts)(self.model);
            let vertex_counts = (core.csm_get_drawable_vertex_counts)(self.model);
            let vertex_positions = (core.csm_get_drawable_vertex_positions)(self.model);
            let vertex_uvs = (core.csm_get_drawable_vertex_uvs)(self.model);
            let index_counts = (core.csm_get_drawable_index_counts)(self.model);
            let indices = (core.csm_get_drawable_indices)(self.model);
            let multiply_colors = (core.csm_get_drawable_multiply_colors)(self.model);
            let screen_colors = (core.csm_get_drawable_screen_colors)(self.model);
            let masks = (core.csm_get_drawable_masks)(self.model);

            // 先收集每个 drawable 的原始索引
            let mut items: Vec<(usize, i32)> = (0..count)
                .map(|i| (i, *render_orders.add(i)))
                .collect();
            // 按 render_order 升序排列
            items.sort_by_key(|&(_, ro)| ro);

            items
                .into_iter()
                .map(|(i, ro)| {
                    let vc = *vertex_counts.add(i) as usize;
                    let ic = *index_counts.add(i) as usize;
                    let vp = *vertex_positions.add(i);
                    let vu = *vertex_uvs.add(i);
                    let idx = *indices.add(i);

                    let mut verts = Vec::with_capacity(vc);
                    let mut uvs = Vec::with_capacity(vc);
                    for v in 0..vc {
                        let p = *vp.add(v);
                        let u = *vu.add(v);
                        verts.push([p.x, p.y]);
                        uvs.push([u.x, u.y]);
                    }
                    let mut idx_vec = Vec::with_capacity(ic);
                    for k in 0..ic {
                        idx_vec.push(*idx.add(k));
                    }

                    let mc = *multiply_colors.add(i);
                    let sc = *screen_colors.add(i);

                    // 取出本 drawable 的 mask 索引列表
                    let mk = *mask_counts.add(i) as usize;
                    let mut mask_indices: Vec<i32> = Vec::with_capacity(mk);
                    if mk > 0 {
                        let mptr = *masks.add(i);
                        for k in 0..mk {
                            mask_indices.push(*mptr.add(k));
                        }
                    }

                    DrawableSnapshot {
                        index: i,
                        texture_index: *texture_indices.add(i),
                        draw_order: *draw_orders.add(i),
                        render_order: ro,
                        opacity: *opacities.add(i),
                        blend_mode: *blend_modes.add(i),
                        constant_flags: *const_flags.add(i),
                        dynamic_flags: *dyn_flags.add(i),
                        vertex_positions: verts,
                        vertex_uvs: uvs,
                        indices: idx_vec,
                        multiply_color: [mc.x, mc.y, mc.z, mc.w],
                        screen_color: [sc.x, sc.y, sc.z, sc.w],
                        mask_indices,
                        mask_counts: mk as i32,
                    }
                })
                .collect()
        }
    }
}