// c_add.c
#include <stdio.h>

// 一个简单的加法函数
int add(int a, int b) {
    printf("C: Adding %d and %d\n", a, b);
    return a + b;
}

// 一个返回字符串的函数 (需要注意内存管理)
const char* greet(const char* name) {
    static char buffer[256]; // 静态缓冲区，避免返回栈内存
    snprintf(buffer, sizeof(buffer), "Hello, %s from C!", name);
    return buffer;
}

import 'dart:ffi'; // 导入 FFI 库
import 'dart:io'; // 用于判断平台
import 'package:ffi/ffi.dart'; // 用于内存分配和字符串转换

// 定义 C 函数的类型签名
typedef C_Add = Int32 Function(Int32 a, Int32 b);
typedef Dart_Add = int Function(int a, int b);

typedef C_Greet = Pointer<Utf8> Function(Pointer<Utf8> name);
typedef Dart_Greet = Pointer<Utf8> Function(Pointer<Utf8> name);

// 获取动态链接库的路径
DynamicLibrary _openDynamicLibrary() {
  if (Platform.isMacOS || Platform.isIOS) {
    return DynamicLibrary.open('libc_add.dylib');
  } else if (Platform.isAndroid || Platform.isLinux) {
    return DynamicLibrary.open('libc_add.so');
  } else if (Platform.isWindows) {
    return DynamicLibrary.open('c_add.dll');
  } else {
    throw UnsupportedError('Unknown platform');
  }
}

void main() {
  // 加载动态链接库
  final DynamicLibrary nativeLib = _openDynamicLibrary();

  // 查找并转换为 Dart 函数 (add)
  final Dart_Add add = nativeLib
      .lookupFunction<C_Add, Dart_Add>('add');

  // 调用 C 函数
  int result = add(10, 20);
  print('Dart: Result from C add function: $result');

  // 查找并转换为 Dart 函数 (greet)
  final Dart_Greet greetNative = nativeLib
      .lookupFunction<C_Greet, Dart_Greet>('greet');

  // 准备 C 字符串
  final Pointer<Utf8> namePtr = 'World'.toNativeUtf8();

  // 调用 C 函数并获取返回的 C 字符串指针
  final Pointer<Utf8> greetingPtr = greetNative(namePtr);

  // 将 C 字符串转换为 Dart 字符串
  final String greeting = greetingPtr.toDartString();
  print('Dart: Result from C greet function: $greeting');

  // 释放 C 字符串内存 (如果是由 Dart 分配的)
  // calloc.free(namePtr); // 如果是 toNativeUtf8() 分配的，需要释放
}

// image_processor.c
#include <stdint.h>

// 灰度化函数：将 RGBA 图像数据转换为灰度图像
// data: RGBA 像素数据数组
// width: 图像宽度
// height: 图像高度
void grayscale_image(uint8_t* data, int width, int height) {
    for (int i = 0; i < width * height; ++i) {
        uint8_t r = data[i * 4];
        uint8_t g = data[i * 4 + 1];
        uint8_t b = data[i * 4 + 2];

        // 计算灰度值 (简单的平均值法)
        uint8_t gray = (r + g + b) / 3;

        data[i * 4] = gray;     // R
        data[i * 4 + 1] = gray; // G
        data[i * 4 + 2] = gray; // B
        // data[i * 4 + 3] 是 Alpha 通道，保持不变
    }
}

import 'dart:ffi';
import 'dart:io';
import 'dart:typed_data';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart'; // 用于加载图片资源

// 定义 C 函数的类型签名
typedef C_GrayscaleImage = Void Function(Pointer<Uint8> data, Int32 width, Int32 height);
typedef Dart_GrayscaleImage = void Function(Pointer<Uint8> data, int width, int height);

// 获取动态链接库的路径
DynamicLibrary _openDynamicLibrary() {
  if (Platform.isMacOS || Platform.isIOS) {
    return DynamicLibrary.open('libimage_processor.dylib');
  } else if (Platform.isAndroid || Platform.isLinux) {
    return DynamicLibrary.open('libimage_processor.so');
  } else if (Platform.isWindows) {
    return DynamicLibrary.open('image_processor.dll');
  } else {
    throw UnsupportedError('Unknown platform');
  }
}

class ImageProcessingScreen extends StatefulWidget {
  const ImageProcessingScreen({super.key});

  @override
  State<ImageProcessingScreen> createState() => _ImageProcessingScreenState();
}

class _ImageProcessingScreenState extends State<ImageProcessingScreen> {
  late DynamicLibrary _nativeLib;
  late Dart_GrayscaleImage _grayscaleImage;
  Image? _originalImage;
  Image? _processedImage;

  @override
  void initState() {
    super.initState();
    _nativeLib = _openDynamicLibrary();
    _grayscaleImage = _nativeLib.lookupFunction<C_GrayscaleImage, Dart_GrayscaleImage>(
      'grayscale_image',
    );
    _loadImage();
  }

  Future<void> _loadImage() async {
    // 从 assets 加载图片
    final ByteData data = await rootBundle.load('assets/images/sample_image.png'); // 确保你有这个图片文件
    final Uint8List bytes = data.buffer.asUint8List();

    // 将图片解码为 Image 对象
    final Image image = Image.memory(bytes);
    setState(() {
      _originalImage = image;
    });
  }

  Future<void> _processImage() async {
    if (_originalImage == null) return;

    // 获取图片的像素数据
    final ByteData? byteData = await _originalImage!.image
        .toByteData(format: ImageByteFormat.rawRgba);

    if (byteData == null) return;

    final Uint8List rgbaBytes = byteData.buffer.asUint8List();

    // 在 C 堆上分配内存，并将 Dart 字节数据复制过去
    final Pointer<Uint8> nativeData = calloc<Uint8>(rgbaBytes.length);
    nativeData.asTypedList(rgbaBytes.length).setAll(0, rgbaBytes);

    // 获取图片尺寸
    final int width = _originalImage!.image.width;
    final int height = _originalImage!.image.height;

    // 调用 C 函数进行灰度化处理
    _grayscaleImage(nativeData, width, height);

    // 将处理后的数据复制回 Dart 的 Uint8List
    final Uint8List processedRgbaBytes = nativeData.asTypedList(rgbaBytes.length);

    // 释放 C 堆上的内存
    calloc.free(nativeData);

    // 将处理后的像素数据转换为 Image 对象
    final Image processedImage = Image.memory(
      processedRgbaBytes,
      width: width.toDouble(),
      height: height.toDouble(),
      fit: BoxFit.cover,
    );

    setState(() {
      _processedImage = processedImage;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('FFI 图像处理示例'),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            if (_originalImage != null)
              Column(
                children: [
                  const Text('原始图片:'),
                  SizedBox(
                    width: 200,
                    height: 200,
                    child: _originalImage,
                  ),
                ],
              ),
            const SizedBox(height: 20),
            ElevatedButton(
              onPressed: _processImage,
              child: const Text('灰度化图片 (FFI)'),
            ),
            const SizedBox(height: 20),
            if (_processedImage != null)
              Column(
                children: [
                  const Text('处理后的图片:'),
                  SizedBox(
                    width: 200,
                    height: 200,
                    child: _processedImage,
                  ),
                ],
              ),
          ],
        ),
      ),
    );
  }
}

void main() {
  runApp(const MaterialApp(home: ImageProcessingScreen()));
}