/*
 * Copyright (c) 2023 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.
 */

#include "smc.h"
#include <functional>
#include <mc/crypto/crc8.h>
#include <mc/exception.h>
#include <unistd.h>
#include "securec.h"

using namespace dev;

namespace {
const uint32_t SMC_MAX_DATA_LENGTH = 255;

const uint32_t SMC_MAX_BUFFER_LEN           = SMC_MAX_DATA_LENGTH + 5;
const uint32_t SMC_MIN_READ_LEN             = 2;
const uint32_t SMC_FORWARD_READ_LEN         = 3;
const uint32_t SMC_DEFAULT_READ_LEN         = 8;
const uint32_t SMC_MAX_BYTE_READ_SIZE       = 4;
const uint32_t BITS_PER_BYTE                = 8;
const uint32_t SMC_EXTRA_LEN                = 1;
const uint32_t SMC_READ_LEN_OFFSET          = 3;
const uint32_t SMC_READ_CC_OFFSET           = SMC_READ_LEN_OFFSET + 1;
const uint32_t SMC_READ_DATA_OFFSET         = SMC_READ_CC_OFFSET + 1;
const uint32_t SMC_RESP_RAW_READ_LEN_OFFSET = 0x00;
const uint32_t SMC_RESP_RAW_CC_OFFSET       = 0x01;
const uint32_t SMC_MCTP_READ_LEN_OFFSET     = 0x00;
const uint32_t SMC_MCTP_CC_OFFSET           = 0x01;
const uint32_t SMC_MCTP_DATA_OFFSET         = 0x03;
const uint32_t SMC_MCTP_CC_MASK             = 0x0F;
const uint32_t SMC_MCTP_READ_EXTRA_LEN      = 4;
const uint32_t SMC_MCTP_MAX_RETRIES         = 5;

const uint8_t PROTOCOL_MCTP_OVER_SMC = 0x03;
const uint8_t FORWARD_TYPE_MCTP      = 0x02;
const uint8_t FORWARD_TYPE_SMC       = 0x01;

// 重试轮数与退避序列对齐 Lua 版 smc.lua do_read:6 轮,读前睡眠 2^i ms(2,4,8,16,32,64)
const uint32_t SMC_LISTEN_TIMES = 6;
const uint32_t SMC_SLEEP_TIME   = 5000;

const uint32_t SMC_MULTI_MASK  = 0x200;
const uint32_t SMC_RW_MASK     = 0x100;
const uint32_t SMC_OPCODE_MASK = 0xfffffc00;
const uint32_t SMC_PARA_MASK   = 0xff;

const uint32_t SMC_SET_TEST_REG = 0x2200;
const uint32_t SMC_GET_TEST_REG = 0x2100;
const uint32_t SMC_TEST_MASK    = 0xff;

inline static uint8_t chip_smc_get_first_nonzero_pos(uint32_t mask)
{
    return __builtin_ctz(mask);
}

template <typename T>
inline static T chip_smc_set_value_with_mask(uint32_t mask, T oriData, T setData)
{
    uint8_t shift = chip_smc_get_first_nonzero_pos(mask);
    return static_cast<T>((mask & (setData << shift)) | (oriData & (~mask)));
}

template <typename T>
inline static T chip_smc_get_value_with_mask(uint32_t mask, T oriData)
{
    uint8_t shift = chip_smc_get_first_nonzero_pos(mask);
    return static_cast<T>((oriData & mask) >> shift);
}
}; // namespace

bool chip_smc::init(mc::mutable_dict& csr_object)
{
    try {
        // 调用chip_base的init函数
        chip_base::init(csr_object);
    } catch (const std::exception& e) {
        elog("SMC configuration loading failed: ${error}", ("error", e.what()));
        return false;
    }

    return true;
}

