// 引入 HiLog 日志模块
import hilog from '@ohos:hilog';

// 导出默认类 EntryAbility，继承自 UIAbility
export default class EntryAbility extends UIAbility {
    
    // 当 Ability 被创建时调用
    onCreate(want, launchParam) {
        // 打印日志：Ability onCreate
        hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onCreate');
    }

    // 当 Ability 被销毁时调用
    onDestroy() {
        // 打印日志：Ability onDestroy
        hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onDestroy');
    }

    // 当主窗口阶段被创建时调用
    onWindowStageCreate(windowStage) {
        // 打印日志：Ability onWindowStageCreate
        hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageCreate');

        // 加载主页面
        windowStage.loadContent('pages/Index', (err, data) => {
            var _a, _b;
            if (err.code) {
                // 加载内容失败，打印错误日志
                hilog.error(0x0000, 'testTag', 'Failed to load the content. Cause: %{public}s', (_a = JSON.stringify(err)) !== null && _a !== void 0 ? _a : '');
                return;
            }
            // 加载内容成功，打印成功日志
            hilog.info(0x0000, 'testTag', 'Succeeded in loading the content. Data: %{public}s', (_b = JSON.stringify(data)) !== null && _b !== void 0 ? _b : '');
        });
    }

    // 当主窗口阶段被销毁时调用
    onWindowStageDestroy() {
        // 打印日志：Ability onWindowStageDestroy
        hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageDestroy');
    }

    // 当 Ability 进入前台时调用
    onForeground() {
        // 打印日志：Ability onForeground
        hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onForeground');
    }

    // 当 Ability 进入后台时调用
    onBackground() {
        // 打印日志：Ability onBackground
        hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onBackground');
    }
}

;

// 引入模块 testNapi 和 batteryInfo
import testNapi from '@app:com.example.test/entry/entry';
import batteryInfo from '@ohos:batteryInfo';

// 定义一个名为 CustomDialogExample 的类，继承自 ViewPU
class CustomDialogExample extends ViewPU {
    // 构造函数
    constructor(parent, params, __localStorage, elmtId = -1) {
        super(parent, __localStorage, elmtId); // 调用父类的构造函数
        // 初始化一个双向绑定的属性 __textValue
        this.__textValue = new SynchedPropertySimpleTwoWayPU(params.textValue, this, "textValue");
        this.controller = undefined; // 初始化 controller 为 undefined
        this.setInitiallyProvidedValue(params); // 设置初始提供的值
    }

    // 设置初始提供的值
    setInitiallyProvidedValue(params) {
        if (params.controller !== undefined) {
            this.controller = params.controller; // 如果参数中有 controller，则设置
        }
    }

    // 更新状态变量（当前为空实现）
    updateStateVars(params) {
    }

    // 清除元素 ID 的变量依赖
    purgeVariableDependenciesOnElmtId(rmElmtId) {
        this.__textValue.purgeDependencyOnElmtId(rmElmtId);
    }

    // 即将被删除时的操作
    aboutToBeDeleted() {
        this.__textValue.aboutToBeDeleted(); // 调用 __textValue 的删除方法
        SubscriberManager.Get().delete(this.id__()); // 从订阅者管理器中删除
        this.aboutToBeDeletedInternal(); // 调用内部的即将删除方法
    }

    // 获取 textValue 属性
    get textValue() {
        return this.__textValue.get();
    }

    // 设置 textValue 属性
    set textValue(newValue) {
        this.__textValue.set(newValue);
    }

    // 设置控制器
    setController(ctr) {
        this.controller = ctr;
    }

    // 初始渲染
    initialRender() {
        // 观察组件的创建
        this.observeComponentCreation((elmtId, isInitialRender) => {
            ViewStackProcessor.StartGetAccessRecordingFor(elmtId); // 开始记录访问
            Column.create(); // 创建一个列
            if (!isInitialRender) {
                Column.pop(); // 如果不是初始渲染，弹出列
            }
            ViewStackProcessor.StopGetAccessRecording(); // 停止记录访问
        });
        this.observeComponentCreation((elmtId, isInitialRender) => {
            ViewStackProcessor.StartGetAccessRecordingFor(elmtId); // 开始记录访问
            Text.create(this.textValue); // 创建一个文本组件，显示 textValue
            Text.fontSize(20); // 设置字体大小
            Text.margin({ top: 10, bottom: 10 }); // 设置边距
            if (!isInitialRender) {
                Text.pop(); // 如果不是初始渲染，弹出文本组件
            }
            ViewStackProcessor.StopGetAccessRecording(); // 停止记录访问
        });
        Text.pop(); // 弹出文本组件
        Column.pop(); // 弹出列
    }

    // 重新渲染
    rerender() {
        this.updateDirtyElements(); // 更新脏元素
    }
}


