package cc.winboll.studio.powerbell.models;

/**
 * @Author ZhanGSKen<zhangsken@qq.com>
 * @Date 2024/04/29 17:24:53
 * @Describe 应用运行参数类
 */
import android.os.Parcel;
import android.os.Parcelable;
import android.util.JsonReader;
import android.util.JsonWriter;
import cc.winboll.studio.libappbase.BaseBean;
import java.io.IOException;
import java.io.Serializable;

// 核心修正：新增 Parcelable 接口实现（API30 持久化/Intent 传递必备）
public class AppConfigBean extends BaseBean implements Serializable, Parcelable {

    // 序列化版本号（Serializable 必备，避免反序列化失败）
    private static final long serialVersionUID = 1L;

    transient public static final String TAG = "AppConfigBean";

    // 核心配置字段（保留原有字段，统一状态字段命名）
    boolean isEnableUsageReminder = false; // 耗电提醒开关
    int usageReminderValue = 45;           // 耗电提醒阈值（0-100）
    boolean isEnableChargeReminder = false;// 充电提醒开关
    int chargeReminderValue = 100;         // 充电提醒阈值（0-100）
    int reminderIntervalTime = 5000;       // 铃声提醒间隔（ms，原有）
    boolean isCharging = false;            // 是否充电（状态字段，原有）
    int currentBatteryValue = -1;          // 修正：统一命名为「currentBatteryValue」（原 currentValue）
    int batteryDetectInterval = 2000;      // 新增：电量检测间隔（ms，适配 RemindThread）

    // 构造方法：初始化默认配置（同步修正字段名，统一默认值）
    public AppConfigBean() {
        setChargeReminderValue(100);
        setEnableChargeReminder(false);
        setUsageReminderValue(10);
        setEnableUsageReminder(false);
        setReminderIntervalTime(5000);
        setBatteryDetectInterval(1000); // 新增：默认检测间隔1秒
        setCurrentBatteryValue(-1);     // 修正：初始化当前电量字段
    }

    // ====================== 核心修复：补全缺失方法（适配 RemindThread/Receiver 调用） ======================
    /**
     * 设置当前电池电量（Receiver 监听电池变化时调用，与 RemindThread 字段对齐）
     */
    public void setCurrentBatteryValue(int currentBatteryValue) {
        // 强化校验：电量范围限制在 0-100，异常值置为 -1（标识无效）
        this.currentBatteryValue = (currentBatteryValue >= 0 && currentBatteryValue <= 100) 
			? currentBatteryValue : -1;
    }

    /**
     * 获取当前电池电量（RemindThread 同步配置时调用，与 set 方法对应）
     */
    public int getCurrentBatteryValue() {
        return currentBatteryValue;
    }

    // ====================== 原有字段 Setter/Getter（修正命名，强化校验） ======================
    public void setReminderIntervalTime(int reminderIntervalTime) {
        // 校验：提醒间隔不小于 1000ms，避免频繁提醒
        this.reminderIntervalTime = Math.max(reminderIntervalTime, 1000);
    }

    public int getReminderIntervalTime() {
        return reminderIntervalTime;
    }

    public void setIsCharging(boolean isCharging) { // 修正：方法名与字段名统一（原 setCharging）
        this.isCharging = isCharging;
    }

    public boolean isCharging() {
        return isCharging;
    }

    public void setEnableUsageReminder(boolean isEnableUsageReminder) {
        this.isEnableUsageReminder = isEnableUsageReminder;
    }

    public boolean isEnableUsageReminder() {
        return isEnableUsageReminder;
    }

    public void setUsageReminderValue(int usageReminderValue) {
        // 校验：阈值范围 0-100
        this.usageReminderValue = Math.min(Math.max(usageReminderValue, 0), 100);
    }

    public int getUsageReminderValue() {
        return usageReminderValue;
    }

    public void setEnableChargeReminder(boolean isEnableChargeReminder) {
        this.isEnableChargeReminder = isEnableChargeReminder;
    }

    public boolean isEnableChargeReminder() {
        return isEnableChargeReminder;
    }

    public void setChargeReminderValue(int chargeReminderValue) {
        // 校验：阈值范围 0-100
        this.chargeReminderValue = Math.min(Math.max(chargeReminderValue, 0), 100);
    }

    public int getChargeReminderValue() {
        return chargeReminderValue;
    }

    // ====================== 电量检测间隔 Setter/Getter（适配 RemindThread） ======================
    public int getBatteryDetectInterval() {
        return batteryDetectInterval;
    }

    // 强化校验：检测间隔不小于500ms（避免 CPU 高占用，与 RemindThread 最小休眠一致）
    public void setBatteryDetectInterval(int batteryDetectInterval) {
        this.batteryDetectInterval = Math.max(batteryDetectInterval, 500);
    }

    // ====================== JSON 序列化/反序列化（兼容旧配置，同步修正字段） ======================
    @Override
    public String getName() {
        return AppConfigBean.class.getName();
    }