int32_t chip_smc::chip_test(uint32_t* result)
{
    try {
        std::vector<uint8_t> write_data = {0xAA};
        std::vector<uint8_t> out_buffer;
        std::string          error;

        int32_t ret = bit_write(SMC_SET_TEST_REG, 1, SMC_TEST_MASK, write_data, out_buffer, error);
        if (ret != HAS_OK) {
            elog("${name} smc-selfTest failed: The writing operation failed, err: ${error}",
                 ("name", get_object_name())("error", error));
            if (result) {
                *result = 0;
            }
            return HAS_ERR;
        }

        std::vector<uint8_t> in_buffer;
        std::vector<uint8_t> read_buffer;
        ret = bit_read(SMC_GET_TEST_REG, 1, SMC_TEST_MASK, in_buffer, read_buffer, error);
        if (ret != HAS_OK) {
            elog("${name} smc-selfTest failed: The reading operation failed, err: ${error}",
                 ("name", get_object_name())("error", error));
            if (result) {
                *result = 0;
            }
            return HAS_ERR;
        }

        if (read_buffer != write_data) {
            elog("${name} smc-selfTest failed: The data written and read are inconsistent",
                 ("name", get_object_name()));
            if (result) {
                *result = 0;
            }
            return HAS_ERR;
        }

        if (result) {
            *result = 1;
        }
        return HAS_OK;
    } catch (const std::exception& e) {
        elog("${name} smc-selfTest exception: ${error}", ("name", get_object_name())("error", e.what()));
        if (result) {
            *result = 0;
        }
        return HAS_ERR;
    }
}

int32_t chip_smc::bit_read(uint32_t offset, uint8_t size, uint32_t mask, std::vector<uint8_t>& in_buffer,
                           std::vector<uint8_t>& out_buffer, std::string& error)
{
    if (size == 0 || size == 3 || size > SMC_MAX_BYTE_READ_SIZE) {
        error = "request error, invalid input length: " + std::to_string(size);
        return HAS_ERR;
    }

    if (mask == 0) {
        out_buffer.clear();
        return HAS_OK;
    }

    out_buffer.clear();

    uint8_t  read_buffer[SMC_MAX_BUFFER_LEN] = {0};
    uint32_t ret = normal_read((offset & SMC_OPCODE_MASK) + 0x100, SMC_MAX_BUFFER_LEN, read_buffer, error);
    if (ret != HAS_OK) {
        return ret;
    }

    uint32_t para = offset & SMC_PARA_MASK;
    if (para > 0) {
        para--;
    }

    const uint32_t response_length = read_buffer[SMC_READ_LEN_OFFSET];
    if (response_length < SMC_EXTRA_LEN) {
        error = "response error, invalid smc response length";
        return HAS_ERR;
    }
    const uint32_t data_length = response_length - SMC_EXTRA_LEN;
    if (para * size + size > data_length) {
        error = "request error, error para, para: " + std::to_string(para) + ", size: " + std::to_string(size) +
                ", read_len: " + std::to_string(data_length);
        return HAS_ERR;
    }

    uint8_t* dataBuf = read_buffer + SMC_READ_DATA_OFFSET + para * size;

    // SMC register payloads are little-endian byte sequences.
    uint32_t raw_value = 0;
    for (uint8_t i = 0; i < size; ++i) {
        raw_value |= static_cast<uint32_t>(dataBuf[i]) << (BITS_PER_BYTE * i);
    }
    const uint32_t value = chip_smc_get_value_with_mask(mask, raw_value);
    for (uint8_t i = 0; i < size; ++i) {
        out_buffer.push_back(static_cast<uint8_t>(value >> (BITS_PER_BYTE * i)));
    }

    return HAS_OK;
}

int32_t chip_smc::bit_write(uint32_t offset, uint8_t size, uint32_t mask, const std::vector<uint8_t>& in_buffer,
                            std::vector<uint8_t>& out_buffer, std::string& error)
{
    if (size == 0 || size == 3 || size > SMC_MAX_BYTE_READ_SIZE) {
        error = "request error, invalid input length: " + std::to_string(size);
        return HAS_ERR;
    }

    if (mask == 0) {
        return HAS_OK;
    }

    if (in_buffer.size() < size) {
        error = "request error, bit_write input length is shorter than size";
        return HAS_ERR;
    }

    uint32_t       para      = offset & SMC_PARA_MASK;
    const uint32_t full_mask = size == sizeof(uint32_t) ? UINT32_MAX : ((1U << (BITS_PER_BYTE * size)) - 1U);
    if (para == 0 && full_mask == mask) {
        // mask 全为1时不需要读取硬件值, 直接写入硬件
        return write(offset, size, in_buffer.data(), error);
    }

    if (para > 0) {
        para--;
    }

    uint8_t  read_buffer[SMC_MAX_BUFFER_LEN] = {0};
    uint32_t ret = normal_read((offset & SMC_OPCODE_MASK) + 0x100, SMC_MAX_BUFFER_LEN, read_buffer, error);
    if (ret != HAS_OK) {
        return ret;
    }

    const uint32_t response_length = read_buffer[SMC_READ_LEN_OFFSET];
    if (response_length < SMC_EXTRA_LEN) {
        error = "response error, invalid smc response length";
        return HAS_ERR;
    }
    const uint32_t data_length = response_length - SMC_EXTRA_LEN;
    if (para * size + size > data_length) {
        error = "bit_write para size overflow";
        return HAS_ERR;
    }

    uint8_t* dataBuf  = read_buffer + SMC_READ_DATA_OFFSET + para * size;
    uint32_t original = 0;
    uint32_t input    = 0;
    for (uint8_t i = 0; i < size; ++i) {
        original |= static_cast<uint32_t>(dataBuf[i]) << (BITS_PER_BYTE * i);
        input |= static_cast<uint32_t>(in_buffer[i]) << (BITS_PER_BYTE * i);
    }
    const uint32_t value = chip_smc_set_value_with_mask(mask, original, input);
    for (uint8_t i = 0; i < size; ++i) {
        dataBuf[i] = static_cast<uint8_t>(value >> (BITS_PER_BYTE * i));
    }

    return write(offset, size, dataBuf, error);
}

