package cc.winboll.studio.powerbell.utils;

import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import androidx.core.content.FileProvider;
import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.powerbell.R;
import cc.winboll.studio.powerbell.models.BackgroundBean;
import com.yalantis.ucrop.UCrop;
import java.io.File;

/**
 * 图片裁剪工具类（集成 uCrop 2.2.8 终极兼容版，强制输出 PNG 格式，全程保留透明通道，支持 Uri/File 双传参）
 */
public class ImageCropUtils {
    public static final String TAG = "ImageCropUtils";
    // FileProvider 授权（与 AndroidManifest 配置一致）
    private static final String FILE_PROVIDER_SUFFIX = ".fileprovider";
    // 强制输出格式：固定为 PNG（保留透明通道）
    private static final String FORCE_OUTPUT_SUFFIX = "png";
    private static final android.graphics.Bitmap.CompressFormat FORCE_COMPRESS_FORMAT = android.graphics.Bitmap.CompressFormat.PNG;

    // ====================== 核心裁剪方法（强制 PNG 输出，优化逻辑）======================
    /**
     * 【Uri 传参版】启动 uCrop 裁剪 - 强制输出 PNG，保留透明通道
     * @param activity 上下文
     * @param inputUri 输入图片 Uri（本应用 FileProvider Uri，非空）
     * @param outputUri 输出图片 Uri（本应用 FileProvider Uri，非空）
     * @param aspectX 固定比例 X（自由裁剪传 0）
     * @param aspectY 固定比例 Y（自由裁剪传 0）
     * @param isFreeCrop 是否自由裁剪
     * @param requestCode 裁剪请求码
     */
    public static void startImageCrop(Activity activity,
                                      Uri inputUri,
                                      Uri outputUri,
                                      int aspectX,
                                      int aspectY,
                                      boolean isFreeCrop,
                                      int requestCode) {
        // 1. 输入参数校验
        if (activity == null || activity.isFinishing()) {
            LogUtils.e(TAG, "【裁剪异常】Activity 无效或已销毁");
            return;
        }
        if (inputUri == null || outputUri == null) {
            LogUtils.e(TAG, "【裁剪异常】输入/输出 Uri 为空");
            showToast(activity, "图片 Uri 无效，无法裁剪");
            return;
        }
        if (!isValidUri(activity, inputUri)) {
            LogUtils.e(TAG, "【裁剪异常】输入 Uri 无效：" + inputUri);
            showToast(activity, "原图 Uri 无效，无法裁剪");
            return;
        }

        // 2. 核心：强制修正输出为 PNG（忽略原图格式，统一转 PNG）
        File outputFile = uriToFile(activity, outputUri);
        if (outputFile == null) {
            LogUtils.e(TAG, "【裁剪异常】输出 Uri 转 File 失败：" + outputUri);
            showToast(activity, "裁剪输出路径无效");
            return;
        }
        outputFile = correctFileSuffix(outputFile, FORCE_OUTPUT_SUFFIX); // 强制 .png 后缀
        outputUri = getFileProviderUri(activity, outputFile); // 重新生成 PNG 对应的 Uri

        // 3. 初始化 uCrop + 强制 PNG 配置（保留透明核心）
        UCrop uCrop = UCrop.of(inputUri, outputUri);
		uCrop.withAspectRatio(aspectX, aspectY);
        UCrop.Options options = initCropOptions(activity, isFreeCrop, aspectX, aspectY); // 移除 isPng 参数

        // 4. 启动裁剪
        uCrop.withOptions(options);
        uCrop.start(activity, requestCode);
        LogUtils.d(TAG, "【裁剪启动成功（Uri 版）】强制输出 PNG（透明保留），输出路径：" + outputFile.getAbsolutePath());
    }

