package cc.winboll.studio.powerbell.views;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.Switch;
import android.widget.TextView;
import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.powerbell.App;
import cc.winboll.studio.powerbell.R;
import cc.winboll.studio.powerbell.models.ControlCenterServiceBean;
import cc.winboll.studio.powerbell.services.ControlCenterService;
import cc.winboll.studio.powerbell.utils.AppConfigUtils;

/**
 * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
 * @Date 2025/12/17 13:14
 * @Describe 主页面核心视图封装类：统一管理视图绑定、数据更新、事件监听，解耦 Activity 逻辑
 * 适配：Java7 | API30 | 小米手机，优化性能与资源回收，杜绝内存泄漏，配置变更确认对话框
 * 新增：拖动进度条时实时预览 sbUsageReminder 与 sbChargeReminder 比值
 */
public class MainContentView {
    // ======================== 静态常量（置顶，唯一标识）========================
    public static final String TAG = "MainContentView";

    // 变更类型常量（区分不同控件，精准处理逻辑）
    private static final int CHANGE_TYPE_CHARGE_SWITCH = 1;
    private static final int CHANGE_TYPE_USAGE_SWITCH = 2;
    private static final int CHANGE_TYPE_SERVICE_SWITCH = 3;
    private static final int CHANGE_TYPE_CHARGE_SEEKBAR = 4;
    private static final int CHANGE_TYPE_USAGE_SEEKBAR = 5;

    // ======================== 内部静态类（临时数据载体，避免外部依赖）========================
    /**
     * 临时配置数据实体（缓存变更信息，取消时恢复）
     */
    private static class TempConfigData {
        int changeType;
        boolean originalBooleanValue;
        int originalIntValue;
        boolean newBooleanValue;
        int newIntValue;

        // 构造方法（开关类型）
        TempConfigData(int changeType, boolean originalValue, boolean newValue) {
            this.changeType = changeType;
            this.originalBooleanValue = originalValue;
            this.newBooleanValue = newValue;
        }

        // 构造方法（进度条类型）
        TempConfigData(int changeType, int originalValue, int newValue) {
            this.changeType = changeType;
            this.originalIntValue = originalValue;
            this.newIntValue = newValue;
        }
    }

    // ======================== 事件回调接口（解耦视图与业务，提升扩展性）========================
    public interface OnViewActionListener {
        void onChargeReminderSwitchChanged(boolean isChecked);
        void onUsageReminderSwitchChanged(boolean isChecked);
        void onServiceSwitchChanged(boolean isChecked);
        void onChargeReminderProgressChanged(int progress);
        void onUsageReminderProgressChanged(int progress);
    }

    // ======================== 成员变量（按功能分类，避免混乱）========================
    // 外部依赖实例（生命周期关联，优先声明）
    private Context mContext;
    private AppConfigUtils mAppConfigUtils;
    private OnViewActionListener mActionListener;

    // 视图控件（按「布局→开关→文本→进度条→图标」功能归类）
    // 基础布局控件
    public RelativeLayout mainLayout;
    public MemoryCachedBackgroundView backgroundView;
	LinearLayout mllBackgroundView;
    // 容器布局控件
    public LinearLayout llLeftSeekBar;
    public LinearLayout llRightSeekBar;
    // 开关控件
    public CheckBox cbEnableChargeReminder;
    public CheckBox cbEnableUsageReminder;
    public Switch swEnableService;
    // 文本显示控件
    public TextView tvTips;
    public TextView tvChargeReminderValue;
    public TextView tvUsageReminderValue;
    public TextView tvCurrentBatteryValue;
    // 进度条控件（使用自定义 VerticalSeekBar）
    public VerticalSeekBar sbChargeReminder;
    public VerticalSeekBar sbUsageReminder;
    // 图标显示控件
    public ImageView ivCurrentBattery;
    public ImageView ivChargeReminderBattery;
    public ImageView ivUsageReminderBattery;

    // 进度缓存（用于实时计算比值，避免频繁调用 getProgress()）
    private int mCurrentChargeProgress;
    private int mCurrentUsageProgress;

    // 内部复用资源（避免重复创建，优化性能）
    private BatteryDrawable mCurrentBatteryDrawable;
    private BatteryDrawable mChargeReminderBatteryDrawable;
    private BatteryDrawable mUsageReminderBatteryDrawable;

    // 配置变更确认对话框（单例复用，避免重复创建）
    private AlertDialog mConfigConfirmDialog;
    private AlertDialog.Builder mDialogBuilder;
    // 临时存储变更数据（对话框确认前缓存，取消时恢复）
    private TempConfigData mTempConfigData;
    // 对话框状态锁（避免快速点击重复弹窗）
    private boolean isDialogShowing = false;

