gmsh_ffi 0.1.0

//! 安全封装 Gmsh C API，提供树状结构：Gmsh -> Model -> (Mesh, Geo, Occ, View...)

use std::ffi::{CStr, CString};
use std::os::raw::{c_char, c_int};
use std::ptr;

// 引入 bindgen 生成的绑定
// 假设绑定模块名为 bingings（根据您提供的文件名）
use crate::bindings as ffi;

// ========================= 错误处理 =========================

/// Gmsh 操作错误。
#[derive(Debug, Clone)]
pub struct GmshError {
    message: String,
}

impl GmshError {
    fn new(msg: String) -> Self {
        Self { message: msg }
    }
}

impl std::fmt::Display for GmshError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Gmsh error: {}", self.message)
    }
}

impl std::error::Error for GmshError {}

/// 宏：执行返回 ierr 的 C 函数，并转换为 Result。
#[macro_export]
macro_rules! check_err {
    ($call:expr) => {{
        let mut ierr = 0;
        let res = $call(&mut ierr);
        if ierr == 0 {
            Ok(res)
        } else {
            let msg = unsafe {
                let mut err_ptr = std::ptr::null_mut();
                ffi::gmshLoggerGetLastError(&mut err_ptr, std::ptr::null_mut());
                if err_ptr.is_null() {
                    "unknown error".to_string()
                } else {
                    std::ffi::CStr::from_ptr(err_ptr)
                        .to_string_lossy()
                        .into_owned()
                }
            };
            Err(GmshError::new(msg))
        }
    }};
}

// ========================= 辅助函数 =========================

/// 将 C 字符串转换为 String，并释放原始内存。
unsafe fn cstr_to_string_and_free(ptr: *mut c_char) -> String {
    if ptr.is_null() {
        return String::new();
    }
    // SAFETY: 调用者保证 ptr 指向有效 C 字符串
    let s = unsafe { CStr::from_ptr(ptr) }.to_string_lossy().into_owned();
    unsafe { ffi::gmshFree(ptr as *mut _) };
    s
}

/// 将 C 字符串数组转换为 Vec<String>，并释放数组内存。
unsafe fn cstr_array_to_vec_and_free(ptr: *mut *mut c_char, len: usize) -> Vec<String> {
    let mut vec = Vec::with_capacity(len);
    for i in 0..len {
        let s_ptr = unsafe { *ptr.add(i) };
        if !s_ptr.is_null() {
            vec.push(unsafe { cstr_to_string_and_free(s_ptr) });
        }
    }
    unsafe { ffi::gmshFree(ptr as *mut _) };
    vec
}

/// 将 Rust 字符串转换为 C 字符串。
fn to_cstring(s: &str) -> CString {
    CString::new(s).expect("CString conversion failed")
}

/// 将 (dim, tag) 实体列表转换为 C 接口所需的交错数组。
fn dimtags_to_cvec(dimtags: &[(i32, i32)]) -> Vec<i32> {
    let mut v = Vec::with_capacity(dimtags.len() * 2);
    for &(dim, tag) in dimtags {
        v.push(dim);
        v.push(tag);
    }
    v
}

// ========================= 顶层结构：Gmsh =========================

/// Gmsh 全局状态。
pub struct Gmsh;

impl Gmsh {
    /// 初始化 Gmsh。
    ///
    /// # 参数
    /// - `args`: 命令行参数（通常为 `std::env::args().collect()`）。
    /// - `read_config_files`: 是否读取配置文件。
    /// - `run`: 是否立即运行 GUI 事件循环（如果为 true，则阻塞）。
    pub fn new(args: Vec<String>, read_config_files: bool, run: bool) -> Result<Self, GmshError> {
        let mut c_args: Vec<CString> = args.into_iter().map(|s| to_cstring(&s)).collect();
        let mut c_argv: Vec<*mut c_char> = c_args.iter_mut().map(|c| c.as_ptr() as *mut _).collect();
        let argc = c_argv.len() as c_int;
        let argv_ptr = if c_argv.is_empty() {
            ptr::null_mut()
        } else {
            c_argv.as_mut_ptr()
        };
        unsafe {
            check_err!(|ierr| {
                ffi::gmshInitialize(
                    argc,
                    argv_ptr,
                    if read_config_files { 1 } else { 0 },
                    if run { 1 } else { 0 },
                    ierr,
                )
            })?;
        }
        Ok(Gmsh)
    }

    /// 使用默认参数初始化（从环境读取参数，读取配置文件，不运行 GUI）。
    pub fn new_default() -> Result<Self, GmshError> {
        Self::new(std::env::args().collect(), true, false)
    }

    /// 结束 Gmsh，释放所有资源。
    pub fn finalize(self) -> Result<(), GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshFinalize(ierr))?;
        }
        // 防止析构时再次调用 finalize
        std::mem::forget(self);
        Ok(())
    }

    /// 添加一个新模型，并设为当前模型。
    pub fn add_model(&self, name: &str) -> Result<Model, GmshError> {
        let c_name = to_cstring(name);
        unsafe {
            check_err!(|ierr| ffi::gmshModelAdd(c_name.as_ptr(), ierr))?;
        }
        Ok(Model { name: name.to_string() })
    }

    /// 获取当前模型的名称。
    pub fn current_model(&self) -> Result<Model, GmshError> {
        let mut name_ptr = ptr::null_mut();
        unsafe {
            check_err!(|ierr| ffi::gmshModelGetCurrent(&mut name_ptr, ierr))?;
            let name = unsafe { cstr_to_string_and_free(name_ptr) };
            Ok(Model { name })
        }
    }

    /// 设置当前模型。
    pub fn set_current_model(&self, name: &str) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        unsafe {
            check_err!(|ierr| ffi::gmshModelSetCurrent(c_name.as_ptr(), ierr))
        }
    }

    /// 列出所有模型名称。
    pub fn list_models(&self) -> Result<Vec<String>, GmshError> {
        let mut names_ptr = ptr::null_mut();
        let mut names_n = 0;
        unsafe {
            check_err!(|ierr| ffi::gmshModelList(&mut names_ptr, &mut names_n, ierr))?;
            Ok(unsafe { cstr_array_to_vec_and_free(names_ptr, names_n) })
        }
    }

    /// 移除当前模型（及其所有数据）。
    pub fn remove_current_model(&self) -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshModelRemove(ierr)) }
    }

    /// 获取当前模型的文件名。
    pub fn model_file_name(&self) -> Result<String, GmshError> {
        let mut name_ptr = ptr::null_mut();
        unsafe {
            check_err!(|ierr| ffi::gmshModelGetFileName(&mut name_ptr, ierr))?;
            Ok(unsafe { cstr_to_string_and_free(name_ptr) })
        }
    }

    /// 设置当前模型的文件名（用于保存）。
    pub fn set_model_file_name(&self, name: &str) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        unsafe {
            check_err!(|ierr| ffi::gmshModelSetFileName(c_name.as_ptr(), ierr))
        }
    }
}