// 定义一个名为 Index 的类，继承自 ViewPU
class Index extends ViewPU {
    // 构造函数
    constructor(parent, params, __localStorage, elmtId = -1) {
        super(parent, __localStorage, elmtId); // 调用父类的构造函数
        this.context = getContext(this); // 获取上下文
        // 初始化观察属性
        this.__message = new ObservedPropertySimplePU('请输入flag', this, "message");
        this.__button_name = new ObservedPropertySimplePU('提交', this, "button_name");
        this.__flag = new ObservedPropertySimplePU('', this, "flag");
        this.__result = new ObservedPropertySimplePU('', this, "result");
        // 初始化对话框控制器
        this.dialogController = new CustomDialogController({
            builder: () => {
                let jsDialog = new CustomDialogExample(this, {
                    textValue: this.__result,
                });
                jsDialog.setController(this.dialogController); // 设置对话框控制器
                ViewPU.create(jsDialog); // 创建对话框视图
            }
        }, this);
        this.setInitiallyProvidedValue(params); // 设置初始提供的值
    }

    // 设置初始提供的值
    setInitiallyProvidedValue(params) {
        if (params.context !== undefined) {
            this.context = params.context;
        }
        if (params.message !== undefined) {
            this.message = params.message;
        }
        if (params.button_name !== undefined) {
            this.button_name = params.button_name;
        }
        if (params.flag !== undefined) {
            this.flag = params.flag;
        }
        if (params.result !== undefined) {
            this.result = params.result;
        }
        if (params.dialogController !== undefined) {
            this.dialogController = params.dialogController;
        }
    }

    // 更新状态变量（当前为空实现）
    updateStateVars(params) {
    }

    // 清除元素 ID 的变量依赖
    purgeVariableDependenciesOnElmtId(rmElmtId) {
        this.__message.purgeDependencyOnElmtId(rmElmtId);
        this.__button_name.purgeDependencyOnElmtId(rmElmtId);
        this.__flag.purgeDependencyOnElmtId(rmElmtId);
        this.__result.purgeDependencyOnElmtId(rmElmtId);
    }

    // 即将被删除时的操作
    aboutToBeDeleted() {
        this.__message.aboutToBeDeleted(); // 调用 __message 的删除方法
        this.__button_name.aboutToBeDeleted(); // 调用 __button_name 的删除方法
        this.__flag.aboutToBeDeleted(); // 调用 __flag 的删除方法
        this.__result.aboutToBeDeleted(); // 调用 __result 的删除方法
        SubscriberManager.Get().delete(this.id__()); // 从订阅者管理器中删除
        this.aboutToBeDeletedInternal(); // 调用内部的即将删除方法
    }

    // 获取 message 属性
    get message() {
        return this.__message.get();
    }

    // 设置 message 属性
    set message(newValue) {
        this.__message.set(newValue);
    }

    // 获取 button_name 属性
    get button_name() {
        return this.__button_name.get();
    }

    // 设置 button_name 属性
    set button_name(newValue) {
        this.__button_name.set(newValue);
    }

    // 获取 flag 属性
    get flag() {
        return this.__flag.get();
    }

    // 设置 flag 属性
    set flag(newValue) {
        this.__flag.set(newValue);
    }

    // 获取 result 属性
    get result() {
        return this.__result.get();
    }

    // 设置 result 属性
    set result(newValue) {
        this.__result.set(newValue);
    }

