# ccall 的标准形式
return_value = ccall(
    (:function_name, "library"),  # 函数名 + 库名
    ReturnType,                     # 返回类型
    (ArgType1, ArgType2, ...),      # 参数类型元组
    arg1, arg2, ...                 # 实际参数
)

# 调用 C 标准库的 clock() 函数
ticks = ccall(:clock, Int32, ())
println("时钟周期: $ticks")

# 调用 strlen
len = ccall(:strlen, Csize_t, (Cstring,), "hello")
println("字符串长度: $len")

# 方式一：符号（已加载的库）
ccall(:func_name, ...)

# 方式二：元组（函数名, 库名）
ccall((:func_name, "libname"), ...)

# 方式三：完整路径
ccall((:func_name, "/path/to/lib.so"), ...)

# 方式四：使用 Libdl 动态加载
using Libdl
lib = Libdl.dlopen("libexample")
func = Libdl.dlsym(lib, :my_function)
ccall(func, Cint, (Cint,), 42)
Libdl.dlclose(lib)

# 数学函数
result = ccall(:sin, Cdouble, (Cdouble,), 3.14159)
println("sin(π) ≈ $result")

# 内存操作
buf = ccall(:malloc, Ptr{Cvoid}, (Csize_t,), 1024)
ccall(:memset, Ptr{Cvoid}, (Ptr{Cvoid}, Cint, Csize_t), buf, 0, 1024)
ccall(:free, Cvoid, (Ptr{Cvoid,), buf)

# 获取环境变量
val = ccall(:getenv, Cstring, (Cstring,), "HOME")
if val != C_NULL
    println("HOME = ", unsafe_string(val))
end

# Julia 已经包装了大多数 libm 函数，这里演示自定义调用
hypot_result = ccall(:hypot, Cdouble, (Cdouble, Cdouble), 3.0, 4.0)
println("hypot(3, 4) = $hypot_result")  # 5.0

// mathutils.c
#include <math.h>

typedef struct {
    double x;
    double y;
} Point;

double distance(Point* p1, Point* p2) {
    double dx = p1->x - p2->x;
    double dy = p1->y - p2->y;
    return sqrt(dx*dx + dy*dy);
}

void scale_array(double* arr, int n, double factor) {
    for (int i = 0; i < n; i++) {
        arr[i] *= factor;
    }
}

gcc -shared -fPIC -o libmathutils.so mathutils.c -lm

# 定义对应的 Julia 结构体
struct Point
    x::Cdouble
    y::Cdouble
end

# 调用 distance 函数
p1 = Point(1.0, 2.0)
p2 = Point(4.0, 6.0)
d = ccall((:distance, "libmathutils"), Cdouble, (Ref{Point}, Ref{Point}), p1, p2)
println("距离: $d")  # 5.0

# Julia 数组的内存布局与 C 兼容
arr = [1.0, 2.0, 3.0, 4.0, 5.0]

# 方式一：使用 pointer()
ccall((:scale_array, "libmathutils"), Cvoid,
      (Ptr{Cdouble}, Cint, Cdouble),
      pointer(arr), length(arr), 2.0)

println(arr)  # [2.0, 4.0, 6.0, 8.0, 10.0]

# 方式二：使用 Ref（更安全，防止数组被 GC 移动）
arr2 = [1.0, 2.0, 3.0]
ccall((:scale_array, "libmathutils"), Cvoid,
      (Ref{Cdouble}, Cint, Cdouble),
      arr2, length(arr2), 3.0)

# 方式一：预先分配 Julia 数组，传指针给 C 填充
function fill_array_from_c(n::Int)
    result = Vector{Cdouble}(undef, n)
    ccall((:fill_array, "libexample"), Cvoid,
          (Ptr{Cdouble}, Cint), result, n)
    return result
end

# 方式二：C 分配内存，Julia 复制后释放
function create_array_from_c(n::Int)
    ptr = ccall((:create_array, "libexample"), Ptr{Cdouble}, (Cint,), n)
    arr = unsafe_wrap(Array, ptr, n; own=false)
    result = copy(arr)  # 复制到 Julia 管理的内存
    ccall(:free, Cvoid, (Ptr{Cvoid},), ptr)  # 释放 C 分配的内存
    return result
end

# Julia String → C const char*
# 使用 Cstring 类型，Julia 自动处理编码和终止符
len = ccall(:strlen, Csize_t, (Cstring,), "Hello, World!")

# 从 C 获取字符串
function get_c_string()
    ptr = ccall(:getenv, Cstring, (Cstring,), "PATH")
    if ptr == C_NULL
        return nothing
    end
    return unsafe_string(ptr)  # 复制到 Julia String
end

# 传递字符串数组给 C (char**)
function list_to_c_strings(strings::Vector{String})
    # 创建 C 风格字符串数组
    c_strings = [Base.unsafe_convert(Cstring, s) for s in strings]
    
    result = ccall((:process_strings, "libexample"), Cint,
                   (Ptr{Cstring}, Cint), c_strings, length(strings))
    
    # 注意：不需要释放 c_strings，Julia 管理内存
    return result
end

# 当 C 返回 malloc 分配的字符串时
function get_allocated_string()
    ptr = ccall((:create_string, "libexample"), Cstring, ())
    if ptr == C_NULL
        error("C 函数返回 NULL")
    end
    result = unsafe_string(ptr)  # 复制内容
    ccall(:free, Cvoid, (Ptr{Cvoid},), ptr)  # 释放原始内存
    return result
end

// C 结构体
typedef struct {
    double latitude;
    double longitude;
    int altitude;
    char name[64];
} GeoPoint;

# Julia 对应结构体（字段顺序必须完全一致！）
struct GeoPoint
    latitude::Cdouble
    longitude::Cdouble
    altitude::Cint
    name::NTuple{64, Cchar}  # 定长字符数组
end

# 创建实例
function make_geopoint(lat, lon, alt, name)
    name_arr = ntuple(i -> i <= length(name) ? Cchar(name[i]) : Cchar(0), 64)
    return GeoPoint(Cdouble(lat), Cdouble(lon), Cint(alt), name_arr)
end

# 使用关键字参数构造
Base.@kwdef struct GeoPoint
    latitude::Cdouble = 0.0
    longitude::Cdouble = 0.0
    altitude::Cint = 0
    name::NTuple{64, Cchar} = ntuple(_ -> Cchar(0), 64)
end

point = GeoPoint(latitude=39.9, longitude=116.4, altitude=50)

# ⚠️ 如果 C 使用 #pragma pack(1)，Julia 需要对应调整
# 默认情况下 Julia 不填充，与大多数 C 编译器一致

# 如果需要 packed 布局，手动计算偏移或使用 @static if
struct PackedStruct
    a::UInt8
    b::UInt32  # 在 packed 模式下紧跟 a
end

# 验证大小
@assert sizeof(PackedStruct) == 5  # 如果是 packed 的话

// C 端定义回调接口
typedef int (*Callback)(int);

int apply_callback(int* arr, int n, Callback cb) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += cb(arr[i]);
    }
    return sum;
}

