-- Copyright (c) 2026 Huawei Technologies Co., Ltd.
-- openUBMC is licensed under Mulan PSL v2.
-- You can use this software according to the terms and conditions of the Mulan PSL v2.
-- You may obtain a copy of Mulan PSL v2 at:
--          http://license.coscl.org.cn/MulanPSL2
-- THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
-- EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
-- MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
-- See the Mulan PSL v2 for more details.

local defs = require('defs')
local class = require('mc.class')
local context = require('mc.context')
local hwproxy_objects = require('hwproxy_objects')
local shared_object = require('shared_object')
local hwproxy_error = require('hwproxy.errors')
local chip_types = require('hwproxy.json_types.keplerChip')
local object_defs = require('object_defs')
local hw_utils = require('hw_utils.utils')
local vos = require('utils.vos')
local utils_core = require('utils.core')
local utils = require('mc.utils')
local bus = require('hwproxy_objects.app_bus')
local log = require('mc.logging')
local queue = require('skynet.queue')
local skynet = require('skynet')
local ser = require('serialize')
local client = require('client')
local is_utf8 = utils_core.utf8_validate

local telemetry = require('telemetry')
local trace = require('telemetry.trace')

local SetLockStatusResultCode = chip_types.SetLockStatusResultCode

local skynet_sleep = skynet.sleep
local LOCK_TIME = defs.LOCK_TIME
local LOCK_STATUS = defs.LOCK_STATUS
local LOCK_OP_TYPE = defs.LOCK_OP_TYPE
local table_compare = utils.table_compare

local CHIP_INTERFACE = 'bmc.kepler.Chip'
local SCANNER_INTERFACE <const> = 'bmc.kepler.Scanner'
local ACCESSOR_INTERFACE <const> = 'bmc.kepler.Accessor'
local AGGREGATE_INTERFACE <const> = 'bmc.kepler.Scanner.Aggregate'
local MIN_DISABLE_DURATION <const> = 1
local MAX_DISABLE_DURATION <const> = 1800
local SCAN_DISABLED <const> = 0

local SCAN_NOT_ACCESSIBLE <const> = 3

-- 从资源树获取拓扑数据
local function get_topo_data(self, position)
    local generate_topo = function(obj)
        local topo_str = obj:GetTopology_PACKED(context.new()):unpack(true)
        log:hw_stream_notice('position: %s, get topology successfully, topology: %s', position, topo_str)
        self.topo_data[position] = topo_str and ser.decode(topo_str) or nil
    end

    local ret, obj
    for _ = 1, 10 do
        ret, obj = pcall(client.GetObjectGroupObjectGroupObject, client, { Id = position })
        if ret then
            generate_topo(obj)
            return
        end
        skynet_sleep(100) -- 间隔时间1s
    end
    log:warn('position: %s get topology failed ret: %s', position, obj)
end

local function sync_telemetry(obj)
    obj.stream:send('dlog_level_change', log:getLevel())
    obj.stream:send('trace_status_change', telemetry.get_status())
    obj.stream:send('trace_status_change', telemetry.get_status(telemetry.lOGS), telemetry.lOGS)
    obj.stream:send('trace_status_change', telemetry.get_status(telemetry.METRICS), telemetry.METRICS)
    obj.stream:send('trace_flags_change', 'load_sampling_rate', trace.get_trace_flag('load_sampling_rate'))
    obj.stream:send('trace_flags_change', 'sampling_rate', trace.get_trace_flag('sampling_rate'))
    obj.stream:send('trace_flags_change', 'sampling_level', trace.get_trace_flag('sampling_level'))
end

local app_objects = class(hwproxy_objects)

function app_objects:ctor(_, dbus)
    self.cache_objects = {}
    self.bus_objects = {}
    self.cache_position = {}

    self.wait_register_objects = {}
    self.wait_register_dft = {}
    skynet.fork(function()
        self.monitor_service = skynet.uniqueservice('hwproxy/service/monitor')
        skynet.send(self.monitor_service, 'lua', 'set_debug_log_level', log:getLevel())
    end)
    self.registed_accessor_cb = {}
    self.dbus = dbus
    self.thread_handler = {}
    self.thread_queue = queue()
    self.merge_work_bus = {}

    self.bus_name_to_merge_key = {}
    self.locked_buses = {}
