package cc.winboll.studio.powerbell.models;

import android.util.JsonReader;
import android.util.JsonWriter;
import cc.winboll.studio.libappbase.BaseBean;
import java.io.IOException;
import java.io.Serializable;

/**
 * @Author ZhanGSKen<zhangsken@qq.com>
 * @Date 2024/07/18 11:52:28
 * @Describe 应用背景图片数据类（存储正式/预览背景配置，支持JSON序列化/反序列化）
 */
public class BackgroundBean extends BaseBean implements Serializable {

    public static final String TAG = "BackgroundPictureBean";

    // 核心字段：背景图片文件名（对应应用私有目录下的图片文件，与BackgroundSettingsActivity的_mSourceCroppedFile匹配）
    private String backgroundFileName = "";
    // 核心字段：背景图片完整路径（解决仅存文件名导致的路径拼接错误，与backgroundScaledCompressFilePath对应）
    private String backgroundFilePath = "";
    // 附加字段：图片信息（如Uri、网络地址等，仅作备注，不参与路径生成）
    private String backgroundFileInfo = "";
    // 控制字段：是否启用背景图片（true-显示背景图，false-显示透明背景）
    private boolean isUseBackgroundFile = false;
    // 核心字段：压缩后背景图片文件名（对应应用私有目录下的压缩图片，与saveCropBitmap的压缩图匹配）
    private String backgroundScaledCompressFileName = "";
    // 核心字段：压缩后背景图片完整路径（解决仅存文件名导致的路径拼接错误，适配BackgroundSettingsActivity的私有目录）
    private String backgroundScaledCompressFilePath = "";
    // 重命名字段：是否启用压缩背景图（原isUseScaledCompress → 新isUseBackgroundScaledCompressFile，语义更清晰）
    private boolean isUseBackgroundScaledCompressFile = false;
    // 裁剪比例字段：背景图宽高比（默认1:1，用于固定比例裁剪）
    private int backgroundWidth = 100;
    private int backgroundHeight = 100;
    // 像素拾取字段：拾取的像素颜色（用于纯色背景）
    private int pixelColor = 0;

    /**
     * 无参构造器（必须，JSON反序列化时需默认构造器）
     */
    public BackgroundBean() {
    }

    // ====================================== Getter/Setter 方法（全字段，含重命名+新增字段）======================================
    public String getBackgroundFileName() {
        return backgroundFileName;
    }

    public void setBackgroundFileName(String backgroundFileName) {
        this.backgroundFileName = backgroundFileName == null ? "" : backgroundFileName; // 防null，避免空指针
    }

    public String getBackgroundFilePath() {
        return backgroundFilePath;
    }

    public void setBackgroundFilePath(String backgroundFilePath) {
        this.backgroundFilePath = backgroundFilePath == null ? "" : backgroundFilePath; // 防null，避免路径拼接错误
    }

    public String getBackgroundFileInfo() {
        return backgroundFileInfo;
    }

    public void setBackgroundFileInfo(String backgroundFileInfo) {
        this.backgroundFileInfo = backgroundFileInfo == null ? "" : backgroundFileInfo; // 防null，避免空指针
    }

    public boolean isUseBackgroundFile() {
        return isUseBackgroundFile;
    }

    public void setIsUseBackgroundFile(boolean isUseBackgroundFile) {
        this.isUseBackgroundFile = isUseBackgroundFile;
    }

    public String getBackgroundScaledCompressFileName() {
        return backgroundScaledCompressFileName;
    }

    public void setBackgroundScaledCompressFileName(String backgroundScaledCompressFileName) {
        this.backgroundScaledCompressFileName = backgroundScaledCompressFileName == null ? "" : backgroundScaledCompressFileName; // 防null
    }

    public String getBackgroundScaledCompressFilePath() {
        return backgroundScaledCompressFilePath;
    }