impl Drop for Gmsh {
    fn drop(&mut self) {
        // 忽略 finalize 错误
        let _ = unsafe { ffi::gmshFinalize(ptr::null_mut()) };
    }
}

// ========================= 模型及其子模块 =========================

/// 模型句柄，包含网格、几何等子结构。
pub struct Model {
    name: String,
}

impl Model {
    /// 获取模型名称。
    pub fn name(&self) -> &str {
        &self.name
    }

    /// 生成网格。
    ///
    /// # 参数
    /// - `dim`: 要生成的网格维度（1: 线, 2: 面, 3: 体）。默认为 3。
    pub fn generate_mesh(&self, dim: i32) -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshModelMeshGenerate(dim, ierr)) }
    }

    /// 获取实体列表。
    ///
    /// # 参数
    /// - `dim`: 限制维度（-1 表示所有维度）。
    pub fn get_entities(&self, dim: i32) -> Result<Vec<(i32, i32)>, GmshError> {
        let mut dimtags_ptr = ptr::null_mut();
        let mut dimtags_n = 0;
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelGetEntities(&mut dimtags_ptr, &mut dimtags_n, dim, ierr)
            })?;
            let mut entities = Vec::with_capacity(dimtags_n / 2);
            for i in 0..(dimtags_n / 2) {
                let d = *dimtags_ptr.add(i * 2);
                let t = *dimtags_ptr.add(i * 2 + 1);
                entities.push((d, t));
            }
            ffi::gmshFree(dimtags_ptr as *mut _);
            Ok(entities)
        }
    }

    /// 获取指定维度的所有实体的标签。
    pub fn get_entity_tags(&self, dim: i32) -> Result<Vec<i32>, GmshError> {
        let entities = self.get_entities(dim)?;
        Ok(entities.into_iter().map(|(_, tag)| tag).collect())
    }

    /// 设置实体的名称。
    pub fn set_entity_name(&self, dim: i32, tag: i32, name: &str) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        unsafe {
            check_err!(|ierr| ffi::gmshModelSetEntityName(dim, tag, c_name.as_ptr(), ierr))
        }
    }

    /// 获取实体的名称。
    pub fn get_entity_name(&self, dim: i32, tag: i32) -> Result<String, GmshError> {
        let mut name_ptr = ptr::null_mut();
        unsafe {
            check_err!(|ierr| ffi::gmshModelGetEntityName(dim, tag, &mut name_ptr, ierr))?;
            Ok(unsafe { cstr_to_string_and_free(name_ptr) })
        }
    }

    /// 添加物理组。
    ///
    /// # 参数
    /// - `dim`: 物理组维度。
    /// - `tags`: 包含在该物理组中的实体标签列表。
    /// - `tag`: 物理组标签（0 表示自动分配）。
    /// - `name`: 物理组名称（可选）。
    ///
    /// 返回分配的物理组标签。
    pub fn add_physical_group(
        &self,
        dim: i32,
        tags: &[i32],
        tag: i32,
        name: Option<&str>,
    ) -> Result<i32, GmshError> {
        let c_name = name.map(to_cstring).unwrap_or_else(|| CString::new("").unwrap());
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelAddPhysicalGroup(dim, tags.as_ptr(), tags.len(), tag, c_name.as_ptr(), ierr)
            })
        }
    }

    /// 获取所有物理组。
    ///
    /// # 参数
    /// - `dim`: 限制维度（-1 表示所有维度）。
    pub fn get_physical_groups(&self, dim: i32) -> Result<Vec<(i32, i32)>, GmshError> {
        let mut dimtags_ptr = ptr::null_mut();
        let mut dimtags_n = 0;
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelGetPhysicalGroups(&mut dimtags_ptr, &mut dimtags_n, dim, ierr)
            })?;
            let mut groups = Vec::with_capacity(dimtags_n / 2);
            for i in 0..(dimtags_n / 2) {
                let d = *dimtags_ptr.add(i * 2);
                let t = *dimtags_ptr.add(i * 2 + 1);
                groups.push((d, t));
            }
            ffi::gmshFree(dimtags_ptr as *mut _);
            Ok(groups)
        }
    }

    /// 获取指定物理组中包含的实体标签。
    pub fn get_entities_for_physical_group(&self, dim: i32, tag: i32) -> Result<Vec<i32>, GmshError> {
        let mut tags_ptr = ptr::null_mut();
        let mut tags_n = 0;
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelGetEntitiesForPhysicalGroup(dim, tag, &mut tags_ptr, &mut tags_n, ierr)
            })?;
            let tags = std::slice::from_raw_parts(tags_ptr, tags_n).to_vec();
            ffi::gmshFree(tags_ptr as *mut _);
            Ok(tags)
        }
    }

    /// 设置物理组的名称。
    pub fn set_physical_name(&self, dim: i32, tag: i32, name: &str) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        unsafe {
            check_err!(|ierr| ffi::gmshModelSetPhysicalName(dim, tag, c_name.as_ptr(), ierr))
        }
    }

    /// 获取物理组的名称。
    pub fn get_physical_name(&self, dim: i32, tag: i32) -> Result<String, GmshError> {
        let mut name_ptr = ptr::null_mut();
        unsafe {
            check_err!(|ierr| ffi::gmshModelGetPhysicalName(dim, tag, &mut name_ptr, ierr))?;
            Ok(unsafe { cstr_to_string_and_free(name_ptr) })
        }
    }

    /// 获取实体的边界（低维实体）。
    pub fn get_boundary(
        &self,
        entities: &[(i32, i32)],
        combined: bool,
        oriented: bool,
        recursive: bool,
    ) -> Result<Vec<(i32, i32)>, GmshError> {
        let dimtags = dimtags_to_cvec(entities);
        let mut out_ptr = ptr::null_mut();
        let mut out_n = 0;
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelGetBoundary(
                    dimtags.as_ptr(),
                    dimtags.len(),
                    &mut out_ptr,
                    &mut out_n,
                    if combined { 1 } else { 0 },
                    if oriented { 1 } else { 0 },
                    if recursive { 1 } else { 0 },
                    ierr,
                )
            })?;
            let mut boundary = Vec::with_capacity(out_n / 2);
            for i in 0..(out_n / 2) {
                let d = *out_ptr.add(i * 2);
                let t = *out_ptr.add(i * 2 + 1);
                boundary.push((d, t));
            }
            ffi::gmshFree(out_ptr as *mut _);
            Ok(boundary)
        }
    }

    /// 获取实体的包围盒。
    pub fn get_bounding_box(&self, dim: i32, tag: i32) -> Result<[f64; 6], GmshError> {
        let mut xmin = 0.0;
        let mut ymin = 0.0;
        let mut zmin = 0.0;
        let mut xmax = 0.0;
        let mut ymax = 0.0;
        let mut zmax = 0.0;
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelGetBoundingBox(dim, tag, &mut xmin, &mut ymin, &mut zmin, &mut xmax, &mut ymax, &mut zmax, ierr)
            })?;
            Ok([xmin, ymin, zmin, xmax, ymax, zmax])
        }
    }

    /// 获取当前模型的维度（最高维实体的维度）。
    pub fn get_dimension(&self) -> Result<i32, GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshModelGetDimension(ierr)) }
    }

    /// 返回网格操作子对象。
    pub fn mesh(&self) -> Mesh {
        Mesh { model_name: self.name.clone() }
    }

    /// 返回内置几何（Gmsh 原生）子对象。
    pub fn geo(&self) -> Geo {
        Geo { _model_name: self.name.clone() }
    }

    /// 返回 OpenCASCADE 几何子对象。
    pub fn occ(&self) -> Occ {
        Occ { _model_name: self.name.clone() }
    }

    /// 写入网格文件。
    pub fn write(&self, filename: &str) -> Result<(), GmshError> {
        let c_filename = to_cstring(filename);
        unsafe { check_err!(|ierr| ffi::gmshWrite(c_filename.as_ptr(), ierr)) }
    }
}