int32_t chip_smc::block_read(uint32_t offset, uint32_t length, std::vector<uint8_t>& in_buffer,
                             std::vector<uint8_t>& out_buffer, std::string& error)
{
    out_buffer.clear();

    auto ret = read(offset, length, out_buffer, error);
    out_buffer.shrink_to_fit();

    return ret;
}

int32_t chip_smc::block_write(uint32_t offset, const std::vector<uint8_t>& in_buffer, std::vector<uint8_t>& out_buffer,
                              std::string& error)
{
    return write(offset, in_buffer.size(), in_buffer.data(), error);
}

int32_t chip_smc::block_write_read(uint32_t offset, const std::vector<uint8_t>& indata, uint32_t read_length,
                                   std::vector<uint8_t>& out_buffer, std::string& error, uint8_t protocol_flag)
{
    if (protocol_flag != PROTOCOL_MCTP_OVER_SMC) {
        MC_THROW(mc::invalid_op_exception, "Chip SMC block_write_read not supported");
    }
    if (indata.empty()) {
        error = "request error, mctp write buffer is empty";
        return HAS_ERR;
    }
    if (read_length == 0) {
        error = "request error, mctp read length is zero";
        return HAS_ERR;
    }

    const uint8_t bus_id = m_host_bus ? m_host_bus->get_id() : m_channel_num;
    auto          ret    = forward_write_mctp(indata, bus_id, error);
    if (ret != HAS_OK) {
        return ret;
    }
    return forward_read_mctp(read_length, out_buffer, error);
}

uint32_t chip_smc::forward_write_mctp(const std::vector<uint8_t>& request, uint8_t bus_id, std::string& error)
{
    constexpr uint32_t FORWARD_OPCODE_WIDTH = 4;
    if (request.empty()) {
        error = "request error, mctp write buffer is empty";
        return HAS_ERR;
    }

    const uint32_t payload_length = FORWARD_OPCODE_WIDTH + request.size() - 1;
    if (payload_length > 250) {
        error = "request error, smc wrap exceed maximum payload length";
        return HAS_ERR;
    }

    const uint32_t forward_opcode = calc_forward_opcode(request.front(), 0, FORWARD_TYPE_MCTP, bus_id);
    const auto     payload        = request.size() > 1 ? request.data() + 1 : nullptr;

    return normal_write(forward_opcode, static_cast<uint32_t>(request.size() - 1), payload,
                        SMC_WRITE_OPCODE_FORWARD_MCTP, error);
}

uint32_t chip_smc::read_mctp_response(uint32_t length, std::vector<uint8_t>& response, std::string& error)
{
    if (length > UINT32_MAX - SMC_MCTP_READ_EXTRA_LEN) {
        error = "request error, mctp read length is too large";
        return HAS_ERR;
    }

    std::vector<uint8_t> in_buffer;
    response.clear();
    const uint32_t read_length = length + SMC_MCTP_READ_EXTRA_LEN;
    try {
        const auto ret =
            data_access(0, SMC_READ_BUFFER_FORWARD_MCTP, read_length, in_buffer, response, CHIP_OP_TYPE_READ);
        if (ret != HAS_OK) {
            error = "data_access failed";
        }
        return ret;
    } catch (const std::exception& e) {
        error = std::string("read_mctp_response error: ") + e.what();
        return HAS_ERR;
    }
}