    @Override
    public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
        super.writeThisToJsonWriter(jsonWriter);
        AppConfigBean bean = this;
        // 原有字段序列化（保留拼写兼容，同步修正字段名）
        jsonWriter.name("isEnableUsageReminder").value(bean.isEnableUsageReminder());
        jsonWriter.name("usageReminderValue").value(bean.getUsageReminderValue());
        jsonWriter.name("isEnableChargeReminder").value(bean.isEnableChargeReminder());
        jsonWriter.name("chargeReminderValue").value(bean.getChargeReminderValue());
        jsonWriter.name("reminderIntervalTime").value(bean.getReminderIntervalTime());
        jsonWriter.name("isCharging").value(bean.isCharging());
        // 修正：序列化新字段名 currentBatteryValue，兼容旧字段 currentValue
        jsonWriter.name("currentBatteryValue").value(bean.getCurrentBatteryValue());
        jsonWriter.name("currentValue").value(bean.getCurrentBatteryValue()); // 兼容旧配置，避免数据丢失
        // 新增字段序列化：电量检测间隔
        jsonWriter.name("batteryDetectInterval").value(bean.getBatteryDetectInterval());
    }

    @Override
    public BaseBean readBeanFromJsonReader(JsonReader jsonReader) throws IOException {
        AppConfigBean bean = new AppConfigBean();
        jsonReader.beginObject();
        while (jsonReader.hasNext()) {
            String name = jsonReader.nextName();
            // 原有字段反序列化（兼容旧 Key 拼写，同步修正字段）
            if (name.equals("isEnableUsageReminder") || name.equals("isEnableUsegeReminder")) {
                bean.setEnableUsageReminder(jsonReader.nextBoolean());
            } else if (name.equals("usageReminderValue") || name.equals("usegeReminderValue")) {
                bean.setUsageReminderValue(jsonReader.nextInt());
            } else if (name.equals("isEnableChargeReminder")) {
                bean.setEnableChargeReminder(jsonReader.nextBoolean());
            } else if (name.equals("chargeReminderValue")) {
                bean.setChargeReminderValue(jsonReader.nextInt());
            } else if (name.equals("reminderIntervalTime")) {
                bean.setReminderIntervalTime(jsonReader.nextInt());
            } else if (name.equals("isCharging")) {
                bean.setIsCharging(jsonReader.nextBoolean()); // 修正：调用新方法名
            } 
            // 核心兼容：优先读取旧字段 currentValue，再读取新字段 currentBatteryValue（新字段覆盖旧字段）
            else if (name.equals("currentValue")) {
                bean.setCurrentBatteryValue(jsonReader.nextInt());
            } else if (name.equals("currentBatteryValue")) {
                bean.setCurrentBatteryValue(jsonReader.nextInt());
            } 
            // 新增字段反序列化（兼容无此字段的旧配置，用默认值1000ms）
            else if (name.equals("batteryDetectInterval")) {
                bean.setBatteryDetectInterval(jsonReader.nextInt());
            } else {
                jsonReader.skipValue();
            }
        }
        jsonReader.endObject();
        return bean;
    }

    // ====================== Parcelable 接口实现（同步修正字段，确保 Intent 传递正常） ======================
    @Override
    public int describeContents() {
        return 0; // 无特殊内容描述，固定返回0
    }

    // 序列化：将所有字段写入 Parcel（同步修正字段名，Java7 适配）
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeByte((byte) (isEnableUsageReminder ? 1 : 0)); // boolean → byte
        dest.writeInt(usageReminderValue);
        dest.writeByte((byte) (isEnableChargeReminder ? 1 : 0)); // boolean → byte
        dest.writeInt(chargeReminderValue);
        dest.writeInt(reminderIntervalTime);
        dest.writeByte((byte) (isCharging ? 1 : 0)); // boolean → byte
        dest.writeInt(currentBatteryValue); // 修正：序列化新字段名
        dest.writeInt(batteryDetectInterval);
    }

    // 反序列化：从 Parcel 读取字段，创建对象（必须 public static final 修饰）
    public static final Parcelable.Creator<AppConfigBean> CREATOR = new Parcelable.Creator<AppConfigBean>() {
        @Override
        public AppConfigBean createFromParcel(Parcel source) {
            AppConfigBean bean = new AppConfigBean();
            // 按 writeToParcel 顺序读取，同步修正字段
            bean.isEnableUsageReminder = source.readByte() != 0;
            bean.usageReminderValue = source.readInt();
            bean.isEnableChargeReminder = source.readByte() != 0;
            bean.chargeReminderValue = source.readInt();
            bean.reminderIntervalTime = source.readInt();
            bean.isCharging = source.readByte() != 0;
            bean.currentBatteryValue = source.readInt(); // 修正：读取新字段名
            bean.batteryDetectInterval = source.readInt();
            return bean;
        }

        @Override
        public AppConfigBean[] newArray(int size) {
            return new AppConfigBean[size];
        }
    };
}