// ========================= 网格模块 =========================

/// 网格操作。
pub struct Mesh {
    model_name: String,
}

impl Mesh {
    /// 获取所有节点。
    pub fn get_nodes(
        &self,
        dim: i32,
        tag: i32,
        include_boundary: bool,
        return_parametric: bool,
    ) -> Result<(Vec<usize>, Vec<f64>, Vec<f64>), GmshError> {
        let mut node_tags_ptr = ptr::null_mut();
        let mut node_tags_n = 0;
        let mut coord_ptr = ptr::null_mut();
        let mut coord_n = 0;
        let mut param_ptr = ptr::null_mut();
        let mut param_n = 0;
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelMeshGetNodes(
                    &mut node_tags_ptr,
                    &mut node_tags_n,
                    &mut coord_ptr,
                    &mut coord_n,
                    &mut param_ptr,
                    &mut param_n,
                    dim,
                    tag,
                    if include_boundary { 1 } else { 0 },
                    if return_parametric { 1 } else { 0 },
                    ierr,
                )
            })?;
            let node_tags = if node_tags_ptr.is_null() {
                Vec::new()
            } else {
                std::slice::from_raw_parts(node_tags_ptr, node_tags_n).to_vec()
            };
            let coords = if coord_ptr.is_null() {
                Vec::new()
            } else {
                std::slice::from_raw_parts(coord_ptr, coord_n).to_vec()
            };
            let param_coords = if param_ptr.is_null() {
                Vec::new()
            } else {
                std::slice::from_raw_parts(param_ptr, param_n).to_vec()
            };
            ffi::gmshFree(node_tags_ptr as *mut _);
            ffi::gmshFree(coord_ptr as *mut _);
            ffi::gmshFree(param_ptr as *mut _);
            Ok((node_tags, coords, param_coords))
        }
    }

    /// 获取元素信息。
    pub fn get_elements(
        &self,
        dim: i32,
        tag: i32,
    ) -> Result<(Vec<i32>, Vec<Vec<usize>>, Vec<Vec<usize>>), GmshError> {
        let mut element_types_ptr = ptr::null_mut();
        let mut element_types_n = 0;
        let mut element_tags_ptr = ptr::null_mut();
        let mut element_tags_n_ptr = ptr::null_mut();
        let mut element_tags_nn = 0;
        let mut node_tags_ptr = ptr::null_mut();
        let mut node_tags_n_ptr = ptr::null_mut();
        let mut node_tags_nn = 0;
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelMeshGetElements(
                    &mut element_types_ptr,
                    &mut element_types_n,
                    &mut element_tags_ptr,
                    &mut element_tags_n_ptr,
                    &mut element_tags_nn,
                    &mut node_tags_ptr,
                    &mut node_tags_n_ptr,
                    &mut node_tags_nn,
                    dim,
                    tag,
                    ierr,
                )
            })?;

            let element_types = if element_types_ptr.is_null() {
                Vec::new()
            } else {
                std::slice::from_raw_parts(element_types_ptr, element_types_n).to_vec()
            };

            let element_tags_n_slice = if element_tags_n_ptr.is_null() {
                &[]
            } else {
                std::slice::from_raw_parts(element_tags_n_ptr, element_types_n)
            };
            let element_tags_flat = if element_tags_ptr.is_null() {
                &[]
            } else {
                std::slice::from_raw_parts(element_tags_ptr, element_tags_nn)
            };
            let mut element_tags = Vec::with_capacity(element_types_n);
            let mut start = 0;
            for &n in element_tags_n_slice {
                let end = start + n;
                // 将 *mut usize 转换为 usize
                let slice = element_tags_flat[start..end]
                    .iter()
                    .map(|&ptr| ptr as usize)
                    .collect();
                element_tags.push(slice);
                start = end;
            }

            let node_tags_n_slice = if node_tags_n_ptr.is_null() {
                &[]
            } else {
                std::slice::from_raw_parts(node_tags_n_ptr, element_types_n)
            };
            let node_tags_flat = if node_tags_ptr.is_null() {
                &[]
            } else {
                std::slice::from_raw_parts(node_tags_ptr, node_tags_nn)
            };
            let mut node_tags = Vec::with_capacity(element_types_n);
            let mut start = 0;
            for &n in node_tags_n_slice {
                let end = start + n;
                let slice = node_tags_flat[start..end]
                    .iter()
                    .map(|&ptr| ptr as usize)
                    .collect();
                node_tags.push(slice);
                start = end;
            }

            ffi::gmshFree(element_types_ptr as *mut _);
            ffi::gmshFree(element_tags_ptr as *mut _);
            ffi::gmshFree(element_tags_n_ptr as *mut _);
            ffi::gmshFree(node_tags_ptr as *mut _);
            ffi::gmshFree(node_tags_n_ptr as *mut _);

            Ok((element_types, element_tags, node_tags))
        }
    }

    /// 在指定坐标处查找元素。
    pub fn get_element_by_coordinates(
        &self,
        x: f64,
        y: f64,
        z: f64,
        dim: i32,
        strict: bool,
    ) -> Result<(usize, i32, Vec<usize>, (f64, f64, f64)), GmshError> {
        let mut element_tag = 0;
        let mut element_type = 0;
        let mut node_tags_ptr = ptr::null_mut();
        let mut node_tags_n = 0;
        let mut u = 0.0;
        let mut v = 0.0;
        let mut w = 0.0;
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelMeshGetElementByCoordinates(
                    x, y, z,
                    &mut element_tag,
                    &mut element_type,
                    &mut node_tags_ptr,
                    &mut node_tags_n,
                    &mut u,
                    &mut v,
                    &mut w,
                    dim,
                    if strict { 1 } else { 0 },
                    ierr,
                )
            })?;
            let node_tags = if node_tags_ptr.is_null() {
                Vec::new()
            } else {
                std::slice::from_raw_parts(node_tags_ptr, node_tags_n)
                    .iter()
                    .map(|&ptr| ptr as usize)
                    .collect()
            };
            ffi::gmshFree(node_tags_ptr as *mut _);
            Ok((element_tag as usize, element_type, node_tags, (u, v, w)))
        }
    }

    /// 设置实体的网格尺寸。
    pub fn set_size(&self, entities: &[(i32, i32)], size: f64) -> Result<(), GmshError> {
        let dimtags = dimtags_to_cvec(entities);
        unsafe {
            check_err!(|ierr| ffi::gmshModelMeshSetSize(dimtags.as_ptr(), dimtags.len(), size, ierr))
        }
    }

    /// 设置曲线为结构化网格（Transfinite）。
    pub fn set_transfinite_curve(&self, tag: i32, num_nodes: i32, mesh_type: &str, coef: f64) -> Result<(), GmshError> {
        let c_type = to_cstring(mesh_type);
        unsafe {
            check_err!(|ierr| ffi::gmshModelMeshSetTransfiniteCurve(tag, num_nodes, c_type.as_ptr(), coef, ierr))
        }
    }

    /// 设置曲面为结构化网格（Transfinite）。
    pub fn set_transfinite_surface(&self, tag: i32, arrangement: &str, corner_tags: &[i32]) -> Result<(), GmshError> {
        let c_arr = to_cstring(arrangement);
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelMeshSetTransfiniteSurface(
                    tag,
                    c_arr.as_ptr(),
                    corner_tags.as_ptr(),
                    corner_tags.len(),
                    ierr,
                )
            })
        }
    }

    /// 设置实体为结构化网格（Transfinite Volume）。
    pub fn set_transfinite_volume(&self, tag: i32, corner_tags: &[i32]) -> Result<(), GmshError> {
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelMeshSetTransfiniteVolume(tag, corner_tags.as_ptr(), corner_tags.len(), ierr)
            })
        }
    }

    /// 设置曲面的重构（四边形网格）。
    pub fn set_recombine(&self, dim: i32, tag: i32, angle: f64) -> Result<(), GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelMeshSetRecombine(dim, tag, angle, ierr))
        }
    }

    /// 设置网格平滑算法。
    pub fn set_smoothing(&self, dim: i32, tag: i32, value: i32) -> Result<(), GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelMeshSetSmoothing(dim, tag, value, ierr))
        }
    }

    /// 设置网格生成算法。
    pub fn set_algorithm(&self, dim: i32, tag: i32, value: i32) -> Result<(), GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelMeshSetAlgorithm(dim, tag, value, ierr))
        }
    }

    /// 清除指定实体上的网格。
    pub fn clear(&self, entities: &[(i32, i32)]) -> Result<(), GmshError> {
        let dimtags = dimtags_to_cvec(entities);
        unsafe {
            check_err!(|ierr| ffi::gmshModelMeshClear(dimtags.as_ptr(), dimtags.len(), ierr))
        }
    }
}