    public void setBackgroundScaledCompressFilePath(String backgroundScaledCompressFilePath) {
        this.backgroundScaledCompressFilePath = backgroundScaledCompressFilePath == null ? "" : backgroundScaledCompressFilePath; // 防null，避免路径错误
    }

    /**
     * 重命名：原isUseScaledCompress → 新isUseBackgroundScaledCompressFile（Getter/Setter同步修改）
     * 语义：明确表示“是否启用背景压缩图文件”，避免与其他压缩逻辑混淆
     */
    public boolean isUseBackgroundScaledCompressFile() {
        return isUseBackgroundScaledCompressFile;
    }

    public void setIsUseBackgroundScaledCompressFile(boolean isUseBackgroundScaledCompressFile) {
        this.isUseBackgroundScaledCompressFile = isUseBackgroundScaledCompressFile;
    }

    public int getBackgroundWidth() {
        return backgroundWidth;
    }

    public void setBackgroundWidth(int backgroundWidth) {
        this.backgroundWidth = backgroundWidth <= 0 ? 100 : backgroundWidth; // 防无效值，确保宽高比有效
    }

    public int getBackgroundHeight() {
        return backgroundHeight;
    }

    public void setBackgroundHeight(int backgroundHeight) {
        this.backgroundHeight = backgroundHeight <= 0 ? 100 : backgroundHeight; // 防无效值，确保宽高比有效
    }

    public int getPixelColor() {
        return pixelColor;
    }

    public void setPixelColor(int pixelColor) {
        this.pixelColor = pixelColor;
    }

    // ====================================== 序列化/反序列化方法（适配重命名字段，兼容旧版本）======================================
    @Override
    public String getName() {
        return BackgroundBean.class.getName(); // 必须重写，BaseBean序列化时需类名标识
    }

    /**
     * 序列化：同步重命名字段（原isUseScaledCompress → 新isUseBackgroundScaledCompressFile）
     * 确保新字段能正常持久化，同时兼容旧版本JSON（可选：保留旧字段写入，避免旧版本读取异常）
     */
    @Override
    public void writeThisToJsonWriter(JsonWriter jsonWriter) throws IOException {
        super.writeThisToJsonWriter(jsonWriter);
        BackgroundBean bean = this;
        jsonWriter.name("backgroundFileName").value(bean.getBackgroundFileName());
        jsonWriter.name("backgroundFilePath").value(bean.getBackgroundFilePath()); // 新增字段：背景原图完整路径
        jsonWriter.name("backgroundFileInfo").value(bean.getBackgroundFileInfo());
        jsonWriter.name("isUseBackgroundFile").value(bean.isUseBackgroundFile());
        jsonWriter.name("backgroundScaledCompressFileName").value(bean.getBackgroundScaledCompressFileName());
        jsonWriter.name("backgroundScaledCompressFilePath").value(bean.getBackgroundScaledCompressFilePath());
        // 关键：新字段序列化（核心）
        jsonWriter.name("isUseBackgroundScaledCompressFile").value(bean.isUseBackgroundScaledCompressFile());
        // 兼容旧版本：保留旧字段名写入（可选，避免旧版本Bean读取时缺失字段）
        jsonWriter.name("isUseScaledCompress").value(bean.isUseBackgroundScaledCompressFile());
        jsonWriter.name("backgroundWidth").value(bean.getBackgroundWidth());
        jsonWriter.name("backgroundHeight").value(bean.getBackgroundHeight());
        jsonWriter.name("pixelColor").value(bean.getPixelColor());
    }