uint32_t chip_smc::unwrap_mctp_response(const std::vector<uint8_t>& response, std::vector<uint8_t>& data_out,
                                        std::string& error)
{
    if (response.size() < SMC_MCTP_DATA_OFFSET + 1) {
        error = "response error, mctp response is too short";
        return HAS_ERR;
    }

    const uint32_t mctp_length     = response[SMC_MCTP_READ_LEN_OFFSET] + ((response[SMC_MCTP_CC_OFFSET] & 0xF0) << 4);
    const uint32_t response_length = mctp_length + 2;
    if (response_length < SMC_MCTP_DATA_OFFSET + 1 || response.size() < response_length) {
        error = "response error, mctp response length is invalid";
        return HAS_ERR;
    }

    std::string crc_input;
    crc_input.reserve(3 + response_length - 1);
    crc_input.push_back(static_cast<char>(m_address & 0xFE));
    crc_input.push_back(static_cast<char>(SMC_READ_BUFFER_FORWARD_MCTP));
    crc_input.push_back(static_cast<char>(m_address | 0x01));
    crc_input.append(response.begin(), response.begin() + response_length - 1);

    const uint8_t crc = mc::crypto::CRC8().calculate(crc_input);
    if (crc != response[response_length - 1]) {
        error = "request error, get crc: " + std::to_string(response[response_length - 1]) +
                ", real crc: " + std::to_string(crc);
        elog("${error}", ("error", error));
        return HAS_ERR;
    }

    data_out.assign(response.begin() + SMC_MCTP_DATA_OFFSET, response.begin() + response_length - 1);
    return HAS_OK;
}

uint32_t chip_smc::forward_read_mctp(uint32_t length, std::vector<uint8_t>& data_out, std::string& error)
{
    constexpr uint8_t SMC_CC_NEED_MORE = 6;
    data_out.clear();

    uint32_t not_ready_count = 0;
    while (not_ready_count < SMC_MCTP_MAX_RETRIES) {
        usleep((1U << (not_ready_count + 2)) * 1000);

        std::vector<uint8_t> response;
        const auto           ret = read_mctp_response(length, response, error);
        if (ret != HAS_OK) {
            return ret;
        }
        if (response.size() <= SMC_MCTP_CC_OFFSET) {
            error = "response error, mctp response is too short";
            return HAS_ERR;
        }

        const uint8_t completion_code = response[SMC_MCTP_CC_OFFSET] & SMC_MCTP_CC_MASK;
        {
            std::lock_guard<std::mutex> lock(m_status_mutex);
            m_last_smc_cc = completion_code;
        }
        if (completion_code == SMC_CC_NOT_READY) {
            ++not_ready_count;
            continue;
        }

        std::vector<uint8_t> response_data;
        if (completion_code == SMC_CC_NEED_MORE || completion_code == SMC_CC_SUCCESS) {
            const auto unwrap_ret = unwrap_mctp_response(response, response_data, error);
            if (unwrap_ret != HAS_OK) {
                return unwrap_ret;
            }
            data_out.insert(data_out.end(), response_data.begin(), response_data.end());
            if (completion_code == SMC_CC_SUCCESS) {
                return HAS_OK;
            }
            not_ready_count = 0;
            continue;
        }

        error = get_object_name() + " Smc read_forward_mctp: request error, " +
                std::string(smc_cc_to_string(completion_code)) +
                ", SMC completion code: " + std::to_string(completion_code);
        return HAS_ERR;
    }

    error = "read_forward_mctp failed, max listen times reached";
    return HAS_ERR;
}