// ========================= 内置几何（Gmsh Geo） =========================

/// Gmsh 原生几何建模内核。
pub struct Geo {
    _model_name: String,
}

impl Geo {
    /// 添加点。
    pub fn add_point(&self, x: f64, y: f64, z: f64, mesh_size: f64, tag: i32) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelGeoAddPoint(x, y, z, mesh_size, tag, ierr))
        }
    }

    /// 添加直线段。
    pub fn add_line(&self, start_tag: i32, end_tag: i32, tag: i32) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelGeoAddLine(start_tag, end_tag, tag, ierr))
        }
    }

    /// 添加圆弧（圆心、起点、终点）。
    pub fn add_circle_arc(&self, start_tag: i32, center_tag: i32, end_tag: i32, tag: i32, nx: f64, ny: f64, nz: f64) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelGeoAddCircleArc(start_tag, center_tag, end_tag, tag, nx, ny, nz, ierr))
        }
    }

    /// 添加样条曲线（通过一系列点）。
    pub fn add_spline(&self, point_tags: &[i32], tag: i32) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelGeoAddSpline(point_tags.as_ptr(), point_tags.len(), tag, ierr))
        }
    }

    /// 添加曲线环（用于创建平面）。
    pub fn add_curve_loop(&self, curve_tags: &[i32], tag: i32, reorient: bool) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelGeoAddCurveLoop(
                    curve_tags.as_ptr(),
                    curve_tags.len(),
                    tag,
                    if reorient { 1 } else { 0 },
                    ierr,
                )
            })
        }
    }

    /// 添加平面曲面（通过曲线环）。
    pub fn add_plane_surface(&self, wire_tags: &[i32], tag: i32) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelGeoAddPlaneSurface(wire_tags.as_ptr(), wire_tags.len(), tag, ierr))
        }
    }

    /// 添加曲面环（用于创建实体）。
    pub fn add_surface_loop(&self, surface_tags: &[i32], tag: i32) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelGeoAddSurfaceLoop(surface_tags.as_ptr(), surface_tags.len(), tag, ierr))
        }
    }

    /// 添加实体（通过曲面环）。
    pub fn add_volume(&self, shell_tags: &[i32], tag: i32) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelGeoAddVolume(shell_tags.as_ptr(), shell_tags.len(), tag, ierr))
        }
    }

    /// 拉伸实体。
    pub fn extrude(
        &self,
        entities: &[(i32, i32)],
        dx: f64,
        dy: f64,
        dz: f64,
        num_elements: &[i32],
        heights: &[f64],
        recombine: bool,
    ) -> Result<Vec<(i32, i32)>, GmshError> {
        let dimtags = dimtags_to_cvec(entities);
        let mut out_ptr = ptr::null_mut();
        let mut out_n = 0;
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelGeoExtrude(
                    dimtags.as_ptr(),
                    dimtags.len(),
                    dx,
                    dy,
                    dz,
                    &mut out_ptr,
                    &mut out_n,
                    num_elements.as_ptr(),
                    num_elements.len(),
                    heights.as_ptr(),
                    heights.len(),
                    if recombine { 1 } else { 0 },
                    ierr,
                )
            })?;
            let mut new_entities = Vec::with_capacity(out_n / 2);
            for i in 0..(out_n / 2) {
                let d = *out_ptr.add(i * 2);
                let t = *out_ptr.add(i * 2 + 1);
                new_entities.push((d, t));
            }
            ffi::gmshFree(out_ptr as *mut _);
            Ok(new_entities)
        }
    }

    /// 同步几何与模型（将当前几何定义转换为模型实体）。
    pub fn synchronize(&self) -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshModelGeoSynchronize(ierr)) }
    }
}