# Julia 端定义回调函数
function my_callback(x::Cint)::Cint
    return x * x
end

# 将 Julia 函数转为 C 回调指针
const CCallback = Cvoid  # 或者定义为函数指针类型

function apply_with_callback(arr::Vector{Cint})
    # 使用 @cfunction 创建 C 兼容的函数指针
    cb = @cfunction(my_callback, Cint, (Cint,))
    
    result = ccall((:apply_callback, "libexample"), Cint,
                   (Ptr{Cint}, Cint, Ptr{Cvoid}),
                   arr, length(arr), cb)
    return result
end

# C 函数指针不能直接对应 Julia 闭包
# 需要通过全局状态或用户数据指针传递上下文

# 方案一：使用全局变量
const _callback_state = Ref{Any}(nothing)

function _c_callback(x::Cint)::Cint
    f = _callback_state[]
    return Cint(f(x))
end

function apply_closure(f, arr::Vector{Cint})
    _callback_state[] = f
    cb = @cfunction(_c_callback, Cint, (Cint,))
    return ccall((:apply_callback, "libexample"), Cint,
                 (Ptr{Cint}, Cint, Ptr{Cvoid}),
                 arr, length(arr), cb)
end

# 使用
result = apply_closure(x -> x + 1, Cint[1, 2, 3, 4, 5])