uint32_t chip_smc::read_data(uint32_t read_length, uint8_t* out_buffer, uint8_t command_code, std::string& error)
{
    std::vector<uint8_t> in_buffer_vec;
    std::vector<uint8_t> out_buffer_vec;
    out_buffer_vec.reserve(read_length + SMC_READ_LEN_OFFSET);
    // 帧级校验顺序与 Lua 版 smc.lua do_read 对齐:先判帧是否有效(长度字段、截断、CRC),
    // 再看完成码。垃圾帧(如器件复位/升级窗口响应 buffer 未填充返回的全 0xFF)一律按
    // 暂时无效重试;只有器件明确给出的协议错误码 {1,3,4,5} 才是终态失败。
    // retry_status 记录最近一轮被判重试的帧状态,重试耗尽后随错误上抛,便于现场定位。
    std::string retry_status = "no response";
    for (uint32_t i = 0; i < SMC_LISTEN_TIMES; i++) {
        usleep((1 << (i + 1)) * 1000);

        try {
            uint32_t ret = data_access(0, command_code, read_length, in_buffer_vec, out_buffer_vec, CHIP_OP_TYPE_READ);
            if (ret != HAS_OK) {
                error = "data_access failed";
                elog("data_access failed, ret: ${ret}", ("ret", ret));
                return ret;
            }
        } catch (const std::exception& e) {
            error = std::string("read_data error: ") + e.what();
            elog("${error}", ("error", error));
            return HAS_ERR;
        }

        // reject 记录最近一轮被判重试的帧状态,重试耗尽后随错误上抛,便于现场定位
        auto reject = [&](const std::string& status) {
            retry_status = status;
            dlog("${name} Smc read_data: ${status}, round: ${round}",
                 ("name", get_object_name())("status", retry_status)("round", i));
        };

        // 防线一:长度字段缺失/为 0/为 0xFF,说明 buffer 是无效数据而非协议帧。
        // len==0xFF 与 Lua 版一致在此判垃圾:它是全 0xFF 垃圾帧的典型特征;若放行,
        // 扩长分支会把读取长度抬到 257 字节——实测超出 LocalBus 单次读取能力、
        // 被总线层直接拒绝,导致器件恢复后也无法读到有效帧。
        // 其余长度一律交给扩长分支,行为与 Lua 完全一致,不加额外守卫
        if (out_buffer_vec.size() <= SMC_RESP_RAW_CC_OFFSET) {
            reject("response too short");
            continue;
        }
        const uint8_t  completion_code = out_buffer_vec[SMC_RESP_RAW_CC_OFFSET];
        const uint32_t response_length = out_buffer_vec[SMC_RESP_RAW_READ_LEN_OFFSET];
        if (response_length == 0x00 || response_length == 0xFF) {
            reject("invalid smc response length " + std::to_string(response_length));
            continue;
        }

        const uint32_t frame_length = response_length + SMC_MIN_READ_LEN;
        if (frame_length > read_length) {
            reject("response length " + std::to_string(response_length) + " exceeds read length " +
                   std::to_string(read_length));
            read_length = frame_length;
            continue;
        }

        // 防线二:实际收到字节数不足,截断帧按无效数据重试
        if (out_buffer_vec.size() < frame_length) {
            reject("smc response length exceeds received bytes");
            continue;
        }

        out_buffer_vec.resize(frame_length);

        // 倒序插入, 拼凑原始响应数据计算响应crc
        out_buffer_vec.insert(out_buffer_vec.begin(), m_address | 1);
        out_buffer_vec.insert(out_buffer_vec.begin(), command_code);
        out_buffer_vec.insert(out_buffer_vec.begin(), m_address & ~1);

        // 防线三:CRC 先于完成码校验,垃圾帧在此拦截
        // 构建crc_input时去掉最后一个字节的响应crc
        std::string crc_input(out_buffer_vec.begin(), out_buffer_vec.end() - 1);
        uint8_t     crc8 = mc::crypto::CRC8().calculate(crc_input);
        if (crc8 != out_buffer_vec.back()) {
            reject("crc mismatch, crc8: " + std::to_string(crc8) +
                   ", expected: " + std::to_string(out_buffer_vec.back()));
            continue;
        }

        // 防线四:完成码。2=器件未就绪、>5=非协议定义值(如 0xFF 垃圾数据),均重试;
        // {1,3,4,5} 为协议定义错误,终态上报
        if (completion_code == SMC_CC_NOT_READY || completion_code > SMC_CC_MAX_NUMBER) {
            reject((completion_code == SMC_CC_NOT_READY)
                       ? "device not ready, SMC completion code:2"
                       : "undefined completion code " + std::to_string(completion_code));
            continue;
        }
        if (completion_code != SMC_CC_SUCCESS) {
            {
                std::lock_guard<std::mutex> lock(m_status_mutex);
                m_last_smc_cc = completion_code;
            }
            error = get_object_name() + " Smc read_data : request error, " +
                    std::string(smc_cc_to_string(completion_code)) +
                    " , SMC completion code:" + std::to_string(completion_code);
            ilog("${error}", ("error", error));
            return HAS_ERR;
        }

        // 将响应数据复制到输出缓冲区
        errno_t err = memcpy_s(out_buffer, SMC_MAX_BUFFER_LEN, out_buffer_vec.data(), out_buffer_vec.size());
        if (err != EOK) {
            error = "memcpy_s failed, err=" + std::to_string(err);
            elog("${error}", ("error", error));
            return HAS_ERR;
        }

        // 成功访问清除完成码归因:避免残留的终态 cc(如 4)叠加后续无关失败,
        // 误触发 i_chip 的连续失败降级;cc==0 不命中任何降级分支,代价为零
        {
            std::lock_guard<std::mutex> lock(m_status_mutex);
            m_last_smc_cc = SMC_CC_SUCCESS;
        }
        return HAS_OK;
    }

    // 重试耗尽仍无有效帧:本器件始终没有给出协议完成码,按无效完成码 0xFF 归因。
    // 说明:i_chip 健康降级分支要求 smc_cc==0xFF && status_code != HAS_OK,而 SMC 器件的
    // m_last_status_code 恒为 HAS_OK(chip.cpp data_access 显式排除 smc 类),故该分支当前
    // 不会被本路径触发;此处写 0xFF 的作用是确定性归因(清除残留的旧完成码,避免把本次
    // 垃圾帧耗尽误归因到历史协议错误)并供诊断/后续健康逻辑使用
    {
        std::lock_guard<std::mutex> lock(m_status_mutex);
        m_last_smc_cc = SMC_CC_INVALID;
    }
    error = "read_data failed, max listen times reached, last status: " + retry_status;
    elog("${error}", ("error", error));
    return HAS_ERR;
}