// ========================= OpenCASCADE 几何 =========================

/// OpenCASCADE 几何建模内核。
pub struct Occ {
    _model_name: String,
}

impl Occ {
    /// 添加点。
    pub fn add_point(&self, x: f64, y: f64, z: f64, mesh_size: f64, tag: i32) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelOccAddPoint(x, y, z, mesh_size, tag, ierr))
        }
    }

    /// 添加直线段。
    pub fn add_line(&self, start_tag: i32, end_tag: i32, tag: i32) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelOccAddLine(start_tag, end_tag, tag, ierr))
        }
    }

    /// 添加圆弧（三点：起点、中点、终点）。
    pub fn add_circle_arc(&self, start_tag: i32, middle_tag: i32, end_tag: i32, tag: i32, center: i32) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelOccAddCircleArc(start_tag, middle_tag, end_tag, tag, center, ierr))
        }
    }

    /// 添加圆（完整圆）。
    pub fn add_circle(&self, x: f64, y: f64, z: f64, r: f64, tag: i32, angle1: f64, angle2: f64) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelOccAddCircle(x, y, z, r, tag, angle1, angle2, ptr::null(), 0, ptr::null(), 0, ierr))
        }
    }

    /// 添加矩形面。
    pub fn add_rectangle(&self, x: f64, y: f64, z: f64, dx: f64, dy: f64, tag: i32, rounded_radius: f64) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelOccAddRectangle(x, y, z, dx, dy, tag, rounded_radius, ierr))
        }
    }

    /// 添加圆柱体。
    pub fn add_cylinder(&self, x: f64, y: f64, z: f64, dx: f64, dy: f64, dz: f64, r: f64, tag: i32, angle: f64) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelOccAddCylinder(x, y, z, dx, dy, dz, r, tag, angle, ierr))
        }
    }

    /// 添加长方体。
    pub fn add_box(&self, x: f64, y: f64, z: f64, dx: f64, dy: f64, dz: f64, tag: i32) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelOccAddBox(x, y, z, dx, dy, dz, tag, ierr))
        }
    }

    /// 添加球体。
    pub fn add_sphere(&self, xc: f64, yc: f64, zc: f64, radius: f64, tag: i32, angle1: f64, angle2: f64, angle3: f64) -> Result<i32, GmshError> {
        unsafe {
            check_err!(|ierr| ffi::gmshModelOccAddSphere(xc, yc, zc, radius, tag, angle1, angle2, angle3, ierr))
        }
    }

    /// 布尔运算：并集。
    pub fn fuse(
        &self,
        object: &[(i32, i32)],
        tool: &[(i32, i32)],
        tag: i32,
        remove_object: bool,
        remove_tool: bool,
    ) -> Result<Vec<(i32, i32)>, GmshError> {
        let obj_dimtags = dimtags_to_cvec(object);
        let tool_dimtags = dimtags_to_cvec(tool);
        let mut out_ptr = ptr::null_mut();
        let mut out_n = 0;
        let mut map_ptr = ptr::null_mut();
        let mut map_n_ptr = ptr::null_mut();
        let mut map_nn = 0;
        unsafe {
            check_err!(|ierr| {
                ffi::gmshModelOccFuse(
                    obj_dimtags.as_ptr(),
                    obj_dimtags.len(),
                    tool_dimtags.as_ptr(),
                    tool_dimtags.len(),
                    &mut out_ptr,
                    &mut out_n,
                    &mut map_ptr,
                    &mut map_n_ptr,
                    &mut map_nn,
                    tag,
                    if remove_object { 1 } else { 0 },
                    if remove_tool { 1 } else { 0 },
                    ierr,
                )
            })?;
            let mut result = Vec::with_capacity(out_n / 2);
            for i in 0..(out_n / 2) {
                let d = *out_ptr.add(i * 2);
                let t = *out_ptr.add(i * 2 + 1);
                result.push((d, t));
            }
            ffi::gmshFree(out_ptr as *mut _);
            if !map_ptr.is_null() {
                ffi::gmshFree(map_ptr as *mut _);
            }
            if !map_n_ptr.is_null() {
                ffi::gmshFree(map_n_ptr as *mut _);
            }
            Ok(result)
        }
    }

    /// 同步 OCC 几何到模型。
    pub fn synchronize(&self) -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshModelOccSynchronize(ierr)) }
    }
}

// ========================= 视图模块（后处理） =========================

/// 视图（后处理数据）管理。
pub struct View;

impl View {
    /// 添加新视图。
    pub fn add(name: &str, tag: i32) -> Result<i32, GmshError> {
        let c_name = to_cstring(name);
        unsafe { check_err!(|ierr| ffi::gmshViewAdd(c_name.as_ptr(), tag, ierr)) }
    }