    /**
     * 【File 传参版】启动 uCrop 裁剪 - 强制输出 PNG，保留透明通道
     * @param activity 上下文
     * @param inputFile 输入图片文件（任意格式）
     * @param outputFile 输出图片文件（最终强制转为 PNG）
     * @param aspectX 固定比例 X（自由裁剪传 0）
     * @param aspectY 固定比例 Y（自由裁剪传 0）
     * @param isFreeCrop 是否自由裁剪
     * @param requestCode 裁剪请求码
     */
    public static void startImageCrop(Activity activity,
                                      File inputFile,
                                      File outputFile,
                                      int aspectX,
                                      int aspectY,
                                      boolean isFreeCrop,
                                      int requestCode) {
        // 1. 输入参数校验
        if (activity == null || activity.isFinishing()) {
            LogUtils.e(TAG, "【裁剪异常】Activity 无效或已销毁");
            return;
        }
        if (inputFile == null || !inputFile.exists() || inputFile.length() <= 100) {
            LogUtils.e(TAG, "【裁剪异常】输入图片文件无效");
            showToast(activity, "无有效图片可裁剪");
            return;
        }
        if (outputFile == null) {
            LogUtils.e(TAG, "【裁剪异常】输出文件路径为空");
            showToast(activity, "裁剪输出路径无效");
            return;
        }

        // 2. 核心：强制修正输出为 PNG（忽略原图格式）
        Uri inputUri = getFileProviderUri(activity, inputFile);
        outputFile = correctFileSuffix(outputFile, FORCE_OUTPUT_SUFFIX); // 强制 .png 后缀
        Uri outputUri = getFileProviderUri(activity, outputFile);

        // 3. 初始化 uCrop + 强制 PNG 配置
        UCrop uCrop = UCrop.of(inputUri, outputUri);
		uCrop.withAspectRatio(aspectX, aspectY);
        UCrop.Options options = initCropOptions(activity, isFreeCrop, aspectX, aspectY); // 移除 isPng 参数

        // 4. 启动裁剪
        uCrop.withOptions(options);
        uCrop.start(activity, requestCode);
        LogUtils.d(TAG, "【裁剪启动成功（File 版）】强制输出 PNG（透明保留），输出路径：" + outputFile.getAbsolutePath());
    }

    /**
     * 【BackgroundBean 传参版】启动 uCrop 裁剪 - 强制输出 PNG，保留透明通道
     */
    public static void startImageCrop(Activity activity,
                                      BackgroundBean cropBean,
                                      int aspectX,
                                      int aspectY,
                                      boolean isFreeCrop,
                                      int requestCode) {
        File inputFile = new File(cropBean.getBackgroundFilePath());
        File outputFile = new File(cropBean.getBackgroundScaledCompressFilePath());
        startImageCrop(activity, inputFile, outputFile, aspectX, aspectY, isFreeCrop, requestCode);
    }

    // ====================== 裁剪结果处理（保持兼容，优化日志）======================
    public static String handleCropResult(int requestCode, int resultCode, Intent data, int cropRequestCode) {
        if (requestCode != cropRequestCode) return null;

        if (resultCode == Activity.RESULT_OK && data != null) {
            Uri outputUri = UCrop.getOutput(data);
            if (outputUri != null) {
                String outputPath = uriToPath(outputUri);
                LogUtils.d(TAG, "【裁剪成功】强制输出 PNG（透明保留），输出路径：" + outputPath);
                return outputPath;
            }
        } else if (resultCode == UCrop.RESULT_ERROR) {
            Throwable error = UCrop.getError(data);
            LogUtils.e(TAG, "【裁剪失败】原因：" + (error != null ? error.getMessage() : "未知错误"));
        } else {
            LogUtils.d(TAG, "【裁剪取消】用户手动取消");
        }
        return null;
    }

    // ====================== 辅助方法（优化适配强制 PNG 逻辑）======================
    /** 校验 Uri 有效性（确保是图片类型） */
    private static boolean isValidUri(Activity activity, Uri uri) {
        try {
            String type = activity.getContentResolver().getType(uri);
            return type != null && type.startsWith("image/");
        } catch (Exception e) {
            LogUtils.e(TAG, "【Uri 校验失败】原因：" + e.getMessage());
            return false;
        }
    }

    /** Uri 转 File（适配 FileProvider Uri 和普通 Uri） */
    private static File uriToFile(Activity activity, Uri uri) {
        if (uri == null) return null;
        try {
            if (uri.getScheme().equals("file")) {
                return new File(uri.getPath());
            }
            String filePath = uri.getPath();
            if (filePath == null) return null;
            if (filePath.contains("/external_files/")) {
                filePath = filePath.replace("/external_files/", activity.getExternalFilesDir("").getAbsolutePath() + "/");
            } else if (filePath.contains("/cache/")) {
                filePath = filePath.replace("/cache/", activity.getCacheDir().getAbsolutePath() + "/");
            }
            return new File(filePath);
        } catch (Exception e) {
            LogUtils.e(TAG, "【Uri 转 File 失败】uri=" + uri + "，原因：" + e.getMessage());
            return null;
        }
    }