void chip_smc::get_length_from_map(uint32_t offset, uint32_t& record_length)
{
    auto it = m_opcode_length_map.find(offset);
    if (it != m_opcode_length_map.end()) {
        record_length = it->second;
    } else {
        record_length = SMC_DEFAULT_READ_LEN;
    }
}

void chip_smc::update_length_to_map(uint32_t offset, uint32_t length)
{
    m_opcode_length_map[offset & SMC_OPCODE_MASK] = length;
}

uint32_t chip_smc::read_from_hardware(uint32_t opcode, uint32_t out_length, uint8_t* out_buffer, std::string& error)
{
    uint32_t ret = write(opcode, 0, NULL, error);
    if (ret != HAS_OK) {
        ilog("${name} write failed, ret: ${ret}", ("name", get_object_name())("ret", ret));
        return ret;
    }

    uint32_t real_length = (out_length < SMC_MAX_DATA_LENGTH) ? out_length + SMC_MIN_READ_LEN : SMC_MIN_READ_LEN;

    return read_data(real_length, out_buffer, SMC_READ_BUFFER, error);
}

uint32_t chip_smc::normal_read(uint32_t offset, uint32_t buffer_length, uint8_t* buffer, std::string& error)
{
    uint32_t record_length = 0;
    get_length_from_map(offset, record_length);

    if (read_from_hardware(offset, record_length, buffer, error) != HAS_OK) {
        return HAS_ERR;
    }

    update_length_to_map(offset, buffer[SMC_READ_LEN_OFFSET]);
    return HAS_OK;
}

uint32_t chip_smc::normal_write(uint32_t offset, uint32_t length, const uint8_t* buffer, uint8_t command_code,
                                std::string& error)
{
    if (length > SMC_MAX_DATA_LENGTH - sizeof(offset)) {
        error = "request error, input length " + std::to_string(length) + " exceeds max " +
                std::to_string(SMC_MAX_DATA_LENGTH - sizeof(offset));
        return HAS_ERR;
    }

    std::string crc_input;
    crc_input += static_cast<char>(m_address);
    crc_input += static_cast<char>(command_code);
    crc_input += static_cast<char>(sizeof(length) + length);
    for (uint32_t i = sizeof(offset); i > 0; i--) {
        crc_input += static_cast<char>((offset >> ((i - 1) * 8)) & 0xFF);
    }
    if (length != 0) {
        crc_input += std::string(reinterpret_cast<const char*>(buffer), length);
    }

    uint8_t crc8 = mc::crypto::CRC8().calculate(crc_input);
    crc_input += static_cast<char>(crc8);

    // 跳过前两个字节,因为前两个字节是地址和命令码, 命令码作为offset直接使用
    std::vector<uint8_t> in_buffer_vec(crc_input.begin() + 2, crc_input.end());
    std::vector<uint8_t> out_buffer_vec;

    try {
        uint32_t ret =
            data_access(0, crc_input[1], in_buffer_vec.size(), in_buffer_vec, out_buffer_vec, CHIP_OP_TYPE_WRITE);
        if (ret != HAS_OK) {
            error = "data_access failed";
        }
        return ret;
    } catch (const std::exception& e) {
        error = std::string("normal_write error: ") + e.what();
        elog("${error}", ("error", error));
        return HAS_ERR;
    }
}