    /// 移除视图。
    pub fn remove(tag: i32) -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshViewRemove(tag, ierr)) }
    }

    /// 获取所有视图标签。
    pub fn get_tags() -> Result<Vec<i32>, GmshError> {
        let mut tags_ptr = ptr::null_mut();
        let mut tags_n = 0;
        unsafe {
            check_err!(|ierr| ffi::gmshViewGetTags(&mut tags_ptr, &mut tags_n, ierr))?;
            let tags = std::slice::from_raw_parts(tags_ptr, tags_n).to_vec();
            ffi::gmshFree(tags_ptr as *mut _);
            Ok(tags)
        }
    }

    /// 向视图添加模型数据（每个实体单独数据）。
    pub fn add_model_data(
        tag: i32,
        step: i32,
        model_name: &str,
        data_type: &str,
        tags: &[usize],
        data: &[&[f64]],
        time: f64,
        num_components: i32,
        partition: i32,
    ) -> Result<(), GmshError> {
        let c_model = to_cstring(model_name);
        let c_type = to_cstring(data_type);
        let mut data_ptrs: Vec<*const f64> = data.iter().map(|d| d.as_ptr()).collect();
        let data_ns: Vec<usize> = data.iter().map(|d| d.len()).collect();
        unsafe {
            check_err!(|ierr| {
                ffi::gmshViewAddModelData(
                    tag,
                    step,
                    c_model.as_ptr(),
                    c_type.as_ptr(),
                    tags.as_ptr(),
                    tags.len(),
                    data_ptrs.as_ptr(),
                    data_ns.as_ptr(),
                    data_ns.iter().sum(),
                    time,
                    num_components,
                    partition,
                    ierr,
                )
            })
        }
    }

    /// 向视图添加同质模型数据（所有实体共享相同数据）。
    pub fn add_homogeneous_model_data(
        tag: i32,
        step: i32,
        model_name: &str,
        data_type: &str,
        tags: &[usize],
        data: &[f64],
        time: f64,
        num_components: i32,
        partition: i32,
    ) -> Result<(), GmshError> {
        let c_model = to_cstring(model_name);
        let c_type = to_cstring(data_type);
        unsafe {
            check_err!(|ierr| {
                ffi::gmshViewAddHomogeneousModelData(
                    tag,
                    step,
                    c_model.as_ptr(),
                    c_type.as_ptr(),
                    tags.as_ptr(),
                    tags.len(),
                    data.as_ptr(),
                    data.len(),
                    time,
                    num_components,
                    partition,
                    ierr,
                )
            })
        }
    }

    /// 写入视图到文件。
    pub fn write(tag: i32, file_name: &str, append: bool) -> Result<(), GmshError> {
        let c_name = to_cstring(file_name);
        unsafe {
            check_err!(|ierr| ffi::gmshViewWrite(tag, c_name.as_ptr(), if append { 1 } else { 0 }, ierr))
        }
    }
}

// ========================= 全局选项 =========================

/// 全局选项管理（数值、字符串、颜色等）。
pub struct GmshOption;

impl GmshOption {
    /// 设置全局选项（数值）。
    pub fn set_number(name: &str, value: f64) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        unsafe { check_err!(|ierr| ffi::gmshOptionSetNumber(c_name.as_ptr(), value, ierr)) }
    }

    /// 获取全局选项（数值）。
    pub fn get_number(name: &str) -> Result<f64, GmshError> {
        let c_name = to_cstring(name);
        let mut value = 0.0;
        unsafe {
            check_err!(|ierr| ffi::gmshOptionGetNumber(c_name.as_ptr(), &mut value, ierr))?;
            Ok(value)
        }
    }

    /// 设置全局选项（字符串）。
    pub fn set_string(name: &str, value: &str) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        let c_value = to_cstring(value);
        unsafe {
            check_err!(|ierr| ffi::gmshOptionSetString(c_name.as_ptr(), c_value.as_ptr(), ierr))
        }
    }

    /// 获取全局选项（字符串）。
    pub fn get_string(name: &str) -> Result<String, GmshError> {
        let c_name = to_cstring(name);
        let mut value_ptr = ptr::null_mut();
        unsafe {
            check_err!(|ierr| ffi::gmshOptionGetString(c_name.as_ptr(), &mut value_ptr, ierr))?;
            Ok(unsafe { cstr_to_string_and_free(value_ptr) })
        }
    }

    /// 设置全局选项（颜色）。
    pub fn set_color(name: &str, r: i32, g: i32, b: i32, a: i32) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        unsafe {
            check_err!(|ierr| ffi::gmshOptionSetColor(c_name.as_ptr(), r, g, b, a, ierr))
        }
    }

    /// 获取全局选项（颜色）。
    pub fn get_color(name: &str) -> Result<(i32, i32, i32, i32), GmshError> {
        let c_name = to_cstring(name);
        let mut r = 0;
        let mut g = 0;
        let mut b = 0;
        let mut a = 0;
        unsafe {
            check_err!(|ierr| ffi::gmshOptionGetColor(c_name.as_ptr(), &mut r, &mut g, &mut b, &mut a, ierr))?;
            Ok((r, g, b, a))
        }
    }

    /// 恢复所有选项的默认值。
    pub fn restore_defaults() -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshOptionRestoreDefaults(ierr)) }
    }
}

// ========================= 日志模块 =========================

/// 日志与性能测量。
pub struct Logger;

impl Logger {
    /// 写入一条日志消息。
    pub fn write(message: &str, level: &str) -> Result<(), GmshError> {
        let c_msg = to_cstring(message);
        let c_level = to_cstring(level);
        unsafe {
            check_err!(|ierr| ffi::gmshLoggerWrite(c_msg.as_ptr(), c_level.as_ptr(), ierr))
        }
    }