    /** Uri 提取文件路径 */
    private static String uriToPath(Uri uri) {
        if (uri == null) return null;
        try {
            if (uri.getScheme().equals("file")) {
                return uri.getPath();
            }
            String path = uri.getPath();
            if (path == null) return null;
            String[] prefixes = {"/external/", "/external_files/", "/cache/", "/files/"};
            for (String prefix : prefixes) {
                if (path.contains(prefix)) {
                    path = path.substring(path.indexOf(prefix) + prefix.length());
                    String externalRoot = android.os.Environment.getExternalStorageDirectory().getAbsolutePath();
                    return externalRoot + "/" + path;
                }
            }
            return path;
        } catch (Exception e) {
            LogUtils.e(TAG, "【Uri 转路径失败】uri=" + uri + "，原因：" + e.getMessage());
            return null;
        }
    }

    /**
     * 统一初始化裁剪配置（强制 PNG 专属配置，保留透明核心）
     * 移除 isPng 参数，全程用 PNG 配置
     */
    private static UCrop.Options initCropOptions(Activity activity, boolean isFreeCrop, int aspectX, int aspectY) {
		
        UCrop.Options options = new UCrop.Options();

        // 裁剪模式配置（自由裁剪/固定比例）
        options.setFreeStyleCropEnabled(isFreeCrop); // 开启自由裁剪

        // 裁剪配置（优化体验）
        //options.setCompressionFormat(android.graphics.Bitmap.CompressFormat.JPEG); // 输出格式
        //options.setCompressionQuality(100); // 图片质量
        //options.setHideBottomControls(true); // 隐藏底部控制栏（简化界面）
        //options.setToolbarTitle("图片裁剪"); // 工具栏标题
        //options.setToolbarColor(activity.getResources().getColor(R.color.colorPrimary)); // 工具栏颜色（适配项目主题）
        //options.setStatusBarColor(activity.getResources().getColor(R.color.colorPrimaryDark)); // 状态栏颜色
		

        // 2. 核心：强制 PNG 保留透明（固定配置，无需判断原图格式）
        options.setCompressionFormat(FORCE_COMPRESS_FORMAT); // 强制 PNG 压缩
        options.setCompressionQuality(100); // PNG 100% 质量，不损失透明
        options.setDimmedLayerColor(activity.getResources().getColor(android.R.color.transparent)); // 遮罩透明（关键）
        options.setCropFrameColor(activity.getResources().getColor(R.color.colorPrimary)); // 裁剪框主题色
        options.setCropGridColor(activity.getResources().getColor(R.color.colorAccent)); // 网格线主题色

        // 3. 通用 UI 配置（保持原有风格）
        options.setHideBottomControls(true); // 隐藏底部控制栏
        options.setToolbarTitle("图片裁剪");
        options.setToolbarColor(activity.getResources().getColor(R.color.colorPrimary));
        options.setToolbarWidgetColor(activity.getResources().getColor(android.R.color.white));
        options.setStatusBarColor(activity.getResources().getColor(R.color.colorPrimaryDark));

        return options;
    }

    /**
     * 修正文件后缀（强制转为 .png，覆盖原有任何图片后缀）
     */
    private static File correctFileSuffix(File originFile, String targetSuffix) {
        String originName = originFile.getName();
        // 强制替换所有图片后缀为 targetSuffix（避免漏改）
        originName = originName.replaceAll("\\.(jpg|jpeg|png|bmp|gif)$", "") + "." + targetSuffix;
        return new File(originFile.getParent(), originName);
    }

    /** 生成 FileProvider Uri（适配 Android 7.0+） */
    private static Uri getFileProviderUri(Activity activity, File file) {
        try {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                String authority = activity.getPackageName() + FILE_PROVIDER_SUFFIX;
                return FileProvider.getUriForFile(activity, authority, file);
            } else {
                return Uri.fromFile(file);
            }
        } catch (Exception e) {
            LogUtils.e(TAG, "【Uri 生成失败】原因：" + e.getMessage());
            return null;
        }
    }

    /** 显示 Toast（避免崩溃） */
    private static void showToast(Activity activity, String msg) {
        if (activity != null && !activity.isFinishing()) {
            android.widget.Toast.makeText(activity, msg, android.widget.Toast.LENGTH_SHORT).show();
        }
    }

    // ====================== 公有辅助方法（供外部调用）======================
    public static Uri getFileProviderUriPublic(Activity activity, File file) {
        return getFileProviderUri(activity, file);
    }

    public static File getFileFromUriPublic(Activity activity, Uri uri) {
        return uriToFile(activity, uri);
    }

    public static String getPathFromUriPublic(Uri uri) {
        return uriToPath(uri);
    }
}