end

function app_objects:new_bus(object)
    local bus_obj = bus.new(object)
    local addr = bus_obj.stream.work
    local merge_key = bus_obj.stream.merge_key
    if merge_key then
        self.bus_name_to_merge_key[object.name] = merge_key
        if not self.merge_work_bus[merge_key] then
            self.merge_work_bus[merge_key] = {}
        end
        table.insert(self.merge_work_bus[merge_key], object.name)
        skynet.send(self.monitor_service, 'lua', 'register', object.name, addr, merge_key)
        sync_telemetry(bus_obj)
    else
        skynet.send(self.monitor_service, 'lua', 'register', object.name, addr)
        sync_telemetry(bus_obj)
    end

    bus_obj.stream:send('create_hwproxy_object', object.name)
    local tree = shared_object.create_tree()
    bus_obj:set_raw_dbus(self.dbus.bus.conn:to_raw(true), tree:to_raw())
    return bus_obj
end

function app_objects:cache_forward_object(position, object)
    local objects = self.cache_objects[position]
    if not objects then
        objects = {}
        self.cache_objects[position] = objects
    end

    local new_object = { name = object.name, class_name = object.class_name, path = object.path }

    if object.class_name == 'Scanner' then
        new_object.props = utils.merge_table(object[SCANNER_INTERFACE].props, object[AGGREGATE_INTERFACE].props)
        new_object.is_work = true
    elseif object_defs[object.class_name]['type'] == 'Chip' then
        new_object.props = object[CHIP_INTERFACE] and object[CHIP_INTERFACE].props or {}
        new_object.is_work = true
    end

    local props = object:get_all_prop_names()

    if object.class_name == 'Accessor' then
        new_object.prop_precisions = object[ACCESSOR_INTERFACE].prop_precisions
    elseif object.class_name == 'Scanner' then
        new_object.prop_precisions = object[SCANNER_INTERFACE].prop_precisions
    end

    for _, v in ipairs(props) do
        if (object.class_name ~= 'Accessor' and object.class_name ~= 'Scanner') or v ~= 'Value' then
            new_object[v] = object[v]
        end
    end

    new_object.need_register = true

    objects[object.name] = new_object
end

function app_objects:bus_object_handle(class_name, object, position)
    object:register_mdb_objects()
    self.super.bus_object_handle(self, class_name, object, position)
    self:cache_forward_object(position, object)
end

function app_objects:chip_object_handle(class_name, object, position)
    self.wait_register_objects[object.name] = object
    self.super.chip_object_handle(self, class_name, object, position)
    self:cache_forward_object(position, object)
    local obj = object[CHIP_INTERFACE]
    -- JtagSwitch是虚拟chip, 没有这个接口
    if obj then
        shared_object.create_shared_values(obj)

        obj.force_write = true
        obj.property_before_change:on(function(name, value, sender)
            -- 业务主动设置健康状态时,在对应chip的工作线程上更新属性
            if name == 'HealthStatus' and sender ~= nil then
                local chip_name = self:get_chip_name(obj)
                local host_bus = self.chips[chip_name].host_bus
                host_bus.stream:call('set_health_status', { path = obj.path, chip = obj.chip }, value)
            end
        end)
    end

    object.property_changed:on(function(name, value)
        if name == 'DrvWriteDelay' then
            local host_bus = self.chips[object.name].host_bus
            if not host_bus then
                return
            end
            log:notice('chip: %s, sync DrvWriteDelay change to: %d', object.name, value)
            host_bus.stream:call('update_drv_write_delay', object.name, value)
        end
    end)
end