    /// 开始记录日志（将日志存入缓冲区）。
    pub fn start() -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshLoggerStart(ierr)) }
    }

    /// 获取已记录的日志。
    pub fn get() -> Result<Vec<String>, GmshError> {
        let mut log_ptr = ptr::null_mut();
        let mut log_n = 0;
        unsafe {
            check_err!(|ierr| ffi::gmshLoggerGet(&mut log_ptr, &mut log_n, ierr))?;
            Ok(unsafe { cstr_array_to_vec_and_free(log_ptr, log_n) })
        }
    }

    /// 停止记录日志。
    pub fn stop() -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshLoggerStop(ierr)) }
    }

    /// 获取从初始化起的墙钟时间（秒）。
    pub fn wall_time() -> Result<f64, GmshError> {
        unsafe {
            let mut ierr = 0;
            let value = ffi::gmshLoggerGetWallTime(&mut ierr);
            if ierr == 0 {
                Ok(value)
            } else {
                // 获取错误信息
                let mut err_ptr = ptr::null_mut();
                ffi::gmshLoggerGetLastError(&mut err_ptr, ptr::null_mut());
                let msg = if err_ptr.is_null() {
                    "unknown error".to_string()
                } else {
                    CStr::from_ptr(err_ptr).to_string_lossy().into_owned()
                };
                Err(GmshError::new(msg))
            }
        }
    }

    /// 获取从初始化起的 CPU 时间（秒）。
    pub fn cpu_time() -> Result<f64, GmshError> {
        unsafe {
            let mut ierr = 0;
            let value = ffi::gmshLoggerGetCpuTime(&mut ierr);
            if ierr == 0 {
                Ok(value)
            } else {
                let mut err_ptr = ptr::null_mut();
                ffi::gmshLoggerGetLastError(&mut err_ptr, ptr::null_mut());
                let msg = if err_ptr.is_null() {
                    "unknown error".to_string()
                } else {
                    CStr::from_ptr(err_ptr).to_string_lossy().into_owned()
                };
                Err(GmshError::new(msg))
            }
        }
    }

    /// 获取当前内存使用（MB）。
    pub fn memory() -> Result<f64, GmshError> {
        unsafe {
            let mut ierr = 0;
            let value = ffi::gmshLoggerGetMemory(&mut ierr);
            if ierr == 0 {
                Ok(value)
            } else {
                let mut err_ptr = ptr::null_mut();
                ffi::gmshLoggerGetLastError(&mut err_ptr, ptr::null_mut());
                let msg = if err_ptr.is_null() {
                    "unknown error".to_string()
                } else {
                    CStr::from_ptr(err_ptr).to_string_lossy().into_owned()
                };
                Err(GmshError::new(msg))
            }
        }
    }

    /// 获取总内存使用（MB）。
    pub fn total_memory() -> Result<f64, GmshError> {
        unsafe {
            let mut ierr = 0;
            let value = ffi::gmshLoggerGetTotalMemory(&mut ierr);
            if ierr == 0 {
                Ok(value)
            } else {
                let mut err_ptr = ptr::null_mut();
                ffi::gmshLoggerGetLastError(&mut err_ptr, ptr::null_mut());
                let msg = if err_ptr.is_null() {
                    "unknown error".to_string()
                } else {
                    CStr::from_ptr(err_ptr).to_string_lossy().into_owned()
                };
                Err(GmshError::new(msg))
            }
        }
    }
}

// ========================= 插件模块 =========================

/// 插件运行。
pub struct Plugin;

impl Plugin {
    /// 设置插件数值选项。
    pub fn set_number(name: &str, option: &str, value: f64) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        let c_opt = to_cstring(option);
        unsafe {
            check_err!(|ierr| ffi::gmshPluginSetNumber(c_name.as_ptr(), c_opt.as_ptr(), value, ierr))
        }
    }

    /// 设置插件字符串选项。
    pub fn set_string(name: &str, option: &str, value: &str) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        let c_opt = to_cstring(option);
        let c_val = to_cstring(value);
        unsafe {
            check_err!(|ierr| ffi::gmshPluginSetString(c_name.as_ptr(), c_opt.as_ptr(), c_val.as_ptr(), ierr))
        }
    }

    /// 运行插件。
    ///
    /// 返回插件的视图标签（如果创建了新视图）。
    pub fn run(name: &str) -> Result<i32, GmshError> {
        let c_name = to_cstring(name);
        unsafe { check_err!(|ierr| ffi::gmshPluginRun(c_name.as_ptr(), ierr)) }
    }
}

// ========================= Onelab 参数接口 =========================

/// Onelab 参数接口。
pub struct Onelab;

impl Onelab {
    /// 设置 Onelab 数值参数。
    pub fn set_number(name: &str, value: &[f64]) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        unsafe {
            check_err!(|ierr| ffi::gmshOnelabSetNumber(c_name.as_ptr(), value.as_ptr(), value.len(), ierr))
        }
    }

    /// 获取 Onelab 数值参数。
    pub fn get_number(name: &str) -> Result<Vec<f64>, GmshError> {
        let c_name = to_cstring(name);
        let mut value_ptr = ptr::null_mut();
        let mut value_n = 0;
        unsafe {
            check_err!(|ierr| ffi::gmshOnelabGetNumber(c_name.as_ptr(), &mut value_ptr, &mut value_n, ierr))?;
            let values = std::slice::from_raw_parts(value_ptr, value_n).to_vec();
            ffi::gmshFree(value_ptr as *mut _);
            Ok(values)
        }
    }

    /// 设置 Onelab 字符串参数。
    pub fn set_string(name: &str, value: &[&str]) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        let mut c_values: Vec<CString> = value.iter().map(|s| to_cstring(s)).collect();
        let mut c_ptrs: Vec<*const c_char> = c_values.iter().map(|c| c.as_ptr()).collect();
        unsafe {
            check_err!(|ierr| {
                ffi::gmshOnelabSetString(
                    c_name.as_ptr(),
                    c_ptrs.as_ptr(),
                    c_ptrs.len(),
                    ierr,
                )
            })
        }
    }

    /// 获取 Onelab 字符串参数。
    pub fn get_string(name: &str) -> Result<Vec<String>, GmshError> {
        let c_name = to_cstring(name);
        let mut value_ptr = ptr::null_mut();
        let mut value_n = 0;
        unsafe {
            check_err!(|ierr| ffi::gmshOnelabGetString(c_name.as_ptr(), &mut value_ptr, &mut value_n, ierr))?;
            Ok(unsafe { cstr_array_to_vec_and_free(value_ptr, value_n) })
        }
    }

    /// 检查参数是否已更改。
    pub fn get_changed(name: &str) -> Result<bool, GmshError> {
        let c_name = to_cstring(name);
        unsafe {
            let changed = check_err!(|ierr| ffi::gmshOnelabGetChanged(c_name.as_ptr(), ierr))?;
            Ok(changed != 0)
        }
    }

    /// 清除参数。
    pub fn clear(name: &str) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        unsafe {
            check_err!(|ierr| ffi::gmshOnelabClear(c_name.as_ptr(), ierr))
        }
    }
}

// ========================= FLTK 图形界面 =========================

/// FLTK GUI 操作。
pub struct Fltk;