uint32_t chip_smc::read(uint32_t offset, uint32_t length, std::vector<uint8_t>& buffer, std::string& error)
{
    if (length == 0) {
        return HAS_ERR;
    }

    uint8_t  read_buffer[SMC_MAX_BUFFER_LEN] = {0};
    uint32_t ret                             = normal_read(offset, SMC_MAX_BUFFER_LEN, read_buffer, error);
    if (ret != HAS_OK) {
        ilog("${name} normal_read failed, offset: ${offset}, ret: ${ret}, error: ${error}",
             ("name", get_object_name())("offset", offset)("ret", static_cast<int32_t>(ret))("error", error));
        return ret;
    }

    const uint32_t response_length = read_buffer[SMC_READ_LEN_OFFSET];
    const uint32_t data_length     = response_length > 0 ? response_length - 1 : 0;

    buffer.assign(length, 0);
    for (uint32_t i = 0; i < length && i < data_length; i++) {
        buffer[i] = read_buffer[i + SMC_READ_DATA_OFFSET];
    }
    return HAS_OK;
}

uint32_t chip_smc::write(uint32_t offset, uint32_t length, const uint8_t* buffer, std::string& error)
{
    uint8_t command_code = (length == 0) ? SMC_WRITE_OPCODE : SMC_WRITE_OPCODE_WITH_DATA;

    return normal_write(offset, length, buffer, command_code, error);
}

uint32_t chip_smc::forward_read(uint32_t length, std::vector<uint8_t>& data_out)
{
    uint8_t out_buffer[SMC_MAX_BUFFER_LEN] = {0};

    std::string error;
    uint32_t    read_length = (length < SMC_MAX_DATA_LENGTH) ? length + SMC_FORWARD_READ_LEN : SMC_FORWARD_READ_LEN;
    uint32_t    ret         = read_data(read_length, out_buffer, SMC_READ_BUFFER_FORWARD, error);
    if (ret != HAS_OK) {
        elog("forward_read failed: read_data failed, ret=${ret}, length=${length}", ("ret", ret)("length", length));
        return ret;
    }

    const uint32_t response_length = out_buffer[SMC_READ_LEN_OFFSET];
    if (response_length < SMC_EXTRA_LEN ||
        response_length - SMC_EXTRA_LEN > SMC_MAX_BUFFER_LEN - SMC_READ_DATA_OFFSET) {
        elog("forward_read failed: invalid smc response length");
        return HAS_ERR;
    }
    const uint32_t actual_length = std::min(length, response_length - SMC_EXTRA_LEN);
    data_out.resize(actual_length);
    for (uint32_t i = 0; i < actual_length; i++) {
        data_out[i] = out_buffer[i + SMC_READ_DATA_OFFSET];
    }

    return ret;
}

uint32_t chip_smc::forward_write(uint32_t offset, uint32_t length, uint8_t* buffer)
{
    std::string error;
    return normal_write(offset, length, buffer, SMC_WRITE_OPCODE_FORWARD, error);
}

uint32_t chip_smc::calc_forward_opcode(uint8_t addr, uint32_t length, uint8_t chip_type, uint8_t bus_id)
{
    constexpr uint32_t ADDR_LEFT_SHIFT      = 24;
    constexpr uint32_t LEN_LEFT_SHIFT       = 16;
    constexpr uint32_t CHIP_TYPE_LEFT_SHIFT = 10;
    constexpr uint32_t BUS_ID_LEFT_SHIFT    = 0;
    uint32_t           offset               = 0;

    offset |= (addr << ADDR_LEFT_SHIFT);
    offset |= (length << LEN_LEFT_SHIFT);
    offset |= (chip_type << CHIP_TYPE_LEFT_SHIFT);
    offset |= (bus_id << BUS_ID_LEFT_SHIFT);

    return offset;
}