function app_objects:register_property_read(obj, object)
    obj.property_read:on(function(name)
        local ctx_emit = context.get_context()
        if name == 'Status' or (ctx_emit and ctx_emit.AccessMode == 'Cache') then
            return true
        end

        local span = trace.start_span(
            'hwproxy.app_objects.property_read',
            trace.get_status() and { ['accessor.name'] = object.name } or nil
        )
        local offset = object.Offset
        local ret = self:realtime_read(self.chips[object.Chip].host_bus, object.name, ctx_emit, offset)
        if is_utf8(ret) and object.Type == 1 then
            obj['PrintableValue'] = ret
        end
        obj['Value'] = ret
        span:finish()

        return true
    end)
end

function app_objects:setup_accessor_interface(obj, object)
    if object[ACCESSOR_INTERFACE] then
        obj.property_before_change:on(function(name, value, sender)
            local ctx = context.get_context()
            if not sender or context.is_override() then
                return true
            end

            local span = trace.start_span(
                'hwproxy.app_objects.property_before_change',
                trace.get_status() and { ['accessor.name'] = object.name } or nil
            )
            self:realtime_write(self.chips[object.Chip].host_bus, object.name, ctx, value)
            span:finish()
            return true
        end)

        self:register_property_read(obj, object)
    end
end

function app_objects:resource_object_handle(class_name, object, position)
    if not object.Chip or object.Chip == '' then
        log:error('invalid chip object for resource %s', object.name)
        return
    end

    self.wait_register_objects[object.name] = object
    -- 获取Accessor/Scanner资源树对象
    local obj = object[SCANNER_INTERFACE] or object[ACCESSOR_INTERFACE]
    -- 设置force_write属性,属性值相同时,仍然设置资源树值,写入到硬件
    obj.force_write = true

    if object[SCANNER_INTERFACE] then
        self:handle_scanner_interface(object, position)
    end

    self:handle_aggregate_interface(object)
    self:setup_accessor_interface(obj, object)
    self:set_encoding_functions(obj)

    app_objects.super.resource_object_handle(self, class_name, object, position)
    self:cache_forward_object(position, object)
end

function app_objects:handle_scanner_interface(object, position)
    object.property_changed:on(function(name, value)
        if name ~= 'ScanEnabled' then
            return
        end
        if not self.chips[object.Chip] or not self.chips[object.Chip].host_bus then
            -- 当对象还未发送给work服务时,ScanEnabled的值需要更新到cache中
            if name == 'ScanEnabled' then
                self:cache_forward_object(position, object)
            end
            return
        end
        if value == SCAN_DISABLED then
            object[SCANNER_INTERFACE]:clear_error('Value') -- 当ScanEnabled变为disable时,清理Value的错误状态
            object.Value = utils.dbus_value_to_binary(object.NominalValue, 't')
            object.Status = utils.dbus_value_to_binary(SCAN_NOT_ACCESSIBLE, 'y')
        end
        log:notice('scanner: %s change scan enabled to: %s', object.name, value)
    end)

    shared_object.create_shared_values(object[SCANNER_INTERFACE], object)
    if object.ScanEnabled == SCAN_DISABLED then
        object.Value = object.NominalValue
        object.Status = SCAN_NOT_ACCESSIBLE
        log:notice('scanner: %s scan enabled initial value: %d', object.name, object.ScanEnabled)
    end
end

function app_objects:handle_aggregate_interface(object)
    local aggregare_intf_obj = object[AGGREGATE_INTERFACE]
    if aggregare_intf_obj then
        shared_object.create_shared_values(aggregare_intf_obj)
    end
end

function app_objects:set_encoding_functions(obj)
    obj:set_decoder(function(_, value, type)
        return utils.binary_to_dbus_type(value, type)
    end)

    obj:set_encoder(function(_, value, type)
        return utils.dbus_value_to_binary(value, type)
    end)
end

function app_objects:mux_object_handle(class_name, object, position)
    object:register_mdb_objects()
    app_objects.super.mux_object_handle(self, class_name, object, position)
    self:cache_forward_object(position, object)
end