impl Fltk {
    /// 初始化 FLTK GUI（必须在调用任何其他 FLTK 函数前执行）。
    pub fn initialize() -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshFltkInitialize(ierr)) }
    }

    /// 结束 FLTK GUI。
    pub fn finalize() -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshFltkFinalize(ierr)) }
    }

    /// 运行 GUI 事件循环（阻塞直到所有窗口关闭）。
    pub fn run(option_file_name: Option<&str>) -> Result<(), GmshError> {
        let c_file = option_file_name.map(to_cstring).unwrap_or_else(|| CString::new("").unwrap());
        unsafe { check_err!(|ierr| ffi::gmshFltkRun(c_file.as_ptr(), ierr)) }
    }

    /// 等待事件处理最多 `time` 秒（非阻塞，可用于集成到其他事件循环）。
    pub fn wait(time: f64) -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshFltkWait(time, ierr)) }
    }

    /// 强制刷新 GUI（处理待处理事件）。
    pub fn update() -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshFltkUpdate(ierr)) }
    }

    /// 唤醒 GUI 线程并执行指定动作（用于跨线程通信）。
    pub fn awake(action: &str) -> Result<(), GmshError> {
        let c_action = to_cstring(action);
        unsafe { check_err!(|ierr| ffi::gmshFltkAwake(c_action.as_ptr(), ierr)) }
    }

    /// 锁定 GUI 线程（用于多线程安全）。
    pub fn lock() -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshFltkLock(ierr)) }
    }

    /// 解锁 GUI 线程。
    pub fn unlock() -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshFltkUnlock(ierr)) }
    }

    /// 检查 FLTK GUI 是否可用。
    pub fn is_available() -> Result<bool, GmshError> {
        unsafe {
            let mut ierr = 0;
            let val = ffi::gmshFltkIsAvailable(&mut ierr);
            if ierr == 0 {
                Ok(val != 0)
            } else {
                let mut err_ptr = ptr::null_mut();
                ffi::gmshLoggerGetLastError(&mut err_ptr, ptr::null_mut());
                let msg = if err_ptr.is_null() {
                    "unknown error".to_string()
                } else {
                    CStr::from_ptr(err_ptr).to_string_lossy().into_owned()
                };
                Err(GmshError::new(msg))
            }
        }
    }

    /// 让用户在图形界面中选择实体。
    ///
    /// # 参数
    /// - `dim`: 限制选择的维度（-1 表示所有维度）。
    ///
    /// 返回用户选择的实体列表（(dim, tag)）。
    pub fn select_entities(dim: i32) -> Result<Vec<(i32, i32)>, GmshError> {
        let mut dimtags_ptr = ptr::null_mut();
        let mut dimtags_n = 0;
        unsafe {
            let selected = check_err!(|ierr| ffi::gmshFltkSelectEntities(&mut dimtags_ptr, &mut dimtags_n, dim, ierr))?;
            if selected == 0 {
                return Ok(Vec::new());
            }
            let mut entities = Vec::with_capacity(dimtags_n / 2);
            for i in 0..(dimtags_n / 2) {
                let d = *dimtags_ptr.add(i * 2);
                let t = *dimtags_ptr.add(i * 2 + 1);
                entities.push((d, t));
            }
            ffi::gmshFree(dimtags_ptr as *mut _);
            Ok(entities)
        }
    }

    /// 让用户在图形界面中选择元素。
    ///
    /// 返回选中的元素标签列表。
    pub fn select_elements() -> Result<Vec<usize>, GmshError> {
        let mut tags_ptr = ptr::null_mut();
        let mut tags_n = 0;
        unsafe {
            let selected = check_err!(|ierr| ffi::gmshFltkSelectElements(&mut tags_ptr, &mut tags_n, ierr))?;
            if selected == 0 {
                return Ok(Vec::new());
            }
            let tags = std::slice::from_raw_parts(tags_ptr, tags_n).to_vec();
            ffi::gmshFree(tags_ptr as *mut _);
            Ok(tags)
        }
    }

    /// 让用户在图形界面中选择视图。
    ///
    /// 返回选中的视图标签列表。
    pub fn select_views() -> Result<Vec<i32>, GmshError> {
        let mut tags_ptr = ptr::null_mut();
        let mut tags_n = 0;
        unsafe {
            let selected = check_err!(|ierr| ffi::gmshFltkSelectViews(&mut tags_ptr, &mut tags_n, ierr))?;
            if selected == 0 {
                return Ok(Vec::new());
            }
            let tags = std::slice::from_raw_parts(tags_ptr, tags_n).to_vec();
            ffi::gmshFree(tags_ptr as *mut _);
            Ok(tags)
        }
    }

    /// 分割当前窗口。
    ///
    /// # 参数
    /// - `how`: 分割方式 ("h" 水平, "v" 垂直)。
    /// - `ratio`: 分割比例（新窗口大小占比）。
    pub fn split_current_window(how: &str, ratio: f64) -> Result<(), GmshError> {
        let c_how = to_cstring(how);
        unsafe { check_err!(|ierr| ffi::gmshFltkSplitCurrentWindow(c_how.as_ptr(), ratio, ierr)) }
    }

    /// 设置当前窗口索引（多窗口时）。
    pub fn set_current_window(window_index: i32) -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshFltkSetCurrentWindow(window_index, ierr)) }
    }

    /// 设置状态栏消息。
    pub fn set_status_message(message: &str, graphics: bool) -> Result<(), GmshError> {
        let c_msg = to_cstring(message);
        unsafe {
            check_err!(|ierr| ffi::gmshFltkSetStatusMessage(c_msg.as_ptr(), if graphics { 1 } else { 0 }, ierr))
        }
    }

    /// 显示实体的上下文菜单（右键菜单）。
    pub fn show_context_window(dim: i32, tag: i32) -> Result<(), GmshError> {
        unsafe { check_err!(|ierr| ffi::gmshFltkShowContextWindow(dim, tag, ierr)) }
    }

    /// 展开树节点。
    pub fn open_tree_item(name: &str) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        unsafe { check_err!(|ierr| ffi::gmshFltkOpenTreeItem(c_name.as_ptr(), ierr)) }
    }

    /// 折叠树节点。
    pub fn close_tree_item(name: &str) -> Result<(), GmshError> {
        let c_name = to_cstring(name);
        unsafe { check_err!(|ierr| ffi::gmshFltkCloseTreeItem(c_name.as_ptr(), ierr)) }
    }
}