int32_t chip_smc::forward_by_front_chip(ACCESS_DATA_S& data, const std::string& class_name, uint8_t bus_id)
{
    const ACCESS_DATA_S* previous_trace_context = set_forward_trace_context(data.trace_enabled ? &data : nullptr);
    struct scope_exit {
        std::function<void()> fn;
        ~scope_exit()
        {
            fn();
        }
    } reset_trace_context{[this, previous_trace_context]() {
        set_forward_trace_context(previous_trace_context);
    }};

    constexpr uint32_t BUFFER_LEN = 250;
    bool               is_smc     = class_name == "smc";
    int                result     = HAS_OK;
    if (data.protocol_flag == PROTOCOL_MCTP_OVER_SMC) {
        std::string error;
        result = forward_write_mctp(data.in_buffer, bus_id, error);
        if (result != HAS_OK || data.optype == CHIP_OP_TYPE_WRITE) {
            if (result != HAS_OK) {
                elog("forward MCTP write failed: ${error}", ("error", error));
            }
            return result;
        }
        if (data.optype != CHIP_OP_TYPE_READ) {
            return HAS_ERR;
        }
        return forward_read_mctp(data.length, data.out_buffer, error);
    }

    if (data.offset_width > sizeof(data.offset)) {
        elog("forward request has invalid offset width: ${width}", ("width", data.offset_width));
        return HAS_ERR;
    }

    if (data.optype == CHIP_OP_TYPE_WRITE) {
        uint8_t buffer[BUFFER_LEN] = {0};
        uint8_t chip_type          = is_smc ? FORWARD_TYPE_SMC : 0x00;

        if (data.length > data.in_buffer.size() || data.length > BUFFER_LEN - data.offset_width) {
            elog("forward write length exceeds input or buffer capacity");
            return HAS_ERR;
        }

        uint32_t offset        = calc_forward_opcode(data.addr, data.length, chip_type, bus_id);
        uint32_t buffer_offset = 0;
        for (uint32_t i = data.offset_width; i > 0; i--) {
            buffer[buffer_offset++] = (data.offset >> ((i - 1) * 8)) & 0xFF;
        }

        errno_t err = memcpy_s(buffer + buffer_offset, BUFFER_LEN - buffer_offset, data.in_buffer.data(), data.length);
        if (err != 0) {
            elog("memcpy_s failed in forward_by_front_chip, err=${err}", ("err", err));
            return HAS_ERR;
        }

        return forward_write(offset, data.length + buffer_offset, buffer);
    }

    // 如果是eeprom, 要补上写操作, 主要就是需要写offset
    if (!is_smc) {
        uint8_t buffer[BUFFER_LEN] = {0};
        uint8_t chip_type          = 0x00;

        uint32_t offset        = calc_forward_opcode(data.addr | 0x01, data.length, chip_type, bus_id);
        uint32_t buffer_offset = 0;

        if (data.offset == CHIP_EXTEND_READ_MODE) {
            // 扩展读(BlockIO.WriteRead / bmc.kepler.Chip.BlockIO.WriteRead):器件层用
            // offset == 0xFFFFFFFF 作为“写后读”哨兵,真正要下发给目标器件的数据在
            // in_buffer 里。对齐 Lua smc_write_forward 的 extend 分支(input.buffer,
            // offsetWidth 为 0 时即只下发 input.buffer):这里必须把 in_buffer 作为
            // 转发写 payload,且不能把哨兵值当成目标器件寄存器地址下发,否则 SMC 只会
            // 空写一次(或写 0xFF)再读,目标器件返回全 0xFF。
            if (data.in_buffer.empty()) {
                // 空 payload 只会得到一次 0 长度空转发写,静默复现“空写后读回全 0xFF”,
                // 属于非法请求,显式报错。
                elog("forward_by_front_chip extend read with empty in_buffer, addr: ${addr}", ("addr", data.addr));
                return HAS_ERR;
            }
            errno_t err = memcpy_s(buffer, BUFFER_LEN, data.in_buffer.data(), data.in_buffer.size());
            if (err != 0) {
                elog("memcpy_s failed in forward_by_front_chip extend read, err=${err}", ("err", err));
                return HAS_ERR;
            }
            buffer_offset = static_cast<uint32_t>(data.in_buffer.size());
        } else {
            for (uint32_t i = data.offset_width; i > 0; i--) {
                buffer[buffer_offset++] = (data.offset >> ((i - 1) * 8)) & 0xFF;
            }
        }

        result = forward_write(offset, buffer_offset, buffer);
        if (result != HAS_OK) {
            return result;
        }
        usleep(SMC_SLEEP_TIME);
    }

    return forward_read(data.length, data.out_buffer);
}

const char* chip_smc::get_class_name() const
{
    return "smc";
}