package cc.winboll.studio.powerbell.views;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.powerbell.R;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import cc.winboll.studio.powerbell.utils.BackgroundSourceUtils;
import cc.winboll.studio.libappbase.ToastUtils;

/**
 * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
 * @Date 2025/11/19 18:01
 * @Describe 背景图片视图控件（全透明背景 + 不拉伸居中平铺 + 完全填充父视图）
 */
public class BackgroundView extends RelativeLayout {

    public static final String TAG = "BackgroundView";

    Context mContext;
    private ImageView ivBackground;

    private static String BACKGROUND_IMAGE_FOLDER = "Background";
    private static String BACKGROUND_IMAGE_FILENAME = "current.data";
    private static String BACKGROUND_IMAGE_PREVIEW_FILENAME = "current_preview.data";
    private static String backgroundSourceFilePath;
    private float imageAspectRatio = 1.0f; // 图片原始宽高比（控制不拉伸）
    // 标记当前是否处于预览模式
    private boolean isPreviewMode = false;

    public BackgroundView(Context context) {
        super(context);
        this.mContext = context;
        initView();
    }

    public BackgroundView(Context context, AttributeSet attrs) {
        super(context, attrs);
        this.mContext = context;
        initView();
    }

    public BackgroundView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        this.mContext = context;
        initView();
    }

    public BackgroundView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        this.mContext = context;
        initView();
    }

    void initView() {
        // 1. 控件本身：完全填充父视图 + 全透明背景 + 无内边距
        setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
        setPadding(0, 0, 0, 0); // 取消自身内边距
        setBackgroundColor(0x00000000); // 全透明背景（#00000000）
        setBackground(new ColorDrawable(0x00000000)); // 双重保障：同时设置Background为透明（兼容低版本）

        initBackgroundImageView(); // 初始化内部ImageView（全透明 + 不拉伸居中平铺）

		backgroundSourceFilePath = BackgroundSourceUtils.getInstance(this.mContext).getCurrentBackgroundFilePath();
        loadAndSetImageViewBackground();
    }

    private void initBackgroundImageView() {
        ivBackground = new ImageView(mContext);
        // 2. ImageView：初始宽高WRAP_CONTENT + 居中 + 无内边距 + 全透明背景
        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(
			LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
        layoutParams.addRule(RelativeLayout.CENTER_IN_PARENT); // 居中显示
        layoutParams.setMargins(0, 0, 0, 0); // 取消边距
        ivBackground.setLayoutParams(layoutParams);

        // 3. 缩放模式：FIT_CENTER（不拉伸，按比例显示）
        ivBackground.setScaleType(ImageView.ScaleType.FIT_CENTER);
        ivBackground.setPadding(0, 0, 0, 0); // 取消内部padding
        ivBackground.setBackgroundColor(0x00000000); // ImageView背景全透明
        ivBackground.setBackground(new ColorDrawable(0x00000000)); // 双重保障（兼容低版本）

        this.addView(ivBackground);
    }

//    private void initBackgroundImagePath() {
//		if (isPreviewMode) {
//            backgroundSourceFilePath = BackgroundSourceUtils.getInstance(this.mContext).getPreviewBackgroundFilePath();
//        } else {
//			backgroundSourceFilePath = BackgroundSourceUtils.getInstance(this.mContext).getCurrentBackgroundFilePath();
//		}
//    }

    /**
     * 拷贝图片文件到背景资源目录（正式背景）
     */
//    public void setImageViewSource(String srcBackgroundPath) {
//        initBackgroundImagePath();
//        if (backgroundSourceFilePath == null) {
//            LogUtils.e(TAG, "目标路径初始化失败，无法保存背景图片");
//            return;
//        }
//
//        File srcFile = new File(srcBackgroundPath);
//        if (!srcFile.exists() || !srcFile.isFile()) {
//            LogUtils.e(TAG, String.format("源文件不存在或不是文件：%s", srcBackgroundPath));
//            return;
//        }
//
//        File destFile = new File(backgroundSourceFilePath);
//        File destDir = destFile.getParentFile();
//        if (destDir != null && !destDir.exists()) {
//            boolean isDirCreated = destDir.mkdirs();
//            if (!isDirCreated) {
//                LogUtils.e(TAG, "目标目录创建失败：" + destDir.getAbsolutePath());
//                return;
//            }
//        }
//
//        FileInputStream fis = null;
//        FileOutputStream fos = null;
//        try {
//            fis = new FileInputStream(srcFile);
//            fos = new FileOutputStream(destFile);
//
//            byte[] buffer = new byte[4096];
//            int len;
//            while ((len = fis.read(buffer)) != -1) {
//                fos.write(buffer, 0, len);
//            }
//            fos.flush();
//
//            LogUtils.d(TAG, String.format("文件拷贝成功：%s -> %s", srcBackgroundPath, backgroundSourceFilePath));
//            // 拷贝成功后，若处于预览模式则退出预览，加载正式背景
//            if (isPreviewMode) {
//                exitPreviewMode();
//            } else {
//                loadAndSetImageViewBackground();
//            }
//
//        } catch (Exception e) {
//            LogUtils.e(TAG, String.format("文件拷贝失败：%s", e.getMessage()), e);
//            if (destFile.exists()) {
//                destFile.delete();
//                LogUtils.d(TAG, "已删除损坏的目标文件");
//            }
//        } finally {
//            if (fis != null) {
//                try {
//                    fis.close();
//                } catch (Exception e) {
//                    LogUtils.e(TAG, "输入流关闭失败：" + e.getMessage());
//                }
//            }
//            if (fos != null) {
//                try {
//                    fos.close();
//                } catch (Exception e) {
//                    LogUtils.e(TAG, "输出流关闭失败：" + e.getMessage());
//                }
//            }
//        }
//    }

    /**
     * 预览临时图片（全透明背景 + 不拉伸居中平铺）
     * @param previewImagePath 临时预览图片的路径
     */
    /*public void previewBackgroundImage(String previewImagePath) {
	 if (previewImagePath == null || previewImagePath.isEmpty()) {
	 LogUtils.e(TAG, "预览图片路径为空");
	 setDefaultImageViewBackground();
	 return;
	 }

	 File previewFile = new File(previewImagePath);
	 if (!previewFile.exists() || !previewFile.isFile()) {
	 LogUtils.e(TAG, "预览图片不存在或不是文件：" + previewImagePath);
	 setDefaultImageViewBackground();
	 return;
	 }

	 // 计算图片原始宽高比
	 if (!calculateImageAspectRatio(previewFile)) {
	 LogUtils.e(TAG, "预览图片尺寸无效，无法预览");
	 setDefaultImageViewBackground();
	 return;
	 }

	 // 压缩加载预览图片（保持比例）
	 Bitmap previewBitmap = decodeBitmapWithCompress(previewFile, 1080, 1920);
	 if (previewBitmap == null) {
	 LogUtils.e(TAG, "预览图片加载失败");
	 setDefaultImageViewBackground();
	 return;
	 }

	 // 设置预览图片（保持ImageView透明背景）
	 Drawable previewDrawable = new BitmapDrawable(mContext.getResources(), previewBitmap);
	 if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
	 ivBackground.setBackground(previewDrawable);
	 } else {
	 ivBackground.setBackgroundDrawable(previewDrawable);
	 }

	 // 调整ImageView尺寸（居中平铺，不拉伸）
	 adjustImageViewSize();
	 isPreviewMode = true;
	 LogUtils.d(TAG, "进入预览模式，预览图片路径：" + previewImagePath + "，宽高比：" + imageAspectRatio);
	 }
	 */

    /**
     * 退出预览模式，恢复显示正式背景图片
     */
    /*public void exitPreviewMode() {
	 if (isPreviewMode) {
	 loadAndSetImageViewBackground();
	 isPreviewMode = false;
	 LogUtils.d(TAG, "退出预览模式，恢复正式背景");
	 }
	 }*/

    /**
     * 公共函数：供外部类调用，重新加载正式背景图片（刷新显示）
     */
    public void reloadCurrentBackground() {
        LogUtils.d(TAG, "外部调用重新加载背景图片");
		backgroundSourceFilePath = BackgroundSourceUtils.getInstance(this.mContext).getCurrentBackgroundFilePath();
        loadAndSetImageViewBackground();
    }
	
	public void reloadPreviewBackground() {
        LogUtils.d(TAG, "外部调用重新加载背景图片");
		backgroundSourceFilePath = BackgroundSourceUtils.getInstance(this.mContext).getPreviewBackgroundFilePath();
        loadAndSetImageViewBackground();
    }

    /**
     * 加载正式背景图片并设置到 ImageView（全透明背景 + 不拉伸居中平铺）
     */
    private void loadAndSetImageViewBackground() {
        if (backgroundSourceFilePath == null) {
			LogUtils.d(TAG, "backgroundSourceFilePath == null");
            setDefaultImageViewBackground();
            return;
        }
		//ToastUtils.show(String.format("backgroundSourceFilePath : %s", backgroundSourceFilePath));

        File backgroundFile = new File(backgroundSourceFilePath);
        if (!backgroundFile.exists() || !backgroundFile.isFile()) {
            LogUtils.e(TAG, "背景图片不存在：" + backgroundSourceFilePath);
            setDefaultImageViewBackground();
            return;
        }

        // 计算图片原始宽高比
        if (!calculateImageAspectRatio(backgroundFile)) {
            setDefaultImageViewBackground();
            return;
        }

        // 压缩加载 Bitmap（保持比例）
        Bitmap bitmap = decodeBitmapWithCompress(backgroundFile, 1080, 1920);
        if (bitmap == null) {
            LogUtils.e(TAG, "图片加载失败，无法解析为 Bitmap");
            setDefaultImageViewBackground();
            return;
        }

        // 设置图片（保持ImageView透明背景）
        Drawable backgroundDrawable = new BitmapDrawable(mContext.getResources(), bitmap);
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
            ivBackground.setBackground(backgroundDrawable);
        } else {
            ivBackground.setBackgroundDrawable(backgroundDrawable);
        }

        // 调整ImageView尺寸（居中平铺，不拉伸）
        adjustImageViewSize();
        LogUtils.d(TAG, "ImageView 背景加载成功（全透明+不拉伸），宽高比：" + imageAspectRatio);
    }

    /**
     * 计算图片原始宽高比（宽/高）
     */
    private boolean calculateImageAspectRatio(File file) {
        try {
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(file.getAbsolutePath(), options);

            int imageWidth = options.outWidth;
            int imageHeight = options.outHeight;

            if (imageWidth <= 0 || imageHeight <= 0) {
                LogUtils.e(TAG, "图片尺寸无效：宽=" + imageWidth + ", 高=" + imageHeight);
                return false;
            }

            imageAspectRatio = (float) imageWidth / imageHeight;
            return true;
        } catch (Exception e) {
            LogUtils.e(TAG, "计算图片宽高比失败：" + e.getMessage());
            return false;
        }
    }

    /**
     * 调整ImageView尺寸（不拉伸，居中平铺）
     */
    private void adjustImageViewSize() {
        int parentWidth = getWidth(); // 控件宽度（已填充父视图）
        int parentHeight = getHeight(); // 控件高度（已填充父视图）

        if (parentWidth == 0 || parentHeight == 0) {
            post(new Runnable() {
					@Override
					public void run() {
						adjustImageViewSize();
					}
				});
            return;
        }

        int imageViewWidth, imageViewHeight;
        if (imageAspectRatio >= 1.0f) { // 横图
            imageViewWidth = Math.min(parentWidth, (int) (parentHeight * imageAspectRatio));
            imageViewHeight = (int) (imageViewWidth / imageAspectRatio);
        } else { // 竖图
            imageViewHeight = Math.min(parentHeight, (int) (parentWidth / imageAspectRatio));
            imageViewWidth = (int) (imageViewHeight * imageAspectRatio);
        }

        // 应用尺寸
        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) ivBackground.getLayoutParams();
        layoutParams.width = imageViewWidth;
        layoutParams.height = imageViewHeight;
        ivBackground.setLayoutParams(layoutParams);

        LogUtils.d(TAG, "ImageView 尺寸调整完成：宽=" + imageViewWidth + ", 高=" + imageViewHeight);
    }

    /**
     * 带压缩的 Bitmap 解码（保持比例，避免 OOM）
     */
    private Bitmap decodeBitmapWithCompress(File file, int maxWidth, int maxHeight) {
        try {
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(file.getAbsolutePath(), options);

            int scaleX = options.outWidth / maxWidth;
            int scaleY = options.outHeight / maxHeight;
            int inSampleSize = Math.max(scaleX, scaleY);
            if (inSampleSize <= 0) {
                inSampleSize = 1;
            }

            options.inJustDecodeBounds = false;
            options.inSampleSize = inSampleSize;
            options.inPreferredConfig = Bitmap.Config.RGB_565;
            return BitmapFactory.decodeFile(file.getAbsolutePath(), options);
        } catch (Exception e) {
            LogUtils.e(TAG, "图片压缩加载失败：" + e.getMessage());
            return null;
        }
    }

    /**
     * 设置默认背景（全透明兜底，避免空白）
     */
    private void setDefaultImageViewBackground() {
        // 关键：默认背景设为全透明（而非默认图，避免遮挡下层视图）
        ivBackground.setBackground(new ColorDrawable(0x00000000)); // 全透明背景
        imageAspectRatio = 1.0f;
        adjustImageViewSize();
        LogUtils.d(TAG, "已设置默认透明背景");
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        adjustImageViewSize();
    }

    /**
     * 对外提供：判断当前是否处于预览模式
     */
    public boolean isPreviewMode() {
        return isPreviewMode;
    }
}