    // ======================== 构造方法（初始化入口，逻辑闭环）========================
    public MainContentView(Context context, View rootView, OnViewActionListener actionListener) {
        LogUtils.d(TAG, "MainContentView() | context=" + context + " | rootView=" + rootView + " | actionListener=" + actionListener);
        // 初始化外部依赖
        this.mContext = context;
        this.mActionListener = actionListener;
        this.mAppConfigUtils = AppConfigUtils.getInstance(context.getApplicationContext());

        // 执行核心初始化流程（按顺序执行，避免依赖空指针）
        bindViews(rootView);
        initBatteryDrawables();
        initConfirmDialog();
        bindViewListeners();

        LogUtils.d(TAG, "MainContentView 初始化完成");
    }

    // ======================== 私有初始化方法（封装内部逻辑，仅暴露入口）========================
    /**
     * 绑定视图控件（显式强转适配 Java7，适配 API30 视图加载机制）
     */
    private void bindViews(View rootView) {
        LogUtils.d(TAG, "bindViews() | rootView=" + rootView);
        // 基础布局绑定
        mainLayout = (RelativeLayout) rootView.findViewById(R.id.activitymainRelativeLayout1);
        //backgroundView = (BackgroundView) rootView.findViewById(R.id.fragmentmainviewBackgroundView1);
        mllBackgroundView = (LinearLayout) rootView.findViewById(R.id.ll_backgroundview);
		backgroundView = App.sMemoryCachedBackgroundView.getLastInstance(mContext);
		if (backgroundView.getParent() != null) {
			((ViewGroup) backgroundView.getParent()).removeView(backgroundView);
		}
		mllBackgroundView.addView(backgroundView);
        // 容器布局绑定
        llLeftSeekBar = (LinearLayout) rootView.findViewById(R.id.fragmentmainviewLinearLayout1);
        llRightSeekBar = (LinearLayout) rootView.findViewById(R.id.fragmentmainviewLinearLayout2);
        // 开关控件绑定
        cbEnableChargeReminder = (CheckBox) rootView.findViewById(R.id.fragmentmainviewCheckBox1);
        cbEnableUsageReminder = (CheckBox) rootView.findViewById(R.id.fragmentmainviewCheckBox2);
        swEnableService = (Switch) rootView.findViewById(R.id.fragmentandroidviewSwitch1);
        // 文本控件绑定
        tvTips = (TextView) rootView.findViewById(R.id.fragmentandroidviewTextView1);
        tvChargeReminderValue = (TextView) rootView.findViewById(R.id.fragmentandroidviewTextView2);
        tvUsageReminderValue = (TextView) rootView.findViewById(R.id.fragmentandroidviewTextView3);
        tvCurrentBatteryValue = (TextView) rootView.findViewById(R.id.fragmentandroidviewTextView4);
        // 进度条控件绑定（自定义 VerticalSeekBar）
        sbChargeReminder = (VerticalSeekBar) rootView.findViewById(R.id.fragmentandroidviewVerticalSeekBar1);
        sbUsageReminder = (VerticalSeekBar) rootView.findViewById(R.id.fragmentandroidviewVerticalSeekBar2);
        // 图标控件绑定
        ivCurrentBattery = (ImageView) rootView.findViewById(R.id.fragmentandroidviewImageView1);
        ivChargeReminderBattery = (ImageView) rootView.findViewById(R.id.fragmentandroidviewImageView3);
        ivUsageReminderBattery = (ImageView) rootView.findViewById(R.id.fragmentandroidviewImageView2);

        // 初始化进度缓存（从配置读取初始值）
        mCurrentChargeProgress = mAppConfigUtils.getChargeReminderValue();
        mCurrentUsageProgress = mAppConfigUtils.getUsageReminderValue();

        // 关键视图绑定校验（仅保留核心控件错误日志，精简冗余）
        if (mainLayout == null) LogUtils.e(TAG, "mainLayout 绑定失败");
        if (backgroundView == null) LogUtils.e(TAG, "backgroundView 绑定失败");
    }

    /**
     * 初始化电池 Drawable（集成 BatteryDrawable，默认能量风格，适配小米机型渲染）
     */
    private void initBatteryDrawables() {
        LogUtils.d(TAG, "initBatteryDrawables()");
        // 当前电量 Drawable（颜色从资源读取，适配 API30 主题）
        int colorCurrent = getResourceColor(R.color.colorCurrent);
        mCurrentBatteryDrawable = new BatteryDrawable(colorCurrent);
        // 充电提醒 Drawable
        int colorCharge = getResourceColor(R.color.colorCharge);
        mChargeReminderBatteryDrawable = new BatteryDrawable(colorCharge);
        // 耗电提醒 Drawable
        int colorUsage = getResourceColor(R.color.colorUsege);
        mUsageReminderBatteryDrawable = new BatteryDrawable(colorUsage);
    }

