package cc.winboll.studio.powerbell.utils;

import android.app.Activity;
import android.content.Context;
import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.powerbell.App;
import cc.winboll.studio.powerbell.MainActivity;
import cc.winboll.studio.powerbell.models.AppConfigBean;
import cc.winboll.studio.powerbell.models.ControlCenterServiceBean;
import cc.winboll.studio.powerbell.services.ControlCenterService;

/**
 * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
 * @Date 2025/12/17 13:59
 * @Describe 应用配置工具类：管理应用核心配置（服务开关、电池提醒阈值、背景设置等）
 * 适配：Java7 | API30 | 小米手机，单例模式，线程安全，配置持久化
 */
public class AppConfigUtils {
    // ======================== 静态常量（顶部统一管理，抽离魔法值）========================
    public static final String TAG = "AppConfigUtils";
    public static final String BACKGROUND_DIR = "Background"; // 背景图片存储目录
    private static final int MIN_REMINDER_VALUE = 0;         // 提醒阈值最小值
    private static final int MAX_REMINDER_VALUE = 100;       // 提醒阈值最大值
    private static final int MIN_INTERVAL_TIME = 1000;       // 最小提醒间隔（ms）
    private static final int MIN_DETECT_INTERVAL = 500;      // 最小电量检测间隔（ms）

    // ======================== 静态成员（单例实例，严格控制初始化）========================
    private static AppConfigUtils sInstance; // 单例实例（私有，禁止外部直接创建）

    // ======================== 核心依赖属性（优先排列，final保障安全）========================
    private final Context mContext;          // 应用上下文（避免内存泄漏）
    private App mApplication;                // 应用Application实例

    // ======================== 配置Bean属性（持久化核心，volatile保障线程安全）========================
    public volatile AppConfigBean mAppConfigBean;              // 应用配置Bean

    // ======================== 缓存状态属性（减少Bean读取次数，提升性能）========================
    private volatile boolean mIsServiceEnabled = false;        // 服务开关缓存状态


    // ======================== 单例构造方法（私有，禁止外部实例化）========================
    private AppConfigUtils(Context context) {
        LogUtils.d(TAG, "初始化配置工具类");
        this.mContext = context.getApplicationContext(); // 强制取应用上下文，杜绝内存泄漏
        this.mApplication = (App) context.getApplicationContext();
        // 初始化配置Bean
        mAppConfigBean = new AppConfigBean();
        // 加载持久化配置
        loadAppConfig();
        LogUtils.d(TAG, "配置工具类初始化完成");
    }

    // ======================== 单例获取方法（双重校验锁，线程安全，适配多线程）========================
    public static AppConfigUtils getInstance(Context context) {
        if (context == null) {
            LogUtils.e(TAG, "getInstance: Context不能为空，获取实例失败");
            throw new IllegalArgumentException("Context cannot be null");
        }
        if (sInstance == null) {
            synchronized (AppConfigUtils.class) {
                if (sInstance == null) {
                    sInstance = new AppConfigUtils(context);
                    LogUtils.d(TAG, "getInstance: 单例实例创建成功");
                }
            }
        }
        return sInstance;
    }


    // ======================== 核心配置加载/保存方法（内部核心逻辑，优先排列）========================
    /**
     * 加载所有配置（应用配置+服务配置，统一入口，初始化/重载通用）
     */
    public AppConfigBean loadAppConfig() {
        LogUtils.d(TAG, "loadAllConfig: 开始加载所有配置");
        // 加载应用配置
        AppConfigBean savedAppBean = (AppConfigBean) AppConfigBean.loadBean(mContext, AppConfigBean.class);
        if (savedAppBean != null) {
            mAppConfigBean = savedAppBean;
            LogUtils.d(TAG, "loadAllConfig: 应用配置加载成功");
        } else {
			mAppConfigBean = new AppConfigBean();
            AppConfigBean.saveBean(mContext, mAppConfigBean);
            LogUtils.d(TAG, "loadAllConfig: 无已保存应用配置，使用默认值并持久化");
        }
		return mAppConfigBean;
    }

    /**
     * 保存应用配置（内部核心方法，直接持久化，同步通知服务+Activity）
     */
    private void saveAppConfig() {
        AppConfigBean.saveBean(mContext, mAppConfigBean);
        LogUtils.d(TAG, "saveAppConfig: 应用配置保存成功，已同步服务和Activity");
    }

