package com.cake.draw.painting.tools;

import android.app.Activity;
import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Point;
import android.util.DisplayMetrics;
import android.util.Range;
import android.view.MotionEvent;
import android.view.View;
import android.view.WindowManager;

import androidx.camera.core.Camera;
import androidx.core.app.ActivityCompat;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Utils {
    // 支持的图片格式（用于过滤非图片文件）
    private static final List<String> SUPPORTED_IMAGE_FORMATS = Arrays.asList(".jpg", ".jpeg", ".png", ".gif", ".bmp");

    /**
     * 获取相机曝光补偿上限
     * @param camera 相机实例
     * @return 曝光补偿上限值，无则返回0
     */
    public static int getRange(Camera camera) {
        if (camera == null || camera.getCameraInfo() == null || camera.getCameraInfo().getExposureState() == null) {
            return 0;
        }
        Range<Integer> exposureCompensationRange = camera.getCameraInfo().getExposureState().getExposureCompensationRange();
        return exposureCompensationRange.getUpper();
    }

    /**
     * 设置状态栏文字颜色
     * @param activity 活动实例
     * @param dark 是否为深色文字
     */
    public static void setStatusBarTextColor(Activity activity, boolean dark) {
        if (activity == null || activity.getWindow() == null) {
            return;
        }
        View decor = activity.getWindow().getDecorView();
        if (dark) {
            decor.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                    | View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
        } else {
            decor.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                    | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
        }
    }

    /**
     * 获取屏幕宽高
     * @param context 上下文
     * @return 屏幕宽高Point（x=宽，y=高）
     */
    public static Point getScreen(Context context) {
        if (context == null) {
            return new Point(0, 0);
        }
        DisplayMetrics displayMetrics = new DisplayMetrics();
        WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        if (windowManager == null) {
            return new Point(0, 0);
        }
        windowManager.getDefaultDisplay().getMetrics(displayMetrics);
        Point point = new Point();
        point.x = displayMetrics.widthPixels;
        point.y = displayMetrics.heightPixels;
        return point;
    }

    /**
     * 检查权限是否全部授予
     * @param context 上下文
     * @param permissions 权限数组
     * @return 全部授予返回true，否则false
     */
    public static boolean checkPermission(Context context, String[] permissions) {
        if (context == null || permissions == null || permissions.length == 0) {
            return false;
        }
        for (String per : permissions) {
            if (ActivityCompat.checkSelfPermission(context, per) != PackageManager.PERMISSION_GRANTED) {
                return false;
            }
        }
        return true;
    }

    /**
     * 从Assets加载图片（带尺寸压缩，避免OOM）
     * @param context 上下文
     * @param fileName Assets内的文件路径（如 "category/1.jpg"）
     * @return 压缩后的Bitmap，加载失败返回null
     */
    public static Bitmap loadImageFromAssets(Context context, String fileName) {
        if (context == null || fileName == null || fileName.isEmpty()) {
            return null;
        }
        AssetManager assetManager = context.getAssets();
        try (InputStream is = assetManager.open(fileName)) {
            // 先获取图片尺寸，再压缩加载
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeStream(is, null, options);

            // 计算压缩比例（适配屏幕宽度，避免大图）
            Point screen = getScreen(context);
            options.inSampleSize = calculateInSampleSize(options, screen.x / 3, screen.x / 3);
            options.inJustDecodeBounds = false;
            options.inPreferredConfig = Bitmap.Config.RGB_565; // 降低内存占用
            options.inPurgeable = true;
            options.inInputShareable = true;

            // 重新打开流（因为之前decodeStream会消耗流）
            InputStream is2 = assetManager.open(fileName);
            Bitmap bitmap = BitmapFactory.decodeStream(is2, null, options);
            is2.close();
            return bitmap;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 计算图片压缩比例
     * @param options BitmapFactory.Options
     * @param reqWidth 目标宽度
     * @param reqHeight 目标高度
     * @return 压缩比例
     */
    private static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth) {
            final int halfHeight = height / 2;
            final int halfWidth = width / 2;

            while ((halfHeight / inSampleSize) >= reqHeight
                    && (halfWidth / inSampleSize) >= reqWidth) {
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }

    /**
     * 遍历Assets指定目录下的所有文件（支持递归）
     * @param context 上下文
     * @param dir Assets内的目录路径（如 "category/animal"）
     * @return 目录下所有文件路径列表
     */
    public static List<String> fileExistsInAssets(Context context, String dir) {
        List<String> pathList = new ArrayList<>();
        if (context == null || dir == null || dir.isEmpty()) {
            return pathList;
        }
        try {
            AssetManager assetManager = context.getAssets();
            String[] files = assetManager.list(dir);
            if (files != null) {
                for (String name : files) {
                    String fullPath = dir + "/" + name;
                    // 递归判断：如果是目录则继续遍历，否则添加文件路径
                    if (isDirectoryInAssets(assetManager, fullPath)) {
                        pathList.addAll(fileExistsInAssets(context, fullPath));
                    } else {
                        pathList.add(fullPath);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return pathList;
    }

    /**
     * 判断Assets路径是否为目录
     * @param assetManager AssetManager实例
     * @param path 待判断路径
     * @return 是目录返回true，否则false
     */
    private static boolean isDirectoryInAssets(AssetManager assetManager, String path) {
        try {
            String[] files = assetManager.list(path);
            return files != null && files.length > 0;
        } catch (IOException e) {
            return false;
        }
    }

    /**
     * 根据分类目录获取Assets内的图片路径列表（HomeFragment专用）
     * @param context 上下文
     * @param dir 分类目录（如 "category/animal"）
     * @return 过滤后的图片路径列表
     */
    public static List<String> getImagePathsByDir(Context context, String dir) {
        List<String> allFiles = fileExistsInAssets(context, dir);
        List<String> imagePaths = new ArrayList<>();
        // 过滤仅保留支持的图片格式
        for (String path : allFiles) {
            String lowerPath = path.toLowerCase();
            for (String format : SUPPORTED_IMAGE_FORMATS) {
                if (lowerPath.endsWith(format)) {
                    imagePaths.add(path);
                    break;
                }
            }
        }
        return imagePaths;
    }

    /**
     * 加载指定目录下的连续命名图片（1.jpg ~ 40.jpg）
     * @param context 上下文
     * @param dir 目录路径
     * @return 图片Bitmap列表
     */
    public static List<Bitmap> getAnimalsName(Context context, String dir) {
        List<Bitmap> list = new ArrayList<>();
        if (context == null || dir == null || dir.isEmpty()) {
            return list;
        }
        // 缩小循环上限，避免无效遍历（可根据实际需求调整）
        for (int i = 0; i < 40; i++) {
            String fileName = dir + "/" + (i + 1) + ".jpg";
            Bitmap bitmap = loadImageFromAssets(context, fileName);
            if (bitmap == null) {
                break;
            }
            list.add(bitmap);
        }
        return list;
    }

    /**
     * 获取应用包信息
     * @param context 上下文
     * @return PackageInfo实例，失败返回null
     */
    public static PackageInfo getInfo(Context context) {
        if (context == null) {
            return null;
        }
        try {
            return context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
        } catch (PackageManager.NameNotFoundException exception) {
            exception.printStackTrace();
            return null;
        }
    }

    /**
     * 计算双指触摸距离（用于缩放）
     * @param event 触摸事件
     * @return 双指距离，异常返回0
     */
    public static float getDistance(MotionEvent event) {
        if (event == null || event.getPointerCount() < 2) {
            return 0;
        }
        float x = event.getX(0) - event.getX(1);
        float y = event.getY(0) - event.getY(1);
        return (float) Math.sqrt(x * x + y * y);
    }

    /**
     * 计算双指触摸中点（补充：用于缩放中心定位）
     * @param event 触摸事件
     * @return 双指中点坐标
     */
    public static Point getMidPoint(MotionEvent event) {
        Point point = new Point();
        if (event == null || event.getPointerCount() < 2) {
            return point;
        }
        float x = (event.getX(0) + event.getX(1)) / 2;
        float y = (event.getY(0) + event.getY(1)) / 2;
        point.x = (int) x;
        point.y = (int) y;
        return point;
    }
}