    aboutToAppear() {
        // 注册 testNapi 处理程序，针对不同的 batteryInfo 属性进行比较和返回结果

        // 电池剩余电量差值判断
        testNapi.register(0, (a) => {
            var t = batteryInfo.batterySOC - a;
            var f;
            if (t > 0)
                f = 1;
            else if (t == 0)
                f = 0;
            else
                f = -1;
            return f === 0;
        });

        // 充电状态差值判断
        testNapi.register(1, (a) => {
            var t = batteryInfo.chargingStatus - a;
            var f;
            if (t > 0)
                f = 1;
            else if (t == 0)
                f = 0;
            else
                f = -1;
            return f === 0;
        });

        // 电池健康状态差值判断
        testNapi.register(2, (a) => {
            var t = batteryInfo.healthStatus - a;
            var f;
            if (t > 0)
                f = 1;
            else if (t == 0)
                f = 0;
            else
                f = -1;
            return f === 0;
        });

        // 电池插入类型差值判断
        testNapi.register(3, (a) => {
            var t = batteryInfo.pluggedType - a;
            var f;
            if (t > 0)
                f = 1;
            else if (t == 0)
                f = 0;
            else
                f = -1;
            return f === 0;
        });

        // 电池电压差值判断
        testNapi.register(4, (a) => {
            var t = batteryInfo.voltage - a;
            var f;
            if (t > 0)
                f = 1;
            else if (t == 0)
                f = 0;
            else
                f = -1;
            return f === 0;
        });

        // 电池技术判断
        testNapi.register(5, (a) => {
            var f;
            if (a === batteryInfo.technology)
                f = 1;
            else
                f = 0;
            return f === 1;
        });

        // 电池温度差值判断
        testNapi.register(6, (a) => {
            var t = batteryInfo.batteryTemperature - a;
            var f;
            if (t > 0)
                f = 1;
            else if (t == 0)
                f = 0;
            else
                f = -1;
            return f === 0;
        });

        // 电池是否存在判断
        testNapi.register(7, (a) => {
            return batteryInfo.isBatteryPresent === a;
        });

        // 电池容量等级差值判断
        testNapi.register(8, (a) => {
            var t = batteryInfo.batteryCapacityLevel - a;
            var f;
            if (t > 0)
                f = 1;
            else if (t == 0)
                f = 0;
            else
                f = -1;
            return f === 0;
        });

        // 直接返回电池剩余电量
        testNapi.register(256, () => {
            return batteryInfo.batterySOC;
        });

        // 直接返回充电状态
        testNapi.register(257, () => {
            return batteryInfo.chargingStatus;
        });

        // 直接返回电池健康状态
        testNapi.register(258, () => {
            return batteryInfo.healthStatus;
        });

        // 直接返回电池插入类型
        testNapi.register(259, () => {
            return batteryInfo.pluggedType;
        });

        // 直接返回电池电压
        testNapi.register(260, () => {
            return batteryInfo.voltage;
        });

        // 直接返回电池技术
        testNapi.register(261, () => {
            return batteryInfo.technology;
        });

        // 直接返回电池温度
        testNapi.register(262, () => {
            return batteryInfo.batteryTemperature;
        });

        // 直接返回电池是否存在
        testNapi.register(263, () => {
            return batteryInfo.isBatteryPresent;
        });

        // 直接返回电池容量等级
        testNapi.register(264, () => {
            return batteryInfo.batteryCapacityLevel;
        });
    }
        initialRender() {
            // 创建Row布局，设置高度为100%
            this.observeComponentCreation((elmtId, isInitialRender) => {
                ViewStackProcessor.StartGetAccessRecordingFor(elmtId);
                Row.create();
                Row.height('100%');
                if (!isInitialRender) {
                    Row.pop(); // 如果不是初次渲染，则弹出Row
                }
                ViewStackProcessor.StopGetAccessRecording();
            });
        
            // 创建Column布局，设置宽度为100%
            this.observeComponentCreation((elmtId, isInitialRender) => {
                ViewStackProcessor.StartGetAccessRecordingFor(elmtId);
                Column.create();
                Column.width('100%');
                if (!isInitialRender) {
                    Column.pop(); // 如果不是初次渲染，则弹出Column
                }
                ViewStackProcessor.StopGetAccessRecording();
            });
        
            // 创建Text组件，设置字体大小和点击事件
            this.observeComponentCreation((elmtId, isInitialRender) => {
                ViewStackProcessor.StartGetAccessRecordingFor(elmtId);
                Text.create(this.message); // 创建文本组件，显示message属性的内容
                Text.fontSize(50); // 设置字体大小为50
                Text.fontWeight(FontWeight.Bold); // 设置字体为粗体
                Text.onClick(() => {
                    hilog.info(0x0000, 'testTag', 'Test NAPI 2 + 3 = %{public}d', testNapi.add(2, 3)); // 点击事件：调用testNapi.add并记录日志
                });
                if (!isInitialRender) {
                    Text.pop(); // 如果不是初次渲染，则弹出Text
                }
                ViewStackProcessor.StopGetAccessRecording();
            });
            Text.pop(); // 弹出Text组件
        
            // 创建TextInput组件，设置输入变化事件
            this.observeComponentCreation((elmtId, isInitialRender) => {
                ViewStackProcessor.StartGetAccessRecordingFor(elmtId);
                TextInput.create({
                    text: "", // 初始化TextInput组件的text属性为空字符串
                });
                TextInput.onChange((value) => {
                    this.flag = value; // 当输入发生变化时，更新flag属性
                });
                if (!isInitialRender) {
                    TextInput.pop(); // 如果不是初次渲染，则弹出TextInput
                }
                ViewStackProcessor.StopGetAccessRecording();
            });
        }
        this.observeComponentCreation((elmtId, isInitialRender) => {
            ViewStackProcessor.StartGetAccessRecordingFor(elmtId);
            Button.createWithLabel(this.button_name);
            Button.onClick(() => {
                this.context.resourceManager.getRawFileContent("bin").then((value) => {
                    var c = testNapi.check(this.flag, value);
                    if ((c & 0b100) === 0b100) {
                        this.result = '系统环境异常';
                    }
                    else if ((c & 0b10) === 0b10) {
                        this.result = 'flag格式错误';
                    }
                    else if ((c & 0b1) === 0b1) {
                        this.result = 'flag错误或系统环境异常';
                    }
                    else {
                        this.result = 'flag正确';
                    }
                    this.dialogController.open();
                });
            });
            if (!isInitialRender) {
                Button.pop();
            }
            ViewStackProcessor.StopGetAccessRecording();
        });
        Button.pop();
        Column.pop();
        Row.pop();
    }
    rerender() {
        this.updateDirtyElements();
    }
}
ViewStackProcessor.StartGetAccessRecordingFor(ViewStackProcessor.AllocateNewElmetIdForNextComponent());
loadDocument(new Index(undefined, {}));
ViewStackProcessor.StopGetAccessRecording();