    // ======================== 充电提醒配置方法（单独归类，逻辑聚焦）========================
    /**
     * 设置充电提醒开关状态（直接生效，无弹窗）
     * @param isEnabled 目标状态（true=开启，false=关闭）
     */
    public void setChargeReminderEnabled(final boolean isEnabled) {
        if (isEnabled == mAppConfigBean.isEnableChargeReminder()) {
            LogUtils.d(TAG, "setChargeReminderEnabled: 充电提醒状态无变化，无需操作");
            return;
        }
        mAppConfigBean.setEnableChargeReminder(isEnabled);
        saveAppConfig();
        LogUtils.d(TAG, "setChargeReminderEnabled: 充电提醒状态更新为=" + (isEnabled ? "开启" : "关闭"));
    }

    /**
     * 获取充电提醒开关状态
     * @return 充电提醒状态（true=开启，false=关闭）
     */
    public boolean isChargeReminderEnabled() {
        boolean isEnabled = mAppConfigBean.isEnableChargeReminder();
        LogUtils.d(TAG, "isChargeReminderEnabled: 获取充电提醒状态=" + (isEnabled ? "开启" : "关闭"));
        return isEnabled;
    }

    /**
     * 设置充电提醒阈值（直接生效，无弹窗，自动校准范围，适配API30数据安全）
     * @param value 目标阈值（自动校准0-100）
     */
    public void setChargeReminderValue(final int value) {
        final int calibratedValue = Math.min(Math.max(value, MIN_REMINDER_VALUE), MAX_REMINDER_VALUE);
        if (calibratedValue == mAppConfigBean.getChargeReminderValue()) {
            LogUtils.d(TAG, "setChargeReminderValue: 充电提醒阈值无变化，无需操作");
            return;
        }
        mAppConfigBean.setChargeReminderValue(calibratedValue);
        saveAppConfig();
        LogUtils.d(TAG, "setChargeReminderValue: 充电提醒阈值更新为=" + calibratedValue + "%");
    }

    /**
     * 获取充电提醒阈值
     * @return 充电提醒阈值（0-100）
     */
    public int getChargeReminderValue() {
        int value = mAppConfigBean.getChargeReminderValue();
        LogUtils.d(TAG, "getChargeReminderValue: 获取充电提醒阈值=" + value + "%");
        return value;
    }


    // ======================== 耗电提醒配置方法（单独归类，逻辑聚焦）========================
    /**
     * 设置耗电提醒开关状态（直接生效，无弹窗）
     * @param isEnabled 目标状态（true=开启，false=关闭）
     */
    public void setUsageReminderEnabled(final boolean isEnabled) {
        if (isEnabled == mAppConfigBean.isEnableUsageReminder()) {
            LogUtils.d(TAG, "setUsageReminderEnabled: 耗电提醒状态无变化，无需操作");
            return;
        }
        mAppConfigBean.setEnableUsageReminder(isEnabled);
        saveAppConfig();
        LogUtils.d(TAG, "setUsageReminderEnabled: 耗电提醒状态更新为=" + (isEnabled ? "开启" : "关闭"));
    }

    /**
     * 获取耗电提醒开关状态
     * @return 耗电提醒状态（true=开启，false=关闭）
     */
    public boolean isUsageReminderEnabled() {
        boolean isEnabled = mAppConfigBean.isEnableUsageReminder();
        LogUtils.d(TAG, "isUsageReminderEnabled: 获取耗电提醒状态=" + (isEnabled ? "开启" : "关闭"));
        return isEnabled;
    }

    /**
     * 设置耗电提醒阈值（直接生效，无弹窗，自动校准范围，适配小米手机电量跳变）
     * @param value 目标阈值（自动校准0-100）
     */
    public void setUsageReminderValue(final int value) {
        final int calibratedValue = Math.min(Math.max(value, MIN_REMINDER_VALUE), MAX_REMINDER_VALUE);
        if (calibratedValue == mAppConfigBean.getUsageReminderValue()) {
            LogUtils.d(TAG, "setUsageReminderValue: 耗电提醒阈值无变化，无需操作");
            return;
        }
        mAppConfigBean.setUsageReminderValue(calibratedValue);
        saveAppConfig();
        LogUtils.d(TAG, "setUsageReminderValue: 耗电提醒阈值更新为=" + calibratedValue + "%");
    }

    /**
     * 获取耗电提醒阈值
     * @return 耗电提醒阈值（0-100）
     */
    public int getUsageReminderValue() {
        int value = mAppConfigBean.getUsageReminderValue();
        LogUtils.d(TAG, "getUsageReminderValue: 获取耗电提醒阈值=" + value + "%");
        return value;
    }


    // ======================== 实时电池状态配置方法（临时缓存，不持久化，无需弹窗）========================
    /**
     * 设置当前充电状态（仅内存缓存，不持久化）
     * @param isCharging 充电状态（true=充电中，false=未充电）
     */
    public void setCharging(boolean isCharging) {
        if (isCharging == mAppConfigBean.isCharging()) {
            LogUtils.d(TAG, "setCharging: 充电状态无变化，无需操作");
            return;
        }
        mAppConfigBean.setIsCharging(isCharging);
        LogUtils.d(TAG, "setCharging: 充电状态更新为=" + (isCharging ? "充电中" : "未充电"));
    }

