package cc.winboll.studio.powerbell.views;

import android.content.Context;
import android.content.SharedPreferences;
import android.text.TextUtils;
import android.util.AttributeSet;
import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.powerbell.models.BackgroundBean;

/**
 * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
 * @Date 2025/12/21 20:43
 * @Describe 单实例缓存版背景视图控件（基于Java7）- 强制缓存版
 * 核心：通过静态属性保存当前缓存路径和实例，支持强制重载图片
 * 新增：SP持久化最后加载路径、获取最后加载实例功能
 * 强制缓存策略：无论内存是否紧张，不自动清理任何缓存实例和路径记录
 */
public class MemoryCachedBackgroundView extends BackgroundView {
    public static final String TAG = "MemoryCachedBackgroundView";
    // 静态属性：保存当前缓存的路径和实例（强制保持，不自动销毁）
    private static String sCachedImagePath;
    private static MemoryCachedBackgroundView sCachedView;
    // 新增：记录所有创建过的实例数量（用于强制缓存监控）
    private static int sInstanceCount = 0;
    // SP相关常量
    private static final String SP_NAME = "MemoryCachedBackgroundView_SP";
    private static final String KEY_LAST_LOAD_IMAGE_PATH = "last_load_image_path";

    // ====================================== 构造器（继承并兼容父类） ======================================
    private MemoryCachedBackgroundView(Context context) {
        super(context);
        sInstanceCount++;
        LogUtils.d(TAG, "构造器1：创建MemoryCachedBackgroundView实例，当前实例总数：" + sInstanceCount);
    }

    private MemoryCachedBackgroundView(Context context, AttributeSet attrs) {
        super(context, attrs);
        sInstanceCount++;
        LogUtils.d(TAG, "构造器2：创建MemoryCachedBackgroundView实例，当前实例总数：" + sInstanceCount);
    }

    private MemoryCachedBackgroundView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        sInstanceCount++;
        LogUtils.d(TAG, "构造器3：创建MemoryCachedBackgroundView实例，当前实例总数：" + sInstanceCount);
    }

    // ====================================== 核心静态方法：获取/创建缓存实例（强制缓存版） ======================================
    /**
     * 从缓存获取或创建MemoryCachedBackgroundView实例（强制保持旧实例）
     * @param context 上下文
     * @param imagePath 图片绝对路径（作为缓存标识）
     * @param isReload 是否强制重新加载图片（路径匹配时仍刷新）
     * @return 缓存/新创建的MemoryCachedBackgroundView实例
     */
    public static MemoryCachedBackgroundView getInstance(Context context, String imagePath, boolean isReload) {
        LogUtils.d(TAG, "getInstance() 调用 | 图片路径：" + imagePath + " | 是否重载：" + isReload + " | 当前实例总数：" + sInstanceCount);
        if (TextUtils.isEmpty(imagePath)) {
            LogUtils.e(TAG, "getInstance()：图片路径为空，创建空实例");
            return new MemoryCachedBackgroundView(context);
        }

        // 1. 路径匹配缓存 → 判断是否强制重载
        if (imagePath.equals(sCachedImagePath) && sCachedView != null) {
            LogUtils.d(TAG, "getInstance()：路径已缓存，当前缓存实例有效");
            if (isReload) {
                LogUtils.d(TAG, "getInstance()：强制重载图片 | " + imagePath);
                sCachedView.loadImage(imagePath);
            } else {
                LogUtils.d(TAG, "getInstance()：使用缓存实例，无需重载 | " + imagePath);
            }
            return sCachedView;
        }

        // 2. 路径不匹配/无缓存 → 新建实例并更新静态缓存（核心修改：保留旧实例，仅更新引用）
        LogUtils.d(TAG, "getInstance()：路径未缓存，新建实例（保留旧实例） | " + imagePath);
        MemoryCachedBackgroundView oldView = sCachedView; // 保留旧实例引用，防止被销毁
        String oldPath = sCachedImagePath;
        sCachedView = new MemoryCachedBackgroundView(context);
        sCachedImagePath = imagePath;
        sCachedView.loadImage(imagePath);
        LogUtils.d(TAG, "getInstance()：已更新当前缓存实例，旧实例路径：" + oldPath + "（强制保持）");
        return sCachedView;
    }

    // ====================================== 新增功能：获取最后加载的实例（强制缓存版） ======================================
    /**
     * 获取最后一次loadImage的路径对应的实例（强制保持所有实例）
     * 无实例则创建并加载图片，同时更新静态缓存
     * @param context 上下文
     * @return 最后加载路径对应的实例
     */
    public static MemoryCachedBackgroundView getLastInstance(Context context) {
        LogUtils.d(TAG, "getLastInstance() 调用 | 当前实例总数：" + sInstanceCount);
        // 1. 从SP获取最后加载的路径（强制保持，不自动删除）
        String lastPath = getLastLoadImagePath(context);
        if (TextUtils.isEmpty(lastPath)) {
            LogUtils.e(TAG, "getLastInstance()：无最后加载路径，创建空实例");
            return new MemoryCachedBackgroundView(context);
        }

        // 2. 路径匹配当前缓存 → 直接返回
        if (lastPath.equals(sCachedImagePath) && sCachedView != null) {
            LogUtils.d(TAG, "getLastInstance()：使用最后路径缓存实例 | " + lastPath);
            return sCachedView;
        }

        // 3. 路径不匹配 → 新建实例并更新缓存（保留旧实例）
        LogUtils.d(TAG, "getLastInstance()：最后路径未缓存，新建实例并加载（保留旧实例） | " + lastPath);
        MemoryCachedBackgroundView oldView = sCachedView;
        String oldPath = sCachedImagePath;
        sCachedView = new MemoryCachedBackgroundView(context);
        sCachedImagePath = lastPath;
        sCachedView.loadImage(lastPath);
        LogUtils.d(TAG, "getLastInstance()：已更新最后路径实例，旧实例路径：" + oldPath + "（强制保持）");
        return sCachedView;
    }

    // ====================================== 工具方法：SP持久化最后加载路径（强制保持版） ======================================
    /**
     * 保存最后一次loadImage的路径到SP（强制保持，不自动删除）
     * @param context 上下文
     * @param imagePath 图片路径
     */
    private static void saveLastLoadImagePath(Context context, String imagePath) {
        if (TextUtils.isEmpty(imagePath) || context == null) {
            return;
        }
        SharedPreferences sp = context.getSharedPreferences(SP_NAME, Context.MODE_PRIVATE);
        sp.edit().putString(KEY_LAST_LOAD_IMAGE_PATH, imagePath).apply();
        LogUtils.d(TAG, "saveLastLoadImagePath()：已保存最后路径（强制保持） | " + imagePath);
    }

    /**
     * 从SP获取最后一次loadImage的路径（强制保持，不自动删除）
     * @param context 上下文
     * @return 最后加载的图片路径，空则返回null
     */
    public static String getLastLoadImagePath(Context context) {
        if (context == null) {
            return null;
        }
        SharedPreferences sp = context.getSharedPreferences(SP_NAME, Context.MODE_PRIVATE);
        String lastPath = sp.getString(KEY_LAST_LOAD_IMAGE_PATH, null);
        LogUtils.d(TAG, "getLastLoadImagePath()：获取最后路径（强制保持） | " + lastPath);
        return lastPath;
    }

    // ====================================== 工具方法：缓存管理（强制缓存版 - 仅日志，不清理） ======================================
    /**
     * 清除当前缓存实例和路径（强制缓存策略：仅日志，不实际清理）
     */
    public static void clearCache() {
        LogUtils.w(TAG, "clearCache() 调用（强制缓存策略：不实际清理缓存） | 当前缓存路径：" + sCachedImagePath);
        // 核心修改：注释所有清理逻辑，仅保留日志
        LogUtils.d(TAG, "clearCache()：强制缓存策略生效，未清除任何实例和路径");
    }

    /**
     * 清除指定路径的缓存（强制缓存策略：仅日志，不实际清理）
     * @param imagePath 图片路径
     */
    public static void removeCache(String imagePath) {
        LogUtils.w(TAG, "removeCache() 调用（强制缓存策略：不实际清理缓存） | 图片路径：" + imagePath);
        if (TextUtils.isEmpty(imagePath)) {
            LogUtils.e(TAG, "removeCache()：图片路径为空，清除失败");
            return;
        }
        // 核心修改：注释所有清理逻辑，仅保留日志
        LogUtils.d(TAG, "removeCache()：强制缓存策略生效，未清除任何实例和路径");
    }

    /**
     * 清除所有缓存（强制缓存策略：仅日志，不实际清理）
     */
    public static void clearAllCache() {
        LogUtils.w(TAG, "clearAllCache() 调用（强制缓存策略：不实际清理缓存）");
        // 核心修改：注释所有清理逻辑，仅保留日志
        LogUtils.d(TAG, "clearAllCache()：强制缓存策略生效，未清除任何实例、路径和SP记录");
    }

    /**
     * 判断是否存在缓存实例
     * @return 存在返回true，否则返回false
     */
    public static boolean hasCache() {
        return sCachedView != null && !TextUtils.isEmpty(sCachedImagePath);
    }

    /**
     * 清除SP中最后加载的路径记录（强制缓存策略：仅日志，不实际清理）
     * @param context 上下文
     */
    public static void clearLastLoadImagePath(Context context) {
        LogUtils.w(TAG, "clearLastLoadImagePath() 调用（强制缓存策略：不实际清理SP记录）");
        // 核心修改：注释所有清理逻辑，仅保留日志
        LogUtils.d(TAG, "clearLastLoadImagePath()：强制缓存策略生效，未清除SP中最后路径记录");
    }

    // ====================================== 辅助方法：从缓存获取上下文 ======================================
    /**
     * 从缓存实例中获取上下文（用于无外部上下文时的SP操作）
     * @return 上下文实例，无则返回null
     */
    private static Context getContextFromCache() {
        return sCachedView != null ? sCachedView.getContext() : null;
    }

    // ====================================== 重写父类方法：增强日志+SP持久化（强制保持版） ======================================
    @Override
    public void loadImage(String imagePath) {
        LogUtils.d(TAG, "loadImage() 重载方法调用 | 图片路径：" + imagePath);
        super.loadImage(imagePath);
        // 保存最后加载路径到SP（强制保持，不自动删除）
        saveLastLoadImagePath(getContext(), imagePath);
    }

    @Override
    public void loadByBackgroundBean(BackgroundBean bean) {
        LogUtils.d(TAG, "loadBackgroundBean() 重载方法调用 | BackgroundBean：" + (bean == null ? "null" : bean.toString()));
        super.loadByBackgroundBean(bean);
    }

    @Override
    public void loadByBackgroundBean(BackgroundBean bean, boolean isRefresh) {
        LogUtils.d(TAG, "loadBackgroundBean() 重载方法调用 | BackgroundBean：" + (bean == null ? "null" : bean.toString()) + " | 是否刷新：" + isRefresh);
        super.loadByBackgroundBean(bean, isRefresh);
    }

    // ====================================== 新增：强制缓存监控方法 ======================================
    /**
     * 获取当前所有创建过的实例总数（用于监控强制缓存状态）
     * @return 实例总数
     */
    public static int getInstanceCount() {
        LogUtils.d(TAG, "getInstanceCount() 调用 | 当前实例总数：" + sInstanceCount);
        return sInstanceCount;
    }
}