# Julia 的 GC 可能在任何时候运行
# 传递给 C 的数据可能被移动（如果 GC 触发压缩）

# 安全的方式：使用 GC.@preserve
arr = [1.0, 2.0, 3.0]
GC.@preserve arr begin
    # 在这个代码块中，arr 不会被 GC 移动或回收
    ptr = pointer(arr)
    ccall((:process, "libexample"), Cvoid, (Ptr{Cdouble}, Cint), ptr, length(arr))
end

# 让 Julia 数组包装已有的 C 内存
function get_c_array()
    ptr = ccall((:create_array, "libexample"), Ptr{Cdouble}, (Cint,), 100)
    
    # own=false: Julia 不负责释放内存
    arr = unsafe_wrap(Array, ptr, 100; own=false)
    
    # 使用完毕后手动释放
    result = copy(arr)
    ccall(:free, Cvoid, (Ptr{Cvoid},), ptr)
    return result
end

# own=true: Julia 的 GC 最终会调用 free
# ⚠️ 只在 C 使用 malloc 分配的内存时使用

# 使用 try-finally 确保释放
function safe_ccall_example()
    buf = ccall(:malloc, Ptr{Cvoid}, (Csize_t,), 4096)
    try
        # 使用 buf
        ccall((:process_buffer, "libexample"), Cvoid, (Ptr{Cvoid}, Csize_t), buf, 4096)
    finally
        ccall(:free, Cvoid, (Ptr{Cvoid},), buf)
    end
end

using Clang

# 从 C 头文件自动生成 Julia 绑定
# 首先创建配置
ctx = create_context(
    ["include/mylib.h"],           # 头文件列表
    ["-I/usr/include", "-I./include"],  # 编译选项
)

# 生成绑定代码
run(ctx)

# generator.toml 配置示例
[general]
library_name = "libexample"
output_file_path = "./src/LibExample.jl"
module_name = "LibExample"
jll_pkg_name = "Example_jll"

[general.clang_args]
extra_args = ["-I./include"]

[api.function]
argument_filter = ["ctx", "data"]

# Julia 二进制构建器 (BinaryBuilder.jl) 创建的 JLL 包
using Example_jll

# JLL 包自动管理共享库的下载和路径
result = ccall((:my_function, libexample), Cint, (Cint,), 42)

# libexample 变量由 JLL 包自动提供

! fortran_math.f90
subroutine scale_vector(x, n, factor)
    implicit none
    integer, intent(in) :: n
    double precision, intent(inout) :: x(n)
    double precision, intent(in) :: factor
    integer :: i
    do i = 1, n
        x(i) = x(i) * factor
    end do
end subroutine

# 编译: gfortran -shared -fPIC -o libfmath.so fortran_math.f90

# Fortran 传递所有参数通过引用
arr = [1.0, 2.0, 3.0, 4.0]
n = Cint(length(arr))
factor = 2.0

ccall((:scale_vector_, "libfmath"), Cvoid,
      (Ref{Cdouble}, Ref{Cint}, Ref{Cdouble}),
      arr, n, factor)

println(arr)  # [2.0, 4.0, 6.0, 8.0]

# Julia 已内置 BLAS 调用，但有时需要直接调用
using LinearAlgebra

# 直接调用 BLAS dgemm
m, n, k = 100, 100, 100
A = randn(m, k)
B = randn(k, n)
C = zeros(m, n)

ccall((:dgemm_, LinearAlgebra.BLAS.libblastrampoline), Cvoid,
      (Ref{UInt8}, Ref{UInt8}, Ref{Cint}, Ref{Cint}, Ref{Cint},
       Ref{Cdouble}, Ptr{Cdouble}, Ref{Cint},
       Ptr{Cdouble}, Ref{Cint},
       Ref{Cdouble}, Ptr{Cdouble}, Ref{Cint}),
      'N', 'N', m, n, k, 1.0, A, m, B, k, 0.0, C, m)