    /**
     * 初始化配置变更确认对话框（核心优化：保存 Builder 实例，解决消息不生效问题）
     */
    private void initConfirmDialog() {
        LogUtils.d(TAG, "initConfirmDialog()");
        if (mContext == null) {
            LogUtils.e(TAG, "Context 为空，初始化失败");
            return;
        }

        // 1. 初始化 Builder（核心：后续通过 Builder 更新消息）
        mDialogBuilder = new AlertDialog.Builder(mContext);
        mDialogBuilder.setTitle("配置变更确认");
        mDialogBuilder.setMessage("是否确认修改当前配置？");

        // 确定按钮：保存配置+回调+更新视图
        mDialogBuilder.setPositiveButton("确定", new DialogInterface.OnClickListener() {
				@Override
				public void onClick(DialogInterface dialog, int which) {
					confirmConfigChange();
					dialog.dismiss();
				}
			});

        // 取消按钮：恢复原始配置（补充物理取消按钮，提升用户体验）
        mDialogBuilder.setNegativeButton("取消", new DialogInterface.OnClickListener() {
				@Override
				public void onClick(DialogInterface dialog, int which) {
					cancelConfigChange();
					dialog.dismiss();
				}
			});

        // 对话框外部点击监听：关闭对话框+恢复原始配置
        mDialogBuilder.setOnCancelListener(new DialogInterface.OnCancelListener() {
				@Override
				public void onCancel(DialogInterface dialog) {
					cancelConfigChange();
					dialog.dismiss();
				}
			});

        // 2. 初始化对话框实例（设置可取消，支持外部点击关闭）
        mConfigConfirmDialog = mDialogBuilder.create();
        mConfigConfirmDialog.setCancelable(true);
        mConfigConfirmDialog.setCanceledOnTouchOutside(true);
    }

    /**
     * 绑定视图事件监听（Java7 显式实现接口，适配 API30 事件分发，修复进度条弹窗失效）
     */
    private void bindViewListeners() {
        LogUtils.d(TAG, "bindViewListeners()");
        // 依赖校验，避免空指针
        if (mAppConfigUtils == null || mActionListener == null || mConfigConfirmDialog == null) {
            LogUtils.e(TAG, "依赖实例为空，跳过监听绑定");
            return;
        }

        // 充电提醒进度条监听（使用 VerticalSeekBar 专属接口，确保弹窗100%触发）
        if (sbChargeReminder != null) {
            // 原有：触摸抬起/取消监听（用于配置确认）
            sbChargeReminder.setOnVerticalSeekBarTouchListener(new VerticalSeekBar.OnVerticalSeekBarTouchListener() {
					@Override
					public void onTouchUp(VerticalSeekBar seekBar, int progress) {
						int originalValue = mAppConfigUtils.getChargeReminderValue();
						// 进度无变化，不处理
						if (originalValue == progress) {
							LogUtils.d(TAG, "ChargeReminderSeekBar: 进度无变化，跳过");
							return;
						}
						// 缓存变更数据，显示确认对话框
						mTempConfigData = new TempConfigData(CHANGE_TYPE_CHARGE_SEEKBAR, originalValue, progress);
						updateDialogMessageByChangeType();
						showConfigConfirmDialog();
						LogUtils.d(TAG, "ChargeReminderSeekBar触摸抬起 | 原始值=" + originalValue + " | 新进度=" + progress);
					}

					@Override
					public void onTouchCancel(VerticalSeekBar seekBar, int progress) {
						// 触摸取消，回滚视图进度（UI 与配置保持一致）
						int originalValue = mAppConfigUtils.getChargeReminderValue();
						if (tvChargeReminderValue != null && mChargeReminderBatteryDrawable != null && ivChargeReminderBattery != null) {
							mChargeReminderBatteryDrawable.setBatteryValue(originalValue);
							ivChargeReminderBattery.setImageDrawable(mChargeReminderBatteryDrawable);
							tvChargeReminderValue.setText(originalValue + "%");
						}
						seekBar.setProgress(originalValue);
						// 恢复进度缓存
						mCurrentChargeProgress = originalValue;
						LogUtils.d(TAG, "ChargeReminderSeekBar触摸取消 | 进度回滚至=" + originalValue);
					}
				});

            // 新增：实时进度变化监听（用于比值预览）
            sbChargeReminder.setOnVerticalSeekBarChangeListener(new VerticalSeekBar.OnVerticalSeekBarChangeListener() {
					@Override
					public void onProgressChanged(VerticalSeekBar seekBar, int progress, boolean fromUser) {
						if (fromUser) {
							mCurrentChargeProgress = progress;
							// 同步更新进度文本和电池图标（保持UI一致性）
							if (tvChargeReminderValue != null && mChargeReminderBatteryDrawable != null && ivChargeReminderBattery != null) {
								mChargeReminderBatteryDrawable.setBatteryValue(progress);
								ivChargeReminderBattery.setImageDrawable(mChargeReminderBatteryDrawable);
								tvChargeReminderValue.setText(progress + "%");
							}
						}
					}

					@Override
					public void onStartTrackingTouch(VerticalSeekBar seekBar) {}

					@Override
					public void onStopTrackingTouch(VerticalSeekBar seekBar) {}
				});
            LogUtils.d(TAG, "充电提醒进度条专属监听绑定完成");
        }

        // 充电提醒开关监听
        if (cbEnableChargeReminder != null) {
            cbEnableChargeReminder.setOnClickListener(new View.OnClickListener() {
					@Override
					public void onClick(View v) {
						boolean originalValue = mAppConfigUtils.isChargeReminderEnabled();
						boolean newValue = cbEnableChargeReminder.isChecked();
						// 状态无变化，不处理
						if (originalValue == newValue) return;
						// 缓存变更数据，显示确认对话框
						mTempConfigData = new TempConfigData(CHANGE_TYPE_CHARGE_SWITCH, originalValue, newValue);
						updateDialogMessageByChangeType();
						showConfigConfirmDialog();
						LogUtils.d(TAG, "cbEnableChargeReminder点击 | 原始值=" + originalValue + " | 变更后=" + newValue);
					}
				});
            LogUtils.d(TAG, "充电提醒开关监听绑定完成");
        }

        // 耗电提醒进度条监听（使用 VerticalSeekBar 专属接口，确保弹窗100%触发）
        if (sbUsageReminder != null) {
            // 原有：触摸抬起/取消监听（用于配置确认）
            sbUsageReminder.setOnVerticalSeekBarTouchListener(new VerticalSeekBar.OnVerticalSeekBarTouchListener() {
					@Override
					public void onTouchUp(VerticalSeekBar seekBar, int progress) {
						int originalValue = mAppConfigUtils.getUsageReminderValue();
						// 进度无变化，不处理
						if (originalValue == progress) {
							LogUtils.d(TAG, "UsageReminderSeekBar: 进度无变化，跳过");
							return;
						}
						// 缓存变更数据，显示确认对话框
						mTempConfigData = new TempConfigData(CHANGE_TYPE_USAGE_SEEKBAR, originalValue, progress);
						updateDialogMessageByChangeType();
						showConfigConfirmDialog();
						LogUtils.d(TAG, "UsageReminderSeekBar触摸抬起 | 原始值=" + originalValue + " | 新进度=" + progress);
					}

					@Override
					public void onTouchCancel(VerticalSeekBar seekBar, int progress) {
						// 触摸取消，回滚视图进度（UI 与配置保持一致）
						int originalValue = mAppConfigUtils.getUsageReminderValue();
						if (tvUsageReminderValue != null && mUsageReminderBatteryDrawable != null && ivUsageReminderBattery != null) {
							mUsageReminderBatteryDrawable.setBatteryValue(originalValue);
							ivUsageReminderBattery.setImageDrawable(mUsageReminderBatteryDrawable);
							tvUsageReminderValue.setText(originalValue + "%");
						}
						seekBar.setProgress(originalValue);
						// 恢复进度缓存
						mCurrentUsageProgress = originalValue;
						LogUtils.d(TAG, "UsageReminderSeekBar触摸取消 | 进度回滚至=" + originalValue);
					}
				});

            // 新增：实时进度变化监听（用于比值预览）
            sbUsageReminder.setOnVerticalSeekBarChangeListener(new VerticalSeekBar.OnVerticalSeekBarChangeListener() {
					@Override
					public void onProgressChanged(VerticalSeekBar seekBar, int progress, boolean fromUser) {
						if (fromUser) {
							mCurrentUsageProgress = progress;
							// 同步更新进度文本和电池图标（保持UI一致性）
							if (tvUsageReminderValue != null && mUsageReminderBatteryDrawable != null && ivUsageReminderBattery != null) {
								mUsageReminderBatteryDrawable.setBatteryValue(progress);
								ivUsageReminderBattery.setImageDrawable(mUsageReminderBatteryDrawable);
								tvUsageReminderValue.setText(progress + "%");
							}
						}
					}

					@Override
					public void onStartTrackingTouch(VerticalSeekBar seekBar) {}

					@Override
					public void onStopTrackingTouch(VerticalSeekBar seekBar) {}
				});
            LogUtils.d(TAG, "耗电提醒进度条专属监听绑定完成");
        }

        // 耗电提醒开关监听
        if (cbEnableUsageReminder != null) {
            cbEnableUsageReminder.setOnClickListener(new View.OnClickListener() {
					@Override
					public void onClick(View v) {
						boolean originalValue = mAppConfigUtils.isUsageReminderEnabled();
						boolean newValue = cbEnableUsageReminder.isChecked();
						// 状态无变化，不处理
						if (originalValue == newValue) return;
						// 缓存变更数据，显示确认对话框
						mTempConfigData = new TempConfigData(CHANGE_TYPE_USAGE_SWITCH, originalValue, newValue);
						updateDialogMessageByChangeType();
						showConfigConfirmDialog();
						LogUtils.d(TAG, "cbEnableUsageReminder点击 | 原始值=" + originalValue + " | 变更后=" + newValue);
					}
				});
            LogUtils.d(TAG, "耗电提醒开关监听绑定完成");
        }

        // 服务总开关监听（核心优化：逻辑与其他控件完全对齐）
        if (swEnableService != null) {
            swEnableService.setOnClickListener(new View.OnClickListener() {
					@Override
					public void onClick(View v) {
						// 从服务控制Bean读取原始状态，确保与实际一致
						boolean originalValue = getServiceEnableState();
						boolean newValue = ((Switch) v).isChecked();
						// 状态无变化，不处理
						if (originalValue == newValue) return;
						// 缓存变更数据
						mTempConfigData = new TempConfigData(CHANGE_TYPE_SERVICE_SWITCH, originalValue, newValue);
						// 更新差异化提示语
						updateDialogMessageByChangeType();
						// 显示确认对话框
						showConfigConfirmDialog();
						LogUtils.d(TAG, "swEnableService点击 | 原始值=" + originalValue + " | 变更后=" + newValue);
					}
				});
            LogUtils.d(TAG, "服务总开关监听绑定完成");
        }

        LogUtils.d(TAG, "所有事件监听绑定完成");
    }

    // ======================== 对外暴露核心方法（业务入口，精简参数，明确职责）========================
    /**
     * 更新所有视图数据（从配置读取数据，统一刷新 UI，适配 API30 视图更新规范）
     * @param frameDrawable 进度条背景 Drawable（外部传入，适配主题切换）
     */
    public void updateViewData(Drawable frameDrawable) {
        LogUtils.d(TAG, "updateViewData() | frameDrawable=" + frameDrawable);
        if (mAppConfigUtils == null) {
            LogUtils.e(TAG, "AppConfigUtils 为空，跳过更新");
            return;
        }

        // 一次读取所有配置参数，减少工具类调用，提升性能
        int chargeVal = mAppConfigUtils.getChargeReminderValue();
        int usageVal = mAppConfigUtils.getUsageReminderValue();
        int currentVal = mAppConfigUtils.getCurrentBatteryValue();
        boolean chargeEnable = mAppConfigUtils.isChargeReminderEnabled();
        boolean usageEnable = mAppConfigUtils.isUsageReminderEnabled();
        // 从服务控制Bean读取状态，确保UI与实际一致
        boolean serviceEnable = getServiceEnableState();
        // 更新进度缓存
        mCurrentChargeProgress = chargeVal;
        mCurrentUsageProgress = usageVal;
        LogUtils.d(TAG, "配置数据读取完成 | charge=" + chargeVal + " | usage=" + usageVal + " | current=" + currentVal + " | serviceEnable=" + serviceEnable);

        // 进度条背景更新
        if (frameDrawable != null) {
            if (llLeftSeekBar != null) llLeftSeekBar.setBackground(frameDrawable);
            if (llRightSeekBar != null) llRightSeekBar.setBackground(frameDrawable);
        }

        // 当前电量更新（联动 BatteryDrawable，实时刷新图标）
        if (ivCurrentBattery != null && mCurrentBatteryDrawable != null) {
            mCurrentBatteryDrawable.setBatteryValue(currentVal);
            ivCurrentBattery.setImageDrawable(mCurrentBatteryDrawable);
        }
        if (tvCurrentBatteryValue != null) {
            tvCurrentBatteryValue.setTextColor(getResourceColor(R.color.colorCurrent));
            tvCurrentBatteryValue.setText(currentVal + "%");
        }

        // 充电提醒视图更新
        if (ivChargeReminderBattery != null && mChargeReminderBatteryDrawable != null) {
            mChargeReminderBatteryDrawable.setBatteryValue(chargeVal);
            ivChargeReminderBattery.setImageDrawable(mChargeReminderBatteryDrawable);
        }
        if (tvChargeReminderValue != null) {
            tvChargeReminderValue.setTextColor(getResourceColor(R.color.colorCharge));
            tvChargeReminderValue.setText(chargeVal + "%");
        }
        if (sbChargeReminder != null) sbChargeReminder.setProgress(chargeVal);
        if (cbEnableChargeReminder != null) cbEnableChargeReminder.setChecked(chargeEnable);

        // 耗电提醒视图更新
        if (ivUsageReminderBattery != null && mUsageReminderBatteryDrawable != null) {
            mUsageReminderBatteryDrawable.setBatteryValue(usageVal);
            ivUsageReminderBattery.setImageDrawable(mUsageReminderBatteryDrawable);
        }
        if (tvUsageReminderValue != null) {
            tvUsageReminderValue.setTextColor(getResourceColor(R.color.colorUsege));
            tvUsageReminderValue.setText(usageVal + "%");
        }
        if (sbUsageReminder != null) sbUsageReminder.setProgress(usageVal);
        if (cbEnableUsageReminder != null) cbEnableUsageReminder.setChecked(usageEnable);

        // 服务开关+提示文本更新（确保状态准确）
        if (swEnableService != null) {
            swEnableService.setChecked(serviceEnable);
            swEnableService.setText(mContext.getString(R.string.txt_aboveswitch));
        }
        if (tvTips != null) tvTips.setText(mContext.getString(R.string.txt_aboveswitchtips));

        LogUtils.d(TAG, "所有视图数据更新完成");
    }

    /**
     * 实时更新当前电量（单独抽离，适配电池实时监控场景，优化 API30 UI 响应速度）
     * @param value 电量值（自动校准 0-100，避免异常值）
     */
    public void updateCurrentBattery(int value) {
        LogUtils.d(TAG, "updateCurrentBattery() | 原始值=" + value);
        // 核心依赖校验
        if (tvCurrentBatteryValue == null || mCurrentBatteryDrawable == null || ivCurrentBattery == null) {
            LogUtils.e(TAG, "视图/Drawable 为空，跳过更新");
            return;
        }

        // 校准电量范围（强制 0-100，防止 API30 视图显示异常）
        int validValue = Math.max(0, Math.min(value, 100));
        // 联动 BatteryDrawable 更新图标，同步文本显示
        mCurrentBatteryDrawable.setBatteryValue(validValue);
        ivCurrentBattery.setImageDrawable(mCurrentBatteryDrawable);
        tvCurrentBatteryValue.setText(validValue + "%");

        LogUtils.d(TAG, "更新完成 | 校准后值=" + validValue);
    }

    /**
     * 释放资源（主动回收，适配 API30 资源管控机制，优化小米手机内存占用）
     */
    public void releaseResources() {
        LogUtils.d(TAG, "releaseResources()");
        // 释放对话框资源（安全销毁，避免内存泄漏）
        if (mConfigConfirmDialog != null) {
            if (mConfigConfirmDialog.isShowing()) {
                mConfigConfirmDialog.dismiss();
            }
            mConfigConfirmDialog.setOnDismissListener(null);
            mConfigConfirmDialog.setOnCancelListener(null);
            mConfigConfirmDialog = null;
        }
        // 释放 Builder
        mDialogBuilder = null;
        // 释放临时数据
        mTempConfigData = null;

        // 释放 BatteryDrawable 资源（重点回收绘制资源，避免 OOM）
        mCurrentBatteryDrawable = null;
        mChargeReminderBatteryDrawable = null;
        mUsageReminderBatteryDrawable = null;

        // 置空视图实例（断开视图引用，辅助 GC 回收）
        mainLayout = null;
        backgroundView = null;
        llLeftSeekBar = null;
        llRightSeekBar = null;
        cbEnableChargeReminder = null;
        cbEnableUsageReminder = null;
        swEnableService = null;
        tvTips = null;
        tvChargeReminderValue = null;
        tvUsageReminderValue = null;
        tvCurrentBatteryValue = null;
        sbChargeReminder = null;
        sbUsageReminder = null;
        ivCurrentBattery = null;
        ivChargeReminderBattery = null;
        ivUsageReminderBattery = null;

        // 置空外部依赖（断开生命周期关联，杜绝内存泄漏）
        mContext = null;
        mAppConfigUtils = null;
        mActionListener = null;

        LogUtils.d(TAG, "所有资源释放完成");
    }

    /**
     * 设置服务开关启用状态（外部调用，同步 UI 与服务状态，适配 Activity 视图刷新）
     * @param enabled 服务启用状态
     */
    public void setServiceSwitchChecked(boolean enabled) {
        LogUtils.d(TAG, "setServiceSwitchChecked() | enabled=" + enabled);
        if (swEnableService != null) {
            swEnableService.setChecked(enabled);
        }
    }

    /**
     * 设置服务开关点击状态（外部调用，避免更新 UI 时触发重复回调）
     * @param enabled 是否允许点击
     */
    public void setServiceSwitchEnabled(boolean enabled) {
        LogUtils.d(TAG, "setServiceSwitchEnabled() | enabled=" + enabled);
        if (swEnableService != null) {
            swEnableService.setEnabled(enabled);
        }
    }

    // ======================== 内部核心逻辑方法（对话框相关，封装确认/取消逻辑）========================
    /**
     * 显示配置变更确认对话框（确保 Activity 处于前台，避免异常，防止重复弹窗）
     */
    private void showConfigConfirmDialog() {
        LogUtils.d(TAG, "showConfigConfirmDialog() | isDialogShowing=" + isDialogShowing);
        // 对话框状态锁：正在显示则跳过，避免重复触发
        if (isDialogShowing) {
            LogUtils.d(TAG, "对话框已显示，跳过重复调用");
            return;
        }
        // 基础校验：对话框/上下文/Builder 为空
        if (mDialogBuilder == null || mContext == null) {
            LogUtils.e(TAG, "对话框Builder/上下文异常，无法显示");
            if (mTempConfigData != null) cancelConfigChange();
            return;
        }
        // Activity 状态校验：避免销毁后弹窗崩溃（适配 API30）
        Activity activity = (Activity) mContext;
        if (activity.isFinishing() || activity.isDestroyed()) {
            LogUtils.e(TAG, "Activity 已销毁，无法显示对话框");
            if (mTempConfigData != null) cancelConfigChange();
            return;
        }
        // 重新构建对话框（核心：确保最新消息生效）
        mConfigConfirmDialog = mDialogBuilder.create();
        // 显示对话框，设置状态锁+关闭监听
        mConfigConfirmDialog.show();
        isDialogShowing = true;
        // 对话框关闭时解锁
        mConfigConfirmDialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
				@Override
				public void onDismiss(DialogInterface dialog) {
					isDialogShowing = false;
					mConfigConfirmDialog.setOnDismissListener(null);
				}
			});
        LogUtils.d(TAG, "确认对话框显示成功");
    }

    /**
     * 确认配置变更（保存数据+回调监听+更新视图）
     */
    private void confirmConfigChange() {
        LogUtils.d(TAG, "confirmConfigChange() | mTempConfigData=" + mTempConfigData);
        if (mTempConfigData == null || mAppConfigUtils == null || mActionListener == null) {
            LogUtils.e(TAG, "依赖数据为空，确认失败");
            return;
        }

        switch (mTempConfigData.changeType) {
				// 充电提醒开关
            case CHANGE_TYPE_CHARGE_SWITCH:
                mAppConfigUtils.setChargeReminderEnabled(mTempConfigData.newBooleanValue);
                mActionListener.onChargeReminderSwitchChanged(mTempConfigData.newBooleanValue);
                LogUtils.d(TAG, "充电提醒开关确认 | 值=" + mTempConfigData.newBooleanValue);
                break;
				// 耗电提醒开关
            case CHANGE_TYPE_USAGE_SWITCH:
                mAppConfigUtils.setUsageReminderEnabled(mTempConfigData.newBooleanValue);
                mActionListener.onUsageReminderSwitchChanged(mTempConfigData.newBooleanValue);
                LogUtils.d(TAG, "耗电提醒开关确认 | 值=" + mTempConfigData.newBooleanValue);
                break;
				// 服务总开关（核心：持久化配置+触发 Activity 回调）
            case CHANGE_TYPE_SERVICE_SWITCH:
                // 1. 设置服务启停
                if (mTempConfigData.newBooleanValue) {
                    ControlCenterService.startControlCenterService(mContext);
                } else {
                    ControlCenterService.stopControlCenterService(mContext);
                }
                // 2. 强制触发 Activity 回调，执行服务启停逻辑
                mActionListener.onServiceSwitchChanged(mTempConfigData.newBooleanValue);
                LogUtils.d(TAG, "服务开关确认 | 值=" + mTempConfigData.newBooleanValue + "，已持久化配置");
                break;
				// 充电提醒进度条
            case CHANGE_TYPE_CHARGE_SEEKBAR:
                mAppConfigUtils.setChargeReminderValue(mTempConfigData.newIntValue);
                mActionListener.onChargeReminderProgressChanged(mTempConfigData.newIntValue);
                LogUtils.d(TAG, "充电提醒进度确认 | 值=" + mTempConfigData.newIntValue);
                break;
				// 耗电提醒进度条
            case CHANGE_TYPE_USAGE_SEEKBAR:
                mAppConfigUtils.setUsageReminderValue(mTempConfigData.newIntValue);
                mActionListener.onUsageReminderProgressChanged(mTempConfigData.newIntValue);
                LogUtils.d(TAG, "耗电提醒进度确认 | 值=" + mTempConfigData.newIntValue);
                break;
            default:
                LogUtils.w(TAG, "未知变更类型，跳过");
                break;
        }

        // 确认完成，清空临时数据
        mTempConfigData = null;
    }

    /**
     * 取消配置变更（恢复原始值+刷新视图，确保 UI 与配置一致）
     */
    private void cancelConfigChange() {
        LogUtils.d(TAG, "cancelConfigChange() | mTempConfigData=" + mTempConfigData);
        if (mTempConfigData == null || mAppConfigUtils == null) {
            LogUtils.e(TAG, "依赖数据为空，取消失败");
            return;
        }

        switch (mTempConfigData.changeType) {
            case CHANGE_TYPE_CHARGE_SWITCH:
                if (cbEnableChargeReminder != null) {
                    cbEnableChargeReminder.setChecked(mTempConfigData.originalBooleanValue);
                }
                LogUtils.d(TAG, "充电提醒开关取消 | 恢复值=" + mTempConfigData.originalBooleanValue);
                break;
            case CHANGE_TYPE_USAGE_SWITCH:
                if (cbEnableUsageReminder != null) {
                    cbEnableUsageReminder.setChecked(mTempConfigData.originalBooleanValue);
                }
                LogUtils.d(TAG, "耗电提醒开关取消 | 恢复值=" + mTempConfigData.originalBooleanValue);
                break;
            case CHANGE_TYPE_SERVICE_SWITCH:
                if (swEnableService != null) {
                    swEnableService.setChecked(mTempConfigData.originalBooleanValue);
                }
                LogUtils.d(TAG, "服务开关取消 | 恢复值=" + mTempConfigData.originalBooleanValue);
                break;
            case CHANGE_TYPE_CHARGE_SEEKBAR:
                if (sbChargeReminder != null) {
                    sbChargeReminder.setProgress(mTempConfigData.originalIntValue);
                }
                if (tvChargeReminderValue != null && mChargeReminderBatteryDrawable != null && ivChargeReminderBattery != null) {
                    mChargeReminderBatteryDrawable.setBatteryValue(mTempConfigData.originalIntValue);
                    ivChargeReminderBattery.setImageDrawable(mChargeReminderBatteryDrawable);
                    tvChargeReminderValue.setText(mTempConfigData.originalIntValue + "%");
                }
                LogUtils.d(TAG, "充电提醒进度取消 | 恢复值=" + mTempConfigData.originalIntValue);
                break;
            case CHANGE_TYPE_USAGE_SEEKBAR:
                if (sbUsageReminder != null) {
                    sbUsageReminder.setProgress(mTempConfigData.originalIntValue);
                }
                if (tvUsageReminderValue != null && mUsageReminderBatteryDrawable != null && ivUsageReminderBattery != null) {
                    mUsageReminderBatteryDrawable.setBatteryValue(mTempConfigData.originalIntValue);
                    ivUsageReminderBattery.setImageDrawable(mUsageReminderBatteryDrawable);
                    tvUsageReminderValue.setText(mTempConfigData.originalIntValue + "%");
                }
                LogUtils.d(TAG, "耗电提醒进度取消 | 恢复值=" + mTempConfigData.originalIntValue);
                break;
            default:
                LogUtils.w(TAG, "未知变更类型，跳过");
                break;
        }

        // 取消完成，清空临时数据
        mTempConfigData = null;
    }

    /**
     * 根据变更类型更新对话框提示语（核心优化：通过 Builder 更新，确保生效）
     */
    private void updateDialogMessageByChangeType() {
        LogUtils.d(TAG, "updateDialogMessageByChangeType() | mTempConfigData=" + mTempConfigData);
        if (mDialogBuilder == null || mTempConfigData == null) return;
        String message;
        if (mTempConfigData.changeType == CHANGE_TYPE_SERVICE_SWITCH) {
            // 服务开关差异化提示语
            message = mTempConfigData.newBooleanValue ?
				"启用服务后，将后台持续监控电池状态，是否确认？" :
				"禁用服务后，电池监控功能将停止，是否确认？";
        } else {
            // 普通配置默认提示语
            message = "是否确认修改当前配置？";
        }
        // 通过 Builder 设置消息，确保弹窗显示最新内容
        mDialogBuilder.setMessage(message);
    }

    // ======================== 内部工具方法（封装重复逻辑，提升复用性）========================
    /**
     * 实时计算并更新比值预览（sbUsageReminder / sbChargeReminder）
     * 处理除数为0的情况，避免崩溃
     */