function app_objects:debounce_object_handle(class_name, object, position)
    object:register_mdb_objects()
    app_objects.super.debounce_object_handle(self, class_name, object, position)
    self:cache_forward_object(position, object)
end

function app_objects:dft_object_handle(class_name, object, position)
    self.wait_register_dft[object.RefChip] = self.wait_register_dft[object.RefChip] or {}
    self.wait_register_dft[object.RefChip][object.name] = object
    app_objects.super.dft_object_handle(self, class_name, object, position)
    self:cache_forward_object(position, object)
end

function app_objects:smc_dfx_info_handle(class_name, object, position)
    app_objects.super.smc_dfx_info_handle(self, class_name, object, position)
    self:cache_forward_object(position, object)
end

function app_objects:on_add_object_complete(position)
    get_topo_data(self, position)
    app_objects.super.on_add_object_complete(self, position)

    local bus_objects = self.bus_objects
    local has_object_buses = {}
    for _, object in pairs(self.cache_objects[position]) do
        local name = object.name
        if self.buses[name] then
            bus_objects[name] = { self.buses[name] }
        elseif self.chips[name] then
            bus_objects[name] = { self.chips[name].host_bus }
        elseif object.Chip then
            if object.Chip ~= '' then
                bus_objects[name] = { self.chips[object.Chip].host_bus }
            end
        elseif self.mux_data[name] then
            if self.chips[self.mux_data[name].pre_device] then
                bus_objects[name] = { self.chips[self.mux_data[name].pre_device].host_bus }
            end
        else
            bus_objects[name] = self.buses
        end

        for _, v in pairs(bus_objects[name] or {}) do
            has_object_buses[v.name] = v
            v:add_object(object.class_name, object, position)
        end
    end

    for _, v in pairs(has_object_buses) do
        skynet.send(self.monitor_service, 'lua', 'add_work_monitor', _, position) -- 通知monitor服务打开监听complete消息
        v:add_object_complete(position, self.topo_data[position], self.monitor_service)
    end
    self.cache_position[#self.cache_position + 1] = position
end

function app_objects:on_delete_object(class_name, object, position)
    local name = object.name
    local bus_objects = self.bus_objects
    if object.LockStatus and object.LockStatus == 1 then
        self:unlock(object, {}, true)
    end
    for _, v in pairs(bus_objects[name] or {}) do
        v:delete_object(class_name, { name = name }, position)
    end
    bus_objects[name] = nil
    if self.cache_objects[position] then
        self.cache_objects[position][object.name] = nil
    end

    app_objects.super.on_delete_object(self, class_name, object, position)
end

function app_objects:on_delete_object_complete(position)
    for _, v in pairs(self.buses) do
        v:delete_object_complete(position)
    end

    app_objects.super.on_delete_object_complete(self, position)
    for index, pos in ipairs(self.cache_position) do
        if pos == position then
            table.remove(self.cache_position, index)
            break
        end
    end
end

function app_objects:trace_status_change(status, kind)
    for _, bus_obj in pairs(self.buses) do
        bus_obj.stream:send('trace_status_change', status, kind)
    end
end

function app_objects:trace_flags_change(flag, value)
    for _, bus_obj in pairs(self.buses) do
        bus_obj.stream:send('trace_flags_change', flag, value)
    end
end

-- 日志DlogLevel与DlogType修改回调
function app_objects:dlog_level_change(dlog_level)
    for _, bus_obj in pairs(self.buses) do
        bus_obj.stream:send('dlog_level_change', dlog_level)
    end
    skynet.send(self.monitor_service, 'lua', 'set_debug_log_level', dlog_level)
end

function app_objects:dlog_type_change(dlog_type)
    for _, bus_obj in pairs(self.buses) do
        bus_obj.stream:send('dlog_type_change', dlog_type)
    end
end

-- 对象资源树方法实现
function app_objects:read_write_func(func_name, obj, ctx, ...)
    if getmetatable(ctx) == context or type(ctx) == 'table' then
        if ctx.RPCTimeCost == 'used' then
            ctx.RPCTimeCost = vos.vos_tick_get()
        else
            ctx.RPCTimeCost = nil
        end
    end

    local span = trace.start_span(
        'hwproxy.app_objects.read_write_func',
        trace.get_status() and { ['func.name'] = func_name, ['chip.name'] = obj.path } or nil
    )

    local chip_name = self:get_chip_name(obj)
    local host_bus = self.chips[chip_name].host_bus
    local results =
        { host_bus.stream:call('read_write_func', func_name, { path = obj.path, chip = obj.chip }, ctx, ...) }
    span:finish()
    return table.unpack(results)
end

function app_objects:bus_read_write_func(func_name, obj, ctx, ...)
    local chip_name = self:get_vchip_name(obj)
    local host_bus = self.chips[chip_name].host_bus
    return host_bus.stream:call('read_write_func', func_name, { chip = chip_name }, ctx and ctx or context.new(), ...)
end

function app_objects:cpld_upg_request(op, obj, ctx, ...)
    local chip_name = self:get_chip_name(obj)
    local host_bus = self.chips[chip_name].host_bus
    return host_bus.stream:call('cpld_upg_request', op, { path = obj.path }, ctx and ctx or context.new(), ...)
end

function app_objects:accessor_operate(op, accessor_name, value)
    local ref_chip = self.accessor_ref_chip[accessor_name]
    if not ref_chip then
        error(hwproxy_error.chip_not_exist_error())
    end
    local ctx = context.get_context()
    if op == 'Read' then
        return self:realtime_read(ref_chip.host_bus, accessor_name, ctx)
    elseif op == 'Write' then
        value = utils.dbus_value_to_binary(value, 'x')
        return self:realtime_write(ref_chip.host_bus, accessor_name, ctx, value)
    end
end

-- Accessor属性实时读取/写入方法
function app_objects:realtime_read(host_bus, accessor_name, ctx, offset)
    return host_bus.stream:call('realtime_read', {}, accessor_name, ctx and ctx or context.new(), offset)
end

function app_objects:realtime_write(host_bus, accessor_name, ctx, value)
    return host_bus.stream:call('realtime_write', {}, accessor_name, ctx and ctx or context.new(), value)
end

-- chip自检
function app_objects:chip_test(obj)
    local ref_chip_name = self:get_ref_chip_name(obj)
    local host_bus = self.chips[ref_chip_name].host_bus
    local obj_name = self:get_object_name_from_path(obj)
    local dtf_obj = self.dft_list[obj_name]
    return host_bus.stream:call('chip_test', { path = obj.path, offset = dtf_obj.Offset, len = dtf_obj.Size })
end

function app_objects:update_resource(chip_name, resource_names, ok, ret)
    local t_chip = self.chips[chip_name]
    if t_chip == nil then
        return
    end

    local resources = {}
    for _, work_res in ipairs(resource_names) do
        local work_res_name = work_res.name
        local res = t_chip.accessors[work_res_name] or t_chip.scanners[work_res_name]
        if not res then
            goto continue
        end

        local work_res_scan_status = work_res.scan_status
        for _, app_res in ipairs(res.resources) do
            if app_res.name == work_res_name then
                app_res.scan_status = work_res_scan_status
                resources[#resources + 1] = app_res
            end
        end
        ::continue::
    end

    t_chip:update_resource(resources, ok, ret)
end

-- 禁止和使能器件访问
function app_objects:handle_chip_scanners(obj, _, Status, DisableDuration)
    local chip_name = self:get_chip_name(obj)
    local host_bus = self.chips[chip_name].host_bus
    -- 禁用时间校验
    if DisableDuration < MIN_DISABLE_DURATION or DisableDuration > MAX_DISABLE_DURATION then
        log:raise(
            'Invalid Parameter! DisableDuration Range is:[%d, %d], current DisableDuration is %d',
            MIN_DISABLE_DURATION,
            MAX_DISABLE_DURATION,
            DisableDuration
        )
    end
    -- Status:true -> 使能器件访问
    -- Status: false -> 禁止器件访问
    if Status == false then
        return host_bus.stream:call('stop_chip_scanners', { path = obj.path }, DisableDuration)
    else
        return host_bus.stream:call('restart_chip_scanners', { path = obj.path })
    end
end

function app_objects:lock(obj, ctx, lock_time)
    -- 锁定时间校验
    if lock_time < LOCK_TIME.MIN or lock_time > LOCK_TIME.MAX then
        return SetLockStatusResultCode.InvalidParameter
    end

    local chip_name = self:get_chip_name(obj)
    local chip = self.chips[chip_name]
    local bus_name = chip.host_bus.name
    local channel_chain = chip.channel_chain
    local requestor = ctx.Requestor or 'unknown'
    local lock_info = self.locked_buses[bus_name]
    if lock_info ~= nil then
        if requestor ~= lock_info.requestor then
            return SetLockStatusResultCode.RequestorMismatchedError
        end

        if chip_name ~= lock_info.chip_name then
            return (channel_chain == lock_info.channel_chain) and SetLockStatusResultCode.ChipMismatchedError
                or SetLockStatusResultCode.ChannelMismatchedError
        end

        skynet.killthread(lock_info.co)
        self.locked_buses[bus_name] = nil
    end

    local co = skynet.timeout(lock_time * 100, function()
        self.locked_buses[bus_name] = nil
        obj.LockStatus = LOCK_STATUS.UNLOCKED
        log:notice(
            'channel automatic unlocked upon timeout, bus: %s, channel_chain: %s, chip: %s',
            bus_name,
            channel_chain,
            chip_name
        )
    end)

    self.locked_buses[bus_name] =
        { co = co, requestor = requestor, chip_name = chip_name, channel_chain = channel_chain }
    obj.LockStatus = LOCK_STATUS.LOCKED

    if lock_info ~= nil then
        log:notice(
            '[%s] renew lock status for %s seconds successfully, bus: %s, channel_chain: %s, chip: %s',
            requestor,
            lock_time,
            bus_name,
            channel_chain,
            chip_name
        )
    else
        log:notice(
            '[%s] lock channel for %s seconds successfully, bus: %s, channel_chain: %s, chip: %s',
            requestor,
            lock_time,
            bus_name,
            channel_chain,
            chip_name
        )
    end

    return SetLockStatusResultCode.OK
end

function app_objects:unlock(obj, ctx, is_force_unlock)
    local chip_name = self:get_chip_name(obj)
    local chip = self.chips[chip_name]
    local bus_name = chip.host_bus.name

    local lock_info = self.locked_buses[bus_name]
    local requestor = ctx.Requestor or 'unknown'
    local channel_chain = chip.channel_chain

    if not is_force_unlock then
        if lock_info == nil then
            return SetLockStatusResultCode.UnlockedError -- 通道未锁定无需解锁
        end

        if requestor ~= lock_info.requestor then
            return SetLockStatusResultCode.RequestorMismatchedError
        end

        if chip_name ~= lock_info.chip_name then -- 器件名不匹配解锁失败
            return (channel_chain == lock_info.channel_chain) and SetLockStatusResultCode.ChipMismatchedError
                or SetLockStatusResultCode.ChannelMismatchedError
        end
    end

    skynet.killthread(lock_info.co)
    self.locked_buses[bus_name] = nil
    obj.LockStatus = LOCK_STATUS.UNLOCKED

    log:notice(
        '[%s] unlock channel successfully, bus: %s, channel_chain: %s, chip: %s',
        requestor,
        bus_name,
        channel_chain,
        chip_name
    )

    return SetLockStatusResultCode.OK
end

-- 器件所在的硬件通道加锁和解锁
function app_objects:set_lock_status(obj, ctx, op_type, lock_time)
    if op_type == LOCK_OP_TYPE.LOCK then
        return self:lock(obj, ctx, lock_time)
    elseif op_type == LOCK_OP_TYPE.UNLOCK then
        return self:unlock(obj, ctx)
    end

    return SetLockStatusResultCode.InvalidParameter
end

function app_objects:porcess_accessibility(obj, host_bus, bus_name, status, disable_duration)
    if self.thread_handler[bus_name] then
        skynet.killthread(self.thread_handler[bus_name])
        self.thread_handler[bus_name] = nil
    end

    if not status then
        host_bus.stream:call('stop_bus_access', disable_duration)
        obj.AccessEnabled = false
        obj.Timeout = disable_duration
        self.thread_handler[bus_name] = skynet.fork_once(function()
            while disable_duration >= 0 do
                local psuse_time = disable_duration >= 10 and 1000 or (disable_duration * 100)
                skynet_sleep(psuse_time)
                disable_duration = disable_duration - 10
                obj.Timeout = disable_duration > 0 and disable_duration or 0
            end
            host_bus.stream:call('restart_bus_access')
            obj.AccessEnabled = true
            self.thread_handler[bus_name] = nil
        end)
    else
        host_bus.stream:call('restart_bus_access')
        obj.AccessEnabled = true
        obj.Timeout = 0
    end
end

-- 禁止和使能链路访问
function app_objects:handle_bus_accessibility(obj, _, status, disable_duration)
    if obj.AccessEnabled and status then
        log:info('The current link access status is already enabled.')
        return
    end
    -- 禁用时间校验
    if disable_duration < MIN_DISABLE_DURATION or disable_duration > MAX_DISABLE_DURATION then
        log:raise(
            'Invalid Parameter! DisableDuration Range is:[%d, %d], current DisableDuration is %d',
            MIN_DISABLE_DURATION,
            MAX_DISABLE_DURATION,
            disable_duration
        )
    end
    local bus_name = self:get_bus_name(obj)
    local host_bus = self.buses[bus_name]

    self.thread_queue(function()
        self:porcess_accessibility(obj, host_bus, bus_name, status, disable_duration)
    end)
end

-- 主线程与工作线程写共享内存时序问题导致内存值与共享内存值不一致,需要在scanner对象上树时检查值一致
local scanner_map = { 'Status', 'Value' }
function app_objects:check_scanner_shm_value(object, object_name, chip_name)
    for _, value_name in ipairs(scanner_map) do
        local shm_prop_value = hw_utils.get_shm_prop(object.path, SCANNER_INTERFACE, value_name)

        if shm_prop_value and not table_compare(object[value_name], shm_prop_value) then
            local host_bus = self.chips[chip_name].host_bus
            host_bus.stream:send('update_scanner_shm_value', object_name, value_name)
        end
    end
end

function app_objects:object_register(object_name, chip_name)
    if not self.wait_register_objects[object_name] then
        log:mcf_error('object_register failed, %s not exist', object_name)
        return
    end

    local object = self.wait_register_objects[object_name]
    if object.register_mdb_objects then
        object:register_mdb_objects()
    end

    if object[SCANNER_INTERFACE] then
        local ok, err = pcall(self.check_scanner_shm_value, self, object, object_name, chip_name)
        if not ok then
            log:warn(
                'check scanner shm value failed, scanner name: %s, chip name: %s, err: %s',
                object_name,
                chip_name,
                err
            )
        end
    end

    self.wait_register_objects[object_name] = nil

    if self.wait_register_dft[object_name] then
        for _, obj in pairs(self.wait_register_dft[object_name]) do
            if obj.register_mdb_objects then
                obj:register_mdb_objects()
            end
        end
        self.wait_register_dft[object_name] = nil
    end
    log:mcf_debug('object: %s register to resource tree', object_name)
end

function app_objects:get_bus_object(bus_name)
    for _, objs in pairs(self.cache_objects) do
        for _, obj in pairs(objs) do
            if obj.name == bus_name then
                return obj
            end
        end
    end
end

function app_objects:plugin_request(obj, ctx, ...)
    local chip_name = self:get_chip_name(obj)
    local host_bus = self.chips[chip_name].host_bus
    return host_bus.stream:call('plugin_request', { path = obj.path }, ctx, ...)
end

-- 通过资源树模拟Scanner错误调整
function app_objects:mock_scanner_failure(obj, ctx, scanner_name, disable_duration)
    local chip = self.scanner_ref_chip[scanner_name]
    if not chip then
        log:raise('scanner %s not exist', scanner_name)
    end
    return chip.host_bus.stream:call('mock_scanner_failure', scanner_name, disable_duration)
end

function app_objects:mock_bus_ctrl(obj, ctx, bus_name, action)
    if not self.buses[bus_name] then
        log:raise('bus %s not exist', bus_name)
    end
    return skynet.call(self.buses[bus_name].stream.work, 'lua', 'mock_bus_ctrl', action)
end

function app_objects:monitor_obj(obj, ctx, action)
    local chip_name = self:get_chip_name(obj)
    local chip_obj = self.chips[chip_name]
    if not chip_obj then
        log:raise(string.format('obj %s does not exist', chip_name))
    end
    return chip_obj.host_bus.stream:call('monitor_obj', { path = obj.path, chip = obj.chip }, ctx, action)
end

function app_objects:trace_scanner_debounce(object, ctx, action)
    local scanner_name = self:get_object_name_from_path(object)
    local chip_obj = self.scanner_ref_chip[scanner_name]
    chip_obj.host_bus.stream:call('trace_scanner_debounce', { name = scanner_name }, ctx, action)
end

function app_objects:on_reboot_action()
    local ok, err, bus_obj_stream
    for _, bus_obj in pairs(self.buses) do
        bus_obj_stream = bus_obj.stream
        ok, err = pcall(bus_obj_stream.call, bus_obj_stream, 'on_reboot_action')
        if not ok then
            log:warn('on_reboot_action failed bus_name: %s, err: %s', bus_obj.name, err)
        end
    end
end

local add_object_to_bus = function(bus_obj, object, position, bus_object_name)
    if bus_obj.name ~= bus_object_name then
        return
    end
    bus_obj:add_object(object.class_name, object, position)
end

local function restart_bus_service(self, bus_obj, bus_object_name)
    local tree = shared_object.create_tree()
    bus_obj:set_raw_dbus(self.dbus.bus.conn:to_raw(true), tree:to_raw())
    for _, position in ipairs(self.cache_position) do
        for _, object in pairs(self.cache_objects[position]) do
            local name = object.name
            for _, v in pairs(self.bus_objects[name] or {}) do
                add_object_to_bus(v, object, position, bus_object_name)
            end
        end
        skynet.send(self.monitor_service, 'lua', 'add_work_monitor', bus_object_name, position)
        bus_obj:add_object_complete(position, self.topo_data[position], self.monitor_service)
    end
end

function app_objects:restart_work_service(bus_name)
    local merge_key = self.bus_name_to_merge_key[bus_name]
    local group_key = merge_key or bus_name
    local addr = skynet.newservice('hwproxy/service/work', bus_name)
    local ok, err = pcall(function(...)
        if self.merge_work_bus[group_key] then
            -- 同步刷新分组缓存的work服务地址, 避免重启后新建的同组通道拿到已被kill的旧地址
            bus.update_work_addr(group_key, addr)
            local bus_obj
            -- 遍历合并的总线,并创建相应的总线代理对象
            for _, v in pairs(self.merge_work_bus[group_key]) do
                bus_obj = self.buses[v]
                bus_obj.stream.work = addr
                bus_obj.stream:send('create_hwproxy_object', v)
                restart_bus_service(self, bus_obj, v)
            end
            if bus_obj then
                sync_telemetry(bus_obj)
            end
        else
            local bus_obj = self.buses[bus_name]
            bus_obj.stream.work = addr
            bus_obj.stream:send('create_hwproxy_object', bus_name)
            sync_telemetry(bus_obj)
            restart_bus_service(self, bus_obj, bus_name)
        end
    end)
    if not ok then
        log:error('restart work service failed, error: %s', err)
    end
    return addr
end

return app_objects