package com.tagmae.tsgame_erwang.utils;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Environment;
import android.text.TextUtils;
import android.util.Base64;
import android.util.Log;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

/**
 * 图片处理工具类
 * 提供图片保存、编码转换等功能
 */
public class ImageProcessUtils {

    private static final String TAG = "ImageProcessUtils";

    /**
     * 图片保存回调接口
     */
    public interface ImageSaveCallback {
        /**
         * 图片保存成功回调
         * @param imagePath 保存的图片路径
         */
        void onSuccess(String imagePath);

        /**
         * 图片保存失败回调
         * @param errorMsg 错误信息
         */
        void onError(String errorMsg);
    }

    /**
     * 将Base64编码的图片保存到缓存目录
     * @param context 上下文
     * @param base64Image Base64编码的图片（去掉前缀：data:image/jpeg;base64,）
     * @param callback 保存结果回调
     */
    public static void saveBase64ImageToCache(final Context context, final String base64Image, final ImageSaveCallback callback) {
        if (TextUtils.isEmpty(base64Image)) {
            if (callback != null) {
                callback.onError("图片数据为空");
            }
            return;
        }

        new AsyncTask<Void, Void, String>() {
            @Override
            protected String doInBackground(Void... voids) {
                try {
                    // 解码Base64图片数据
                    String base64Data = base64Image;
                    // 检查并去除可能的Base64前缀
                    if (base64Data.contains(",")) {
                        base64Data = base64Data.substring(base64Data.indexOf(",") + 1);
                    }

                    byte[] decodedBytes = Base64.decode(base64Data, Base64.DEFAULT);
                    Bitmap bitmap = BitmapFactory.decodeByteArray(decodedBytes, 0, decodedBytes.length);
                    if (bitmap == null) {
                        return null;
                    }

                    // 保存Bitmap
                    return saveBitmapToCache(context, bitmap);
                } catch (Exception e) {
                    Log.e(TAG, "保存Base64图片出错", e);
                    return null;
                }
            }

            @Override
            protected void onPostExecute(String imagePath) {
                if (callback != null) {
                    if (imagePath != null) {
                        callback.onSuccess(imagePath);
                    } else {
                        callback.onError("保存图片失败");
                    }
                }
            }
        }.execute();
    }

    /**
     * 将Bitmap保存到缓存目录
     * @param context 上下文
     * @param bitmap 要保存的图片Bitmap对象
     * @param callback 保存结果回调
     */
    public static void saveBitmapToCache(final Context context, final Bitmap bitmap, final ImageSaveCallback callback) {
        if (bitmap == null) {
            if (callback != null) {
                callback.onError("图片数据为空");
            }
            return;
        }

        new AsyncTask<Void, Void, String>() {
            @Override
            protected String doInBackground(Void... voids) {
                try {
                    return saveBitmapToCache(context, bitmap);
                } catch (Exception e) {
                    Log.e(TAG, "保存Bitmap图片出错", e);
                    return null;
                }
            }

            @Override
            protected void onPostExecute(String imagePath) {
                if (callback != null) {
                    if (imagePath != null) {
                        callback.onSuccess(imagePath);
                    } else {
                        callback.onError("保存图片失败");
                    }
                }
            }
        }.execute();
    }

    /**
     * 将Bitmap保存到缓存目录（同步方法）
     * @param context 上下文
     * @param bitmap 要保存的Bitmap
     * @return 保存的图片路径，失败返回null
     */
    private static String saveBitmapToCache(Context context, Bitmap bitmap) {
        File file;

        // 参考提供的代码，优先使用SD卡存储，如果没有SD卡则使用系统存储
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            // sd卡存储（/mnt/sdcard/cache）
            file = Environment.getExternalStorageDirectory(); // 获取根目录
        } else {
            // 没有SD卡，缓存到系统存储
            file = Environment.getDataDirectory();
        }

        if (file == null) {
            Log.e(TAG, "获取存储目录失败");
            return null;
        }

        // 确保应用专用目录存在
        File appDir = new File(file, "tsgame_share_images");
        if (!appDir.exists()) {
            if (!appDir.mkdirs()) {
                Log.e(TAG, "创建应用专用目录失败");
                // 如果创建失败，尝试使用应用的缓存目录
                appDir = context.getExternalCacheDir();
                if (appDir == null) {
                    appDir = context.getCacheDir();
                }
                if (appDir == null) {
                    Log.e(TAG, "获取缓存目录失败");
                    return null;
                }
            }
        }

        // 生成唯一文件名
        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()).format(new Date());
        String imageFileName = "SHARE_" + timeStamp + ".jpg";
        File imageFile = new File(appDir, imageFileName);

        // 保存图片
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(imageFile);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 90, fos);
            fos.flush();
            return imageFile.getAbsolutePath();
        } catch (IOException e) {
            Log.e(TAG, "保存图片到文件出错", e);
            return null;
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    Log.e(TAG, "关闭文件流出错", e);
                }
            }
        }
    }

    /**
     * 清理缓存的分享图片
     * @param context 上下文
     * @return 清理是否成功
     */
    public static boolean clearCachedShareImages(Context context) {
        File cacheDir;

        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            cacheDir = context.getExternalCacheDir();
        } else {
            cacheDir = context.getCacheDir();
        }

        if (cacheDir == null) {
            return false;
        }

        File imagesDir = new File(cacheDir, "share_images");
        if (imagesDir.exists()) {
            try {
                File[] files = imagesDir.listFiles();
                if (files != null) {
                    for (File file : files) {
                        if (!file.delete()) {
                            Log.w(TAG, "删除缓存图片失败: " + file.getAbsolutePath());
                        }
                    }
                }
                return imagesDir.delete();
            } catch (Exception e) {
                Log.e(TAG, "清理缓存图片出错", e);
                return false;
            }
        }
        return true;
    }
}