//    private void updateRatioPreview() {
//        if (mTvRatioPreview == null) return;
//        float ratio;
//        // 处理除数为0：充电进度为0时显示0（可根据需求改为“--”）
//        if (mCurrentChargeProgress == 0) {
//            ratio = 0.0f;
//        } else {
//            ratio = (float) mCurrentUsageProgress / mCurrentChargeProgress;
//        }
//        // 格式化比值：保留1位小数，适配本地化（解决小米手机小数分隔符问题）
//        String ratioText = String.format(Locale.getDefault(), "比值：%.1f", ratio);
//        mTvRatioPreview.setText(ratioText);
//        // 触发比值变化回调
//        if (mActionListener != null) {
//            mActionListener.onRatioChanged(ratio);
//        }
//        LogUtils.d(TAG, "比值预览更新 | usage=" + mCurrentUsageProgress + " | charge=" + mCurrentChargeProgress + " | ratio=" + ratio);
//    }

    /**
     * 获取资源颜色（适配 API30 主题颜色读取机制，兼容低版本，优化小米机型颜色显示，防御空指针）
     * @param colorResId 颜色资源 ID
     * @return 校准后的颜色值
     */
    private int getResourceColor(int colorResId) {
        LogUtils.d(TAG, "getResourceColor() | colorResId=" + colorResId);
        // 空指针防御：Context 为空返回默认黑色
        if (mContext == null) {
            LogUtils.e(TAG, "Context 为空，返回默认黑色");
            return 0xFF000000;
        }
        // 适配 API30 主题颜色读取
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            return mContext.getResources().getColor(colorResId, mContext.getTheme());
        } else {
            return mContext.getResources().getColor(colorResId);
        }
    }

    /**
     * 获取服务启用状态（统一从服务控制Bean读取，确保全链路状态一致）
     * @return 服务启用状态（true=启用，false=禁用）
     */
    private boolean getServiceEnableState() {
        LogUtils.d(TAG, "getServiceEnableState()");
        ControlCenterServiceBean serviceBean = ControlCenterServiceBean.loadBean(mContext, ControlCenterServiceBean.class);
        // 本地无配置时，默认禁用服务（与服务初始化逻辑对齐）
        boolean state = serviceBean != null && serviceBean.isEnableService();
        LogUtils.d(TAG, "服务启用状态获取完成 | state=" + state);
        return state;
    }
}

