package cc.winboll.studio.powerbell;

import android.content.Context;
import cc.winboll.studio.libaes.utils.WinBoLLActivityManager;
import cc.winboll.studio.libappbase.GlobalApplication;
import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.libappbase.ToastUtils;
import cc.winboll.studio.powerbell.models.NotificationMessage;
import cc.winboll.studio.powerbell.receivers.GlobalApplicationReceiver;
import cc.winboll.studio.powerbell.utils.AppCacheUtils;
import cc.winboll.studio.powerbell.utils.AppConfigUtils;
import cc.winboll.studio.powerbell.utils.BackgroundSourceUtils;
import cc.winboll.studio.powerbell.utils.BitmapCacheUtils;
import cc.winboll.studio.powerbell.utils.NotificationManagerUtils;
import cc.winboll.studio.powerbell.views.MemoryCachedBackgroundView;

/**
 * 应用全局入口类（适配Android API 30，基于Java 7编写）
 * 核心策略：极致强制缓存 - 无论内存紧张程度，永不自动清理任何缓存（Bitmap/视图控件/路径记录）
 * @Author 豆包&ZhanGSKen<zhangsken@qq.com>
 * @Version 1.0.0
 * @Date 2025-12-25
 */
public class App extends GlobalApplication {
    // ===================== 常量定义区（按功能分类排序） =====================
    public static final String TAG = "App";

    // 组件跳转常量
    public static final String COMPONENT_EN1 = "cc.winboll.studio.powerbell.MainActivityEN1";
    public static final String COMPONENT_CN1 = "cc.winboll.studio.powerbell.MainActivityCN1";
    public static final String COMPONENT_CN2 = "cc.winboll.studio.powerbell.MainActivityCN2";

    // 动作跳转常量
    public static final String ACTION_SWITCHTO_EN1 = "cc.winboll.studio.powerbell.App.ACTION_SWITCHTO_EN1";
    public static final String ACTION_SWITCHTO_CN1 = "cc.winboll.studio.powerbell.App.ACTION_SWITCHTO_CN1";
    public static final String ACTION_SWITCHTO_CN2 = "cc.winboll.studio.powerbell.App.ACTION_SWITCHTO_CN2";

    // 缓存防护常量
    private static final String CACHE_PROTECT_TAG = "FORCE_CACHE_PROTECT";
    private static final int INVALID_BATTERY_VALUE = -1;

    // ===================== 静态属性区（按工具类优先级排序） =====================
    // 应用单例
    private static App sApp;

    // 数据配置工具
    public static AppConfigUtils sAppConfigUtils;
    private static AppCacheUtils sAppCacheUtils;

    // 全局Bitmap缓存工具（极致强制保持：一旦初始化，永不销毁）
    public static BackgroundSourceUtils sBackgroundSourceUtils;
    public static BitmapCacheUtils sBitmapCacheUtils;

    // 全局视图控件缓存工具（极致强制保持：一旦初始化，永不销毁）
    private static MemoryCachedBackgroundView sMemoryCachedBackgroundView;

    // 电池状态
    public static volatile int sQuantityOfElectricity = INVALID_BATTERY_VALUE;

    // 通知管理工具
    private static NotificationManagerUtils sNotificationManagerUtils;

    // ===================== 成员属性区（按生命周期关联度排序） =====================
    // 全局广播接收器
    private GlobalApplicationReceiver mGlobalReceiver;

    // ===================== 公共静态方法区（单例/工具类实例获取） =====================
    /**
     * 获取应用单例实例
     */
    public static App getInstance() {
        LogUtils.d(TAG, "getInstance() 调用 | 返回实例：" + sApp);
        return sApp;
    }

    /**
     * 获取应用配置工具实例
     */
    public static AppConfigUtils getAppConfigUtils(Context context) {
        String contextType = context != null ? context.getClass().getSimpleName() : "null";
        LogUtils.d(TAG, "getAppConfigUtils() 调用 | 入参Context类型：" + contextType);

        if (sAppConfigUtils == null) {
            sAppConfigUtils = AppConfigUtils.getInstance(context);
            LogUtils.d(TAG, "getAppConfigUtils() | AppConfigUtils实例初始化完成");
        }
        LogUtils.d(TAG, "getAppConfigUtils() | 返回实例：" + sAppConfigUtils);
        return sAppConfigUtils;
    }

    /**
     * 获取应用缓存工具实例
     */
    public static AppCacheUtils getAppCacheUtils(Context context) {
        String contextType = context != null ? context.getClass().getSimpleName() : "null";
        LogUtils.d(TAG, "getAppCacheUtils() 调用 | 入参Context类型：" + contextType);

        if (sAppCacheUtils == null) {
            sAppCacheUtils = AppCacheUtils.getInstance(context);
            LogUtils.d(TAG, "getAppCacheUtils() | AppCacheUtils实例初始化完成");
        }
        LogUtils.d(TAG, "getAppCacheUtils() | 返回实例：" + sAppCacheUtils);
        return sAppCacheUtils;
    }

    // ===================== 公共成员方法区（业务功能） =====================
    /**
     * 清除电池历史数据
     */
    public void clearBatteryHistory() {
        LogUtils.d(TAG, "clearBatteryHistory() 调用");
        if (sAppCacheUtils != null) {
            sAppCacheUtils.clearBatteryHistory();
            LogUtils.d(TAG, "clearBatteryHistory() | 电池历史数据清除成功");
        } else {
            LogUtils.w(TAG, "clearBatteryHistory() | 失败：AppCacheUtils未初始化");
        }
    }

    /**
     * 手动清理所有缓存（带严格权限控制，仅主动调用生效）
     * 极致强制缓存策略下，仅提供手动清理入口，永不自动调用
     */
    public static void manualClearAllCache() {
        LogUtils.w(CACHE_PROTECT_TAG, "manualClearAllCache() 调用 | 极致缓存策略下谨慎使用");

        // 清理Bitmap缓存
        if (sBitmapCacheUtils != null) {
            sBitmapCacheUtils.clearAllCache();
            LogUtils.d(CACHE_PROTECT_TAG, "manualClearAllCache() | Bitmap缓存手动清理完成");
        }

        // 清理视图控件缓存（仅清除静态引用，不销毁实例）
        if (sMemoryCachedBackgroundView != null) {
            LogUtils.d(CACHE_PROTECT_TAG, "manualClearAllCache() | 视图缓存保留实例，仅清除静态引用");
            sMemoryCachedBackgroundView = null;
        }
        LogUtils.w(CACHE_PROTECT_TAG, "manualClearAllCache() | 手动清理完成 | 部分缓存实例仍驻留内存");
    }

    /**
     * 获取视图控件缓存实例（非通用：仅通过App实例调用，避免全局直接访问）
     */
    public MemoryCachedBackgroundView getMemoryCachedBackgroundView() {
        LogUtils.d(TAG, "getMemoryCachedBackgroundView() 调用 | 当前实例：" + sMemoryCachedBackgroundView);
        return sMemoryCachedBackgroundView;
    }

    /**
     * 发送调试通知
     */
    public static void notifyMessage(String title, String content) {
        LogUtils.d(TAG, "notifyMessage() 调用 | 入参title：" + title + " | content：" + content);

        boolean canNotify = isDebugging() && sApp != null && sNotificationManagerUtils != null;
        if (canNotify) {
            NotificationMessage message = new NotificationMessage(title, content, "");
            sNotificationManagerUtils.showMessageNotification(sApp, message);
            LogUtils.d(TAG, "notifyMessage() | 调试通知发送成功");
        } else {
            LogUtils.d(TAG, "notifyMessage() | 发送失败：调试模式未开启/工具类未初始化");
        }
    }

    // ===================== 生命周期方法区（按执行顺序排序） =====================
    @Override
    public void onCreate() {
        super.onCreate();
        LogUtils.d(TAG, "onCreate() | 应用启动，开始初始化流程");
        sApp = this;

        // 初始化调试模式
        setIsDebugging(BuildConfig.DEBUG);
        LogUtils.d(TAG, "onCreate() | 调试模式状态：" + BuildConfig.DEBUG);

        // 初始化核心组件
        initBaseTools();
        initUtils();
        initReceiver();

        LogUtils.d(TAG, "onCreate() | 应用初始化完成 | 极致强制缓存策略已启用");
    }

    @Override
    public void onTerminate() {
        super.onTerminate();
        LogUtils.d(TAG, "onTerminate() | 应用终止，释放非缓存资源");

        // 释放轻量级工具
        ToastUtils.release();
        LogUtils.d(TAG, "onTerminate() | Toast工具资源释放完成");

        releaseNotificationManager();
        releaseReceiver();

        // 核心策略：应用终止不清理任何缓存
        LogUtils.w(CACHE_PROTECT_TAG, "onTerminate() | 极致缓存策略生效 | 所有缓存实例保持驻留");
        LogUtils.d(TAG, "onTerminate() | 非缓存资源释放完成");
    }

    @Override
    public void onTrimMemory(int level) {
        super.onTrimMemory(level);
        // 极致缓存策略：拒绝系统触发的缓存清理
        LogUtils.w(CACHE_PROTECT_TAG, "onTrimMemory() 调用 | 内存等级：" + level + " | 强制保持所有缓存");
        logDetailedCacheStatus();
    }

    @Override
    public void onLowMemory() {
        super.onLowMemory();
        // 低内存场景：不清理缓存，仅记录状态
        LogUtils.w(CACHE_PROTECT_TAG, "onLowMemory() 调用 | 极致缓存策略：不执行任何清理操作");
        logDetailedCacheStatus();
    }

    // ===================== 私有初始化方法区（按初始化顺序排序） =====================
    /**
     * 初始化基础工具（Activity管理、Toast、通知工具）
     */
    private void initBaseTools() {
        LogUtils.d(TAG, "initBaseTools() | 开始初始化基础工具集");
        WinBoLLActivityManager.init(this);
        ToastUtils.init(this);
        sNotificationManagerUtils = new NotificationManagerUtils(this);
        LogUtils.d(TAG, "initBaseTools() | ActivityManager/Toast/Notification工具初始化完成");
    }

    /**
     * 初始化核心工具类（极致强制缓存：一旦初始化永不销毁）
     */
    private void initUtils() {
        LogUtils.d(TAG, "initUtils() | 开始初始化核心工具类 | 启用极致强制缓存策略");

        // 初始化配置与缓存工具
        sAppConfigUtils = getAppConfigUtils(this);
        sAppCacheUtils = getAppCacheUtils(this);

        // 初始化背景资源与Bitmap缓存
        sBackgroundSourceUtils = BackgroundSourceUtils.getInstance(this);
        sBackgroundSourceUtils.loadSettings();
        sBitmapCacheUtils = BitmapCacheUtils.getInstance();
        LogUtils.d(TAG, "initUtils() | BackgroundSource/BitmapCache工具初始化完成 | 永久驻留内存");

        // 初始化视图控件缓存
        sMemoryCachedBackgroundView = MemoryCachedBackgroundView.getLastInstance(this);
        if (sMemoryCachedBackgroundView == null) {
            sMemoryCachedBackgroundView = MemoryCachedBackgroundView.getInstance(this, sBackgroundSourceUtils.getCurrentBackgroundBean(), true);
            LogUtils.d(TAG, "initUtils() | 视图缓存工具：新建实例完成");
        }
        LogUtils.d(TAG, "initUtils() | MemoryCachedBackgroundView初始化完成 | 永久驻留内存");
    }

    /**
     * 初始化全局广播接收器
     */
    private void initReceiver() {
        LogUtils.d(TAG, "initReceiver() | 开始初始化广播接收器");
        mGlobalReceiver = new GlobalApplicationReceiver(this);
        mGlobalReceiver.registerAction();
        LogUtils.d(TAG, "initReceiver() | 广播接收器注册完成");
    }

    // ===================== 私有释放方法区（按资源重要性排序） =====================
    /**
     * 释放广播接收器资源
     */
    private void releaseReceiver() {
        LogUtils.d(TAG, "releaseReceiver() | 开始释放广播接收器");
        if (mGlobalReceiver != null) {
            mGlobalReceiver.unregisterAction();
            mGlobalReceiver = null;
            LogUtils.d(TAG, "releaseReceiver() | 广播接收器资源释放完成");
        } else {
            LogUtils.d(TAG, "releaseReceiver() | 无需释放：广播接收器未初始化");
        }
    }

    /**
     * 释放通知管理工具资源
     */
    private void releaseNotificationManager() {
        LogUtils.d(TAG, "releaseNotificationManager() | 开始释放通知工具");
        if (sNotificationManagerUtils != null) {
            sNotificationManagerUtils.release();
            sNotificationManagerUtils = null;
            LogUtils.d(TAG, "releaseNotificationManager() | 通知工具资源释放完成");
        } else {
            LogUtils.d(TAG, "releaseNotificationManager() | 无需释放：通知工具未初始化");
        }
    }

    // ===================== 私有工具方法区（辅助功能） =====================
    /**
     * 记录详细缓存状态（用于调试，监控极致强制缓存效果）
     */
    private void logDetailedCacheStatus() {
        LogUtils.d(TAG, "logDetailedCacheStatus() | 开始记录缓存状态");

        // 记录Bitmap缓存状态
        if (sBitmapCacheUtils != null) {
            LogUtils.d(CACHE_PROTECT_TAG, "Bitmap缓存工具：实例有效（永久驻留）");
            try {
                int cacheCount = sBitmapCacheUtils.getCacheCount();
                LogUtils.d(CACHE_PROTECT_TAG, "Bitmap缓存数量：" + cacheCount);
            } catch (Exception e) {
                LogUtils.d(CACHE_PROTECT_TAG, "Bitmap缓存数量获取失败 | 异常信息：" + e.getMessage());
            }
        }

        // 记录视图缓存状态
        if (sMemoryCachedBackgroundView != null) {
            LogUtils.d(CACHE_PROTECT_TAG, "视图缓存工具：实例有效（永久驻留）");
            int viewCount = MemoryCachedBackgroundView.getInstanceCount();
            LogUtils.d(CACHE_PROTECT_TAG, "视图缓存实例总数：" + viewCount);
        }
        LogUtils.d(TAG, "logDetailedCacheStatus() | 缓存状态记录完成");
    }
}