    /**
     * 反序列化：同步处理重命名字段（兼容旧版本JSON，新旧字段都能读取）
     * 逻辑：优先读取新字段，若新字段不存在则读取旧字段（确保升级后旧配置仍有效）
     */
    @Override
    public BaseBean readBeanFromJsonReader(JsonReader jsonReader) throws IOException {
        BackgroundBean bean = new BackgroundBean();
        jsonReader.beginObject();
        // 临时变量：存储旧字段值（用于兼容）
        boolean tempUseScaledCompress = false;
        while (jsonReader.hasNext()) {
            String name = jsonReader.nextName();
            switch (name) {
                case "backgroundFileName":
                    bean.setBackgroundFileName(jsonReader.nextString());
                    break;
                case "backgroundFilePath":
                    bean.setBackgroundFilePath(jsonReader.nextString()); // 新增字段：读取背景原图完整路径
                    break;
                case "backgroundFileInfo":
                    bean.setBackgroundFileInfo(jsonReader.nextString());
                    break;
                case "isUseBackgroundFile":
                    bean.setIsUseBackgroundFile(jsonReader.nextBoolean());
                    break;
                case "backgroundScaledCompressFileName":
                    bean.setBackgroundScaledCompressFileName(jsonReader.nextString());
                    break;
                case "backgroundScaledCompressFilePath":
                    bean.setBackgroundScaledCompressFilePath(jsonReader.nextString());
                    break;
					// 关键：读取新字段（优先）
                case "isUseBackgroundScaledCompressFile":
                    bean.setIsUseBackgroundScaledCompressFile(jsonReader.nextBoolean());
                    break;
					// 兼容旧版本：读取旧字段（若新字段未读取，则用旧字段值）
                case "isUseScaledCompress":
                    tempUseScaledCompress = jsonReader.nextBoolean();
                    break;
                case "backgroundWidth":
                    bean.setBackgroundWidth(jsonReader.nextInt());
                    break;
                case "backgroundHeight":
                    bean.setBackgroundHeight(jsonReader.nextInt());
                    break;
                case "pixelColor":
                    bean.setPixelColor(jsonReader.nextInt());
                    break;
                default:
                    jsonReader.skipValue(); // 跳过未知字段，兼容旧版本Bean（避免崩溃）
                    break;
            }
        }
        jsonReader.endObject();
        // 兼容逻辑：若新字段未被赋值（旧版本JSON无此字段），则用旧字段值填充
        if (!jsonReader.toString().contains("isUseBackgroundScaledCompressFile")) {
            bean.setIsUseBackgroundScaledCompressFile(tempUseScaledCompress);
        }
        return bean;
    }

    // ====================================== 辅助方法（同步更新重命名字段）======================================
    /**
     * 重置背景配置（适配“取消背景”功能，同步重置重命名字段）
     */
    public void resetBackgroundConfig() {
        this.backgroundFileName = "";
        this.backgroundFilePath = ""; // 新增：重置背景原图完整路径
        this.backgroundScaledCompressFileName = "";
        this.backgroundScaledCompressFilePath = "";
        this.backgroundFileInfo = "";
        this.isUseBackgroundFile = false;
        this.isUseBackgroundScaledCompressFile = false; // 重命名字段：重置为false
        this.backgroundWidth = 100;
        this.backgroundHeight = 100;
    }

    /**
     * 检查背景配置是否有效（适配BackgroundSettingsActivity的预览/保存校验）
     * 同步使用重命名字段判断压缩图是否启用
     * @return true-配置有效（可显示背景图），false-配置无效
     */
    public boolean isBackgroundConfigValid() {
        // 启用背景图时，需确保：原图路径/文件名 或 压缩图路径/文件名 非空
        if (!isUseBackgroundFile) {
            return false;
        }
        // 原图校验：路径非空 或 文件名非空
        boolean isOriginalValid = !backgroundFilePath.isEmpty() || !backgroundFileName.isEmpty();
        // 压缩图校验：启用压缩图时，路径/文件名需非空
        boolean isCompressValid = true;
        if (isUseBackgroundScaledCompressFile()) { // 重命名字段：判断是否启用压缩图
            isCompressValid = !backgroundScaledCompressFilePath.isEmpty() || !backgroundScaledCompressFileName.isEmpty();
        }
        // 逻辑：启用压缩图则需压缩图有效；不启用压缩图则需原图有效
        return isUseBackgroundScaledCompressFile() ? isCompressValid : isOriginalValid;
    }
}