    /**
     * 获取当前充电状态
     * @return 充电状态（true=充电中，false=未充电）
     */
    public boolean isCharging() {
        boolean isCharging = mAppConfigBean.isCharging();
        LogUtils.d(TAG, "isCharging: 获取充电状态=" + (isCharging ? "充电中" : "未充电"));
        return isCharging;
    }

    /**
     * 设置当前电池电量（仅内存缓存，不持久化，自动校准范围）
     * @param value 当前电量（自动校准0-100）
     */
    public void setCurrentBatteryValue(int value) {
        int calibratedValue = Math.min(Math.max(value, MIN_REMINDER_VALUE), MAX_REMINDER_VALUE);
        if (calibratedValue == mAppConfigBean.getCurrentBatteryValue()) {
            LogUtils.d(TAG, "setCurrentBatteryValue: 电池电量无变化，无需操作");
            return;
        }
        mAppConfigBean.setCurrentBatteryValue(calibratedValue);
        LogUtils.d(TAG, "setCurrentBatteryValue: 电池电量更新为=" + calibratedValue + "%");
    }

    /**
     * 获取当前电池电量
     * @return 当前电池电量（0-100）
     */
    public int getCurrentBatteryValue() {
        int value = mAppConfigBean.getCurrentBatteryValue();
        LogUtils.d(TAG, "getCurrentBatteryValue: 获取电池电量=" + value + "%");
        return value;
    }


    // ======================== 间隔配置方法（持久化存储，直接生效，无弹窗）========================
    /**
     * 设置提醒间隔时间（直接生效，无弹窗，自动校准最小1000ms）
     * @param interval 目标间隔（单位：ms）
     */
    public void setReminderIntervalTime(final int interval) {
        final int calibratedInterval = Math.max(interval, MIN_INTERVAL_TIME);
        if (calibratedInterval == mAppConfigBean.getReminderIntervalTime()) {
            LogUtils.d(TAG, "setReminderIntervalTime: 提醒间隔无变化，无需操作");
            return;
        }
        mAppConfigBean.setReminderIntervalTime(calibratedInterval);
        saveAppConfig();
        LogUtils.d(TAG, "setReminderIntervalTime: 提醒间隔更新为=" + calibratedInterval + "ms");
    }

    /**
     * 获取提醒间隔时间
     * @return 提醒间隔（单位：ms）
     */
    public int getReminderIntervalTime() {
        int interval = mAppConfigBean.getReminderIntervalTime();
        LogUtils.d(TAG, "getReminderIntervalTime: 获取提醒间隔=" + interval + "ms");
        return interval;
    }

    /**
     * 设置电量检测间隔（直接生效，无弹窗，自动校准最小500ms，与RemindThread同步）
     * @param interval 目标间隔（单位：ms）
     */
    public void setBatteryDetectInterval(final int interval) {
        final int calibratedInterval = Math.max(interval, MIN_DETECT_INTERVAL);
        if (calibratedInterval == mAppConfigBean.getBatteryDetectInterval()) {
            LogUtils.d(TAG, "setBatteryDetectInterval: 检测间隔无变化，无需操作");
            return;
        }
        mAppConfigBean.setBatteryDetectInterval(calibratedInterval);
        saveAppConfig();
        LogUtils.d(TAG, "setBatteryDetectInterval: 电量检测间隔更新为=" + calibratedInterval + "ms");
    }

    /**
     * 获取电量检测间隔
     * @return 电量检测间隔（单位：ms）
     */
    public int getBatteryDetectInterval() {
        int interval = mAppConfigBean.getBatteryDetectInterval();
        LogUtils.d(TAG, "getBatteryDetectInterval: 获取电量检测间隔=" + interval + "ms");
        return interval;
    }

	public boolean isServiceEnabled() {
		// 加载服务配置
        ControlCenterServiceBean savedServiceBean = (ControlCenterServiceBean) ControlCenterServiceBean.loadBean(mContext, ControlCenterServiceBean.class);
        if (savedServiceBean != null) {
            return savedServiceBean.isEnableService();
        } else {
            ControlCenterServiceBean.saveBean(mContext, new ControlCenterServiceBean(false));
            return false;
        }
	}

	public void setIsServiceEnabled(boolean isServiceEnabled) {
        ControlCenterServiceBean.saveBean(mContext, new ControlCenterServiceBean(isServiceEnabled));
	}
}

