/*
 * Copyright (c) 2024 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 "uart.h"
#include <chrono>
#include <cstring>
#include <mc/exception.h>
#include <mc/log.h>
#include <mutex>
#include <poll.h>
#include <thread>

using namespace dev;

static std::mutex uart_connect_mutex;

bus_uart::bus_uart()
    : m_channel_id(0), m_baudrate(UART_DEFAULT_BAUDRATE), m_databits(UART_DEFAULT_DATABITS),
      m_stopbits(UART_DEFAULT_STOPBITS), m_parity(UartParity::None), m_fd(-1), m_device_open(false)
{}

bus_uart::~bus_uart()
{
    close_device();
}

bool bus_uart::init(mc::mutable_dict& csr_object)
{
    try {
        if (csr_object.contains("ChannelId")) {
            m_channel_id = csr_object["ChannelId"].as<uint8_t>();
            if (m_channel_id > UART_MAX_CHANNEL_ID) {
                MC_THROW(mc::invalid_arg_exception, "ChannelId must be 0~14");
            }
        }
        if (csr_object.contains("BaudRate")) {
            m_baudrate = csr_object["BaudRate"].as<uint32_t>();
            if (!validate_baudrate(m_baudrate)) {
                MC_THROW(mc::invalid_arg_exception, "Invalid BaudRate value");
            }
        }
        if (csr_object.contains("object_name")) {
            m_object_name = csr_object["object_name"].as<std::string>();
        }

        m_device_path = get_device_path();
        m_class_name  = "Uart";

        return open_device();
    } catch (const std::exception& e) {
        elog("Uart init failed, exception: ${exception}", ("exception", e.what()));
        return false;
    }
}

std::string bus_uart::get_device_path()
{
    return "/dev/ttySS" + std::to_string(m_channel_id);
}

bool bus_uart::open_device()
{
    if (m_device_open) {
        return true;
    }

    m_fd = open(m_device_path.c_str(), O_RDWR | O_NOCTTY | O_NDELAY);
    if (m_fd < 0) {
        elog("Failed to open uart device: ${path}", ("path", m_device_path));
        return false;
    }

    if (tcgetattr(m_fd, &m_old_termios) < 0) {
        elog("Failed to get uart attributes");
        close(m_fd);
        m_fd = -1;
        return false;
    }

    if (!configure_termios()) {
        close(m_fd);
        m_fd = -1;
        return false;
    }

    m_device_open = true;
    dlog("Uart device opened: ${path}", ("path", m_device_path));
    return true;
}

void bus_uart::close_device()
{
    if (m_device_open && m_fd >= 0) {
        tcsetattr(m_fd, TCSANOW, &m_old_termios);
        close(m_fd);
        m_fd          = -1;
        m_device_open = false;
    }
}

bool bus_uart::configure_termios(FlushMode flush_mode)
{
    auto     start_time = std::chrono::steady_clock::now();
    uint64_t start_ms   = std::chrono::duration_cast<std::chrono::milliseconds>(start_time.time_since_epoch()).count();
    dlog("UART TIMING: configure_termios START - parity=${p}, flush_mode=${f}, time=${time}ms",
         ("p", static_cast<int>(m_parity))("f", static_cast<int>(flush_mode))("time", start_ms));

    tcgetattr(m_fd, &m_current_termios);

    cfmakeraw(&m_current_termios);
    m_current_termios.c_cflag |= CREAD | CLOCAL;

    m_current_termios.c_cflag &= ~CSIZE;
    switch (m_databits) {
        case 5:
            m_current_termios.c_cflag |= CS5;
            break;
        case 6:
            m_current_termios.c_cflag |= CS6;
            break;
        case 7:
            m_current_termios.c_cflag |= CS7;
            break;
        case 8:
            m_current_termios.c_cflag |= CS8;
            break;
        default:
            m_current_termios.c_cflag |= CS8;
            break;
    }

    m_current_termios.c_cflag &= ~(PARENB | PARODD | CMSPAR);
    if (m_parity == UartParity::Even) {
        m_current_termios.c_cflag |= PARENB;
    } else if (m_parity == UartParity::Odd) {
        m_current_termios.c_cflag |= PARENB | PARODD;
    } else if (m_parity == UartParity::Mark) {
        m_current_termios.c_cflag |= PARENB | PARODD | CMSPAR;
    } else if (m_parity == UartParity::Space) {
        m_current_termios.c_cflag |= PARENB | CMSPAR;
    }

    m_current_termios.c_cflag &= ~CSTOPB;
    if (m_stopbits == 2) {
        m_current_termios.c_cflag |= CSTOPB;
    }

    cfsetispeed(&m_current_termios, baudrate_to_speed(m_baudrate));
    cfsetospeed(&m_current_termios, baudrate_to_speed(m_baudrate));

    m_current_termios.c_cc[VMIN]  = 0;
    m_current_termios.c_cc[VTIME] = 0;

    if (m_parity == UartParity::Mark) {
        m_current_termios.c_iflag |= INPCK;
        m_current_termios.c_iflag &= ~IGNPAR;
        m_current_termios.c_iflag |= PARMRK;
        dlog("UART PARITY CONFIG: Mark parity - INPCK=1, IGNPAR=0, PARMRK=1 (MARK Space parity data with 0xFF 0x00 "
             "prefix, preserve fan response)");
    } else if (m_parity == UartParity::Space) {
        m_current_termios.c_iflag &= ~INPCK;
        m_current_termios.c_iflag &= ~IGNPAR;
        m_current_termios.c_iflag &= ~PARMRK;
        dlog("UART PARITY CONFIG: Space parity - INPCK=0, IGNPAR=0, PARMRK=0 (ACCEPT all data for fan response)");
    } else {
        m_current_termios.c_iflag &= ~INPCK;
        m_current_termios.c_iflag &= ~IGNPAR;
        m_current_termios.c_iflag &= ~PARMRK;
        dlog("UART PARITY CONFIG: Parity=${p} - INPCK=0, IGNPAR=0, PARMRK=0", ("p", static_cast<int>(m_parity)));
    }

    if (tcsetattr(m_fd, TCSADRAIN, &m_current_termios) < 0) {
        elog("Failed to set uart attributes");
        return false;
    }

    dlog("UART DIAGNOSTIC: flush_mode=${mode} (0=NONE, 1=INPUT, 2=OUTPUT, 3=BOTH)",
         ("mode", static_cast<uint32_t>(flush_mode)));

    // 记录diagnose耗时
    auto     diag_start = std::chrono::steady_clock::now();
    uint64_t diag_start_ms =
        std::chrono::duration_cast<std::chrono::milliseconds>(diag_start.time_since_epoch()).count();
    dlog("UART TIMING: diagnose_parity_settings START - elapsed=${elapsed}ms", ("elapsed", diag_start_ms - start_ms));

    diagnose_parity_settings(); // 简要模式

    auto     diag_end    = std::chrono::steady_clock::now();
    uint64_t diag_end_ms = std::chrono::duration_cast<std::chrono::milliseconds>(diag_end.time_since_epoch()).count();
    dlog("UART TIMING: diagnose_parity_settings(brief) OK - elapsed=${elapsed}ms",
         ("elapsed", diag_end_ms - diag_start_ms));

    auto     flush_start = std::chrono::steady_clock::now();
    uint64_t flush_start_ms =
        std::chrono::duration_cast<std::chrono::milliseconds>(flush_start.time_since_epoch()).count();

    switch (flush_mode) {
        case FlushMode::NONE:
            dlog("UART DIAGNOSTIC: FLUSH_NONE - skipping flush");
            break;
        case FlushMode::INPUT:
            dlog("UART DIAGNOSTIC: FLUSH_INPUT - tcflush(TCIFLUSH)");
            tcflush(m_fd, TCIFLUSH);
            break;
        case FlushMode::OUTPUT:
            dlog("UART DIAGNOSTIC: FLUSH_OUTPUT - tcflush(TCOFLUSH)");
            tcflush(m_fd, TCOFLUSH);
            break;
        case FlushMode::BOTH:
            dlog("UART DIAGNOSTIC: FLUSH_BOTH - tcflush(TCIOFLUSH)");
            tcflush(m_fd, TCIOFLUSH);
            break;
    }

    auto     flush_end    = std::chrono::steady_clock::now();
    uint64_t flush_end_ms = std::chrono::duration_cast<std::chrono::milliseconds>(flush_end.time_since_epoch()).count();
    dlog("UART TIMING: flush complete - elapsed=${elapsed}ms", ("elapsed", flush_end_ms - flush_start_ms));

    auto     end_time = std::chrono::steady_clock::now();
    uint64_t end_ms   = std::chrono::duration_cast<std::chrono::milliseconds>(end_time.time_since_epoch()).count();
    dlog("UART TIMING: configure_termios COMPLETE - total_time=${total}ms", ("total", end_ms - start_ms));

    return true;
}

bool bus_uart::validate_baudrate(uint32_t baudrate)
{
    for (auto valid_baud : UART_VALID_BAUDRATES) {
        if (baudrate == valid_baud) {
            return true;
        }
    }
    return false;
}

speed_t bus_uart::baudrate_to_speed(uint32_t baudrate)
{
    switch (baudrate) {
        case 115200:
            return B115200;
        case 57600:
            return B57600;
        case 38400:
            return B38400;
        case 19200:
            return B19200;
        case 9600:
            return B9600;
        case 4800:
            return B4800;
        case 2400:
            return B2400;
        case 1800:
            return B1800;
        case 1200:
            return B1200;
        default:
            return B115200;
    }
}

bool bus_uart::set_baudrate(uint32_t baudrate, FlushMode flush_mode)
{
    if (!validate_baudrate(baudrate)) {
        return false;
    }
    m_baudrate = baudrate;
    return configure_termios(flush_mode);
}

bool bus_uart::set_parity(UartParity parity, FlushMode flush_mode)
{
    // 记录开始时间戳
    auto     start_time = std::chrono::steady_clock::now();
    uint64_t start_ms   = std::chrono::duration_cast<std::chrono::milliseconds>(start_time.time_since_epoch()).count();

    dlog("UART TIMING: set_parity START - parity=${p}, flush_mode=${f}, time=${time}ms",
         ("p", static_cast<int>(parity))("f", static_cast<int>(flush_mode))("time", start_ms));

    int rx_bytes_before = 0;
    int rx_bytes_after  = 0;

    if (flush_mode != FlushMode::NONE && m_fd >= 0) {
        ioctl(m_fd, FIONREAD, &rx_bytes_before);
        auto     flush_check_time = std::chrono::steady_clock::now();
        uint64_t flush_check_ms =
            std::chrono::duration_cast<std::chrono::milliseconds>(flush_check_time.time_since_epoch()).count();
        dlog("UART TIMING: set_parity PRE_FLUSH_CHECK - parity=${p}, rx_bytes=${bytes}, elapsed=${elapsed}ms",
             ("p", static_cast<int>(parity))("bytes", rx_bytes_before)("elapsed", flush_check_ms - start_ms));
    }

    // 记录configure_termios开始时间
    auto     config_start_time = std::chrono::steady_clock::now();
    uint64_t config_start_ms =
        std::chrono::duration_cast<std::chrono::milliseconds>(config_start_time.time_since_epoch()).count();
    dlog("UART TIMING: set_parity CONFIG_START - elapsed=${elapsed}ms", ("elapsed", config_start_ms - start_ms));

    m_parity    = parity;
    bool result = configure_termios(flush_mode);

    // 记录configure_termios完成时间
    auto     config_end_time = std::chrono::steady_clock::now();
    uint64_t config_end_ms =
        std::chrono::duration_cast<std::chrono::milliseconds>(config_end_time.time_since_epoch()).count();
    dlog("UART TIMING: set_parity CONFIG_END - result=${res}, elapsed=${elapsed}ms (configure_termios took "
         "${config_time}ms)",
         ("res", result)("elapsed", config_end_ms - start_ms)("config_time", config_end_ms - config_start_ms));

    if (flush_mode != FlushMode::NONE && m_fd >= 0) {
        ioctl(m_fd, FIONREAD, &rx_bytes_after);
        auto     flush_end_time = std::chrono::steady_clock::now();
        uint64_t flush_end_ms =
            std::chrono::duration_cast<std::chrono::milliseconds>(flush_end_time.time_since_epoch()).count();
        dlog("UART TIMING: set_parity POST_FLUSH - flushed ${flushed} bytes, elapsed=${elapsed}ms",
             ("flushed", rx_bytes_before - rx_bytes_after)("elapsed", flush_end_ms - start_ms));
    }

    // 记录总耗时
    auto     end_time = std::chrono::steady_clock::now();
    uint64_t end_ms   = std::chrono::duration_cast<std::chrono::milliseconds>(end_time.time_since_epoch()).count();
    dlog("UART TIMING: set_parity COMPLETE - parity=${p}, total_time=${total}ms",
         ("p", static_cast<int>(parity))("total", end_ms - start_ms));

    return result;
}

bool bus_uart::set_databits(uint8_t databits, FlushMode flush_mode)
{
    if (databits < 5 || databits > 8) {
        return false;
    }
    m_databits = databits;
    return configure_termios(flush_mode);
}

bool bus_uart::set_stopbits(uint8_t stopbits, FlushMode flush_mode)
{
    if (stopbits < 1 || stopbits > 2) {
        return false;
    }
    m_stopbits = stopbits;
    return configure_termios(flush_mode);
}

bool bus_uart::set_config(const UartConfig& config, FlushMode flush_mode)
{
    if (!validate_baudrate(config.baudrate)) {
        return false;
    }
    if (config.databits < 5 || config.databits > 8) {
        return false;
    }
    if (config.stopbits < 1 || config.stopbits > 2) {
        return false;
    }

    m_baudrate = config.baudrate;
    m_databits = config.databits;
    m_stopbits = config.stopbits;
    m_parity   = config.parity;

    return configure_termios(flush_mode);
}

UartConfig bus_uart::get_config()
{
    UartConfig config;
    config.baudrate = m_baudrate;
    config.databits = m_databits;
    config.stopbits = m_stopbits;
    config.parity   = m_parity;
    return config;
}

int bus_uart::uart_read(uint8_t* buffer, uint32_t length, uint32_t timeout_ms)
{
    if (!m_device_open || m_fd < 0) {
        return -1;
    }

    struct pollfd pfd;
    pfd.fd     = m_fd;
    pfd.events = POLLIN;

    int ret = poll(&pfd, 1, timeout_ms);
    if (ret <= 0) {
        return ret;
    }

    ssize_t bytes_read = ::read(m_fd, buffer, length);
    return static_cast<int>(bytes_read);
}

int bus_uart::uart_write(const uint8_t* buffer, uint32_t length, uint32_t timeout_ms)
{
    if (!m_device_open || m_fd < 0) {
        return -1;
    }

    if (length > 0) {
        dlog("UART DIAG: uart_write PRE_SEND - fd=${fd}, length=${len}, first_byte=0x${byte:02X}, timeout=${timeout}ms",
             ("fd", m_fd)("len", length)("byte", buffer[0])("timeout", timeout_ms));
    }

    // 循环写: 设备以 O_NDELAY 打开时单次 write 可能只写入部分字节(短写),
    // 在总体超时预算内 poll+write 迭代直到写满/失败/预算耗尽。
    // 返回累计写入字节数(可能小于 length, 由上层按短写判错)。
    uint32_t total_written = 0;
    auto     deadline      = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms);

    while (total_written < length) {
        auto remaining_ms =
            std::chrono::duration_cast<std::chrono::milliseconds>(deadline - std::chrono::steady_clock::now()).count();
        if (remaining_ms <= 0) {
            break; // 超时预算耗尽
        }

        struct pollfd pfd;
        pfd.fd     = m_fd;
        pfd.events = POLLOUT;

        int ret = poll(&pfd, 1, static_cast<int>(remaining_ms));
        if (ret <= 0) {
            break; // poll 超时(0)/错误(<0): 返回已写入量
        }

        ssize_t bytes_written = ::write(m_fd, buffer + total_written, length - total_written);
        if (bytes_written <= 0) {
            break; // 写错误: 返回已写入量
        }
        total_written += static_cast<uint32_t>(bytes_written);
    }

    if (length > 0) {
        dlog("UART DIAG: uart_write POST_SEND - wrote ${written}/${total} bytes",
             ("written", total_written)("total", length));
    }

    return static_cast<int>(total_written);
}

int bus_uart::rx_bytes_available()
{
    if (!m_device_open || m_fd < 0) {
        return 0;
    }

    int bytes_available = 0;
    ioctl(m_fd, FIONREAD, &bytes_available);
    return bytes_available;
}

void bus_uart::diagnose_parity_settings(bool verbose)
{
    if (!m_device_open || m_fd < 0) {
        dlog("UART PARITY DIAG: device not open");
        return;
    }

    struct termios current;
    if (tcgetattr(m_fd, &current) != 0) {
        dlog("UART PARITY DIAG: tcgetattr failed");
        return;
    }

    bool inpck  = (current.c_iflag & INPCK) != 0;
    bool ignpar = (current.c_iflag & IGNPAR) != 0;
    bool parmrk = (current.c_iflag & PARMRK) != 0;
    bool parenb = (current.c_cflag & PARENB) != 0;
    bool parodd = (current.c_cflag & PARODD) != 0;
    bool cmspar = (current.c_cflag & CMSPAR) != 0;

    // 简要模式:只输出一行关键信息(正常情况)
    if (!verbose) {
        std::string parity_type;
        if (!parenb) {
            parity_type = "NONE";
        } else if (cmspar) {
            parity_type = parodd ? "MARK(bit9=1)" : "SPACE(bit9=0)";
        } else {
            parity_type = parodd ? "ODD" : "EVEN";
        }

        std::string input_mode;
        if (!inpck) {
            input_mode = "ACCEPT_ALL";
        } else if (ignpar) {
            input_mode = "DISCARD_ERR";
        } else if (parmrk) {
            input_mode = "MARK_ERR(0xFF0x00)";
        } else {
            input_mode = "PASS_ERR";
        }

        dlog("UART PARITY: ${type}, input=${mode}", ("type", parity_type)("mode", input_mode));
        return;
    }

    // 详细模式:输出完整诊断信息(用于调试或出错时)
    dlog("UART PARITY DIAG: === CURRENT TERMIOS CONFIGURATION ===");
    dlog("UART PARITY DIAG: c_cflag=0x${flag:08X}, c_iflag=0x${iflag:08X}",
         ("flag", current.c_cflag)("iflag", current.c_iflag));

    dlog("UART PARITY DIAG: PARENB=${enb}, PARODD=${odd}, CMSPAR=${cms}",
         ("enb", parenb)("odd", parodd)("cms", cmspar));

    if (parenb) {
        if (cmspar) {
            if (parodd) {
                dlog("UART PARITY DIAG: MARK PARITY (bit9=1) - for address transmission");
            } else {
                dlog("UART PARITY DIAG: SPACE PARITY (bit9=0) - for fan response reception");
            }
        } else {
            dlog("UART PARITY DIAG: ${parity} PARITY", ("parity", parodd ? "ODD" : "EVEN"));
        }
    } else {
        dlog("UART PARITY DIAG: PARITY DISABLED (None parity)");
    }

    dlog("UART PARITY DIAG: INPCK=${inpck} (input parity check), IGNPAR=${ignpar} (ignore errors), PARMRK=${parmrk} "
         "(mark errors)",
         ("inpck", inpck)("ignpar", ignpar)("parmrk", parmrk));

    if (inpck) {
        if (ignpar) {
            dlog("UART PARITY DIAG: INPCK=1, IGNPAR=1 -> Parity errors detected and DISCARDED");
        } else if (parmrk) {
            dlog("UART PARITY DIAG: INPCK=1, IGNPAR=0, PARMRK=1 -> Parity errors detected and MARKED (0xFF 0x00 "
                 "prefix)");
            dlog("UART PARITY DIAG: This preserves fan response data in RX buffer");
        } else {
            dlog("UART PARITY DIAG: INPCK=1, IGNPAR=0, PARMRK=0 -> Parity errors pass but may pollute buffer");
        }
    } else {
        dlog("UART PARITY DIAG: INPCK=0 -> Input parity checking DISABLED");
        dlog("UART PARITY DIAG: ALL data accepted (both Mark and Space parity bytes)");
    }

    dlog("UART PARITY DIAG: === END TERMIOS CONFIGURATION ===");
}

bool bus_uart::check_and_log_parity_errors()
{
    if (!m_device_open || m_fd < 0) {
        return false;
    }

    struct termios current;
    if (tcgetattr(m_fd, &current) != 0) {
        dlog("UART PARITY ERROR CHECK: tcgetattr failed");
        return false;
    }

    bool inpck  = (current.c_iflag & INPCK) != 0;
    bool ignpar = (current.c_iflag & IGNPAR) != 0;

    dlog("UART PARITY CONFIG CHECK: INPCK=${inpck} (parity checking), IGNPAR=${ignpar} (ignore parity errors)",
         ("inpck", inpck)("ignpar", ignpar));

    if (!inpck) {
        dlog("UART PARITY CONFIG CHECK: INPCK=0 → PARITY CHECKING DISABLED");
        dlog("UART PARITY CONFIG CHECK: This means ALL data is accepted regardless of parity bit (bit9)");
        dlog("UART PARITY CONFIG CHECK: Mark parity (bit9=1) and Space parity (bit9=0) data BOTH accepted");
        dlog("UART PARITY CONFIG CHECK: RX buffer pollution possible: other fan responses may remain in buffer");
        dlog("UART PARITY CONFIG CHECK: Solution: flush RX buffer BEFORE sending query address");
        return false;
    }

    if (ignpar) {
        dlog("UART PARITY CONFIG CHECK: IGNPAR=1 → data with parity errors will be DISCARDED silently");
        dlog("UART PARITY CONFIG CHECK: Fan response during wrong parity mode may be rejected");
        return true;
    }

    dlog("UART PARITY CONFIG CHECK: INPCK=1, IGNPAR=0 → parity errors detected but data not discarded");
    return false;
}

uint8_t bus_uart::get_id()
{
    return m_channel_id;
}

void bus_uart::bus_lock()
{
    uart_connect_mutex.lock();
}

void bus_uart::bus_unlock()
{
    uart_connect_mutex.unlock();
}

uint32_t bus_uart::read(ACCESS_DATA_S& input)
{
    if (!m_device_open) {
        return HAS_ERR;
    }

    // 长度校验: 拒绝 0 与超上限请求(UART_MAX_READ_LEN 原定义未使用, 此处启用),
    // 防止异常大 length 触发巨量 resize
    if (input.length == 0 || input.length > UART_MAX_READ_LEN) {
        elog("bus_uart read: invalid length ${len} (max ${max})", ("len", input.length)("max", UART_MAX_READ_LEN));
        input.out_buffer.clear();
        return HAS_ERR;
    }

    input.out_buffer.resize(input.length);
    int ret = uart_read(input.out_buffer.data(), input.length,
                        input.read_time_out > 0 ? input.read_time_out : UART_DEFAULT_TIMEOUT_MS);
    // poll 超时返回 0, 错误返回 <0: 均按失败处理并清空缓冲。
    // 原实现只判 ret<0, 超时时把空缓冲当有效响应返回 HAS_OK,
    // 协议层会把空数据当成功进入后续解析造成错帧。
    if (ret <= 0) {
        input.out_buffer.clear();
        return HAS_ERR;
    }
    input.out_buffer.resize(ret);
    return HAS_OK;
}

uint32_t bus_uart::write(ACCESS_DATA_S& input)
{
    if (!m_device_open) {
        return HAS_ERR;
    }

    if (input.in_buffer.empty() || input.length == 0) {
        return HAS_ERR;
    }

    // 一致性校验: uart_write 按 input.length 读取 in_buffer, 不一致时拒绝,
    // 防止 length > in_buffer.size() 场景越界读
    if (input.length != input.in_buffer.size()) {
        elog("bus_uart write: length(${len}) != in_buffer.size(${size})",
             ("len", input.length)("size", input.in_buffer.size()));
        return HAS_ERR;
    }

    int ret = uart_write(input.in_buffer.data(), input.length,
                         input.write_time_out > 0 ? input.write_time_out : UART_DEFAULT_TIMEOUT_MS);
    // 短写(超时/部分写入)或错误一律判失败: RS485 半双工帧一旦短写,
    // 若按成功进入查询阶段, 后续地址/长度解析会全部错位
    if (ret != static_cast<int>(input.length)) {
        elog("bus_uart write: incomplete write - wrote ${wrote}/${total}", ("wrote", ret)("total", input.length));
        return HAS_ERR;
    }
    return HAS_OK;
}

int bus_uart::uart_connect_port(uint8_t uart_id, uint8_t port_id)
{
    std::lock_guard<std::mutex> lock(uart_connect_mutex);

    int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
    if (fd < 0) {
        elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
        return -1;
    }

    struct uart_connect_cfg cfg;
    cfg.mode = UART_2_PORT;
    cfg.src  = uart_id;
    cfg.dst  = port_id;

    int ret = ioctl(fd, SET_UART_CONNECT, &cfg);
    close(fd);
    return ret;
}

int bus_uart::port_connect_port(uint8_t port_id, uint8_t target_id)
{
    std::lock_guard<std::mutex> lock(uart_connect_mutex);

    int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
    if (fd < 0) {
        elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
        return -1;
    }

    struct uart_connect_cfg cfg;
    cfg.mode = PORT_2_PORT;
    cfg.src  = port_id;
    cfg.dst  = target_id;

    int ret = ioctl(fd, SET_UART_CONNECT, &cfg);
    close(fd);
    return ret;
}

int bus_uart::query_uart_connection(uint8_t uart_id, uint32_t* connection_info)
{
    std::lock_guard<std::mutex> lock(uart_connect_mutex);

    int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
    if (fd < 0) {
        elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
        return -1;
    }

    uint32_t buffer[3] = {0};
    int      ret       = ioctl(fd, GET_UART_CONNECT_INFO, buffer);
    if (ret == 0) {
        uint32_t dw_index   = uart_id / 6;
        uint32_t bit_offset = (uart_id % 6) * 5;
        if (dw_index < 3) {
            *connection_info = (buffer[dw_index] >> bit_offset) & 0x1F;
        }
    }
    close(fd);
    return ret;
}

int bus_uart::query_port_connection(uint8_t port_id, uint32_t* connection_info)
{
    std::lock_guard<std::mutex> lock(uart_connect_mutex);

    int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
    if (fd < 0) {
        elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
        return -1;
    }

    uint32_t buffer[3] = {0};
    int      ret       = ioctl(fd, GET_PORT_CONNECT_INFO, buffer);
    if (ret == 0) {
        uint32_t dw_index   = port_id / 6;
        uint32_t bit_offset = (port_id % 6) * 5;
        if (dw_index < 3) {
            *connection_info = (buffer[dw_index] >> bit_offset) & 0x1F;
        }
    }
    close(fd);
    return ret;
}

int bus_uart::uart_connect_uart_from_uart_raw(uint8_t src_uart, uint8_t dst_uart)
{
    std::lock_guard<std::mutex> lock(uart_connect_mutex);

    int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
    if (fd < 0) {
        dlog("UART DIAGNOSTIC: Failed to open uart_connect device, errno=${err}", ("err", errno));
        return -1;
    }

    struct uart_connect_cfg cfg;
    cfg.mode = UART_FROM_UART_RAW;
    cfg.src  = src_uart;
    cfg.dst  = dst_uart;

    dlog("UART DIAGNOSTIC: Configuring uart connect: src=${src}(RX), dst=${dst}(TX), mode=UART_FROM_UART_RAW",
         ("src", src_uart)("dst", dst_uart));

    int ret = ioctl(fd, SET_UART_CONNECT, &cfg);
    close(fd);

    if (ret < 0) {
        dlog("UART DIAGNOSTIC: ioctl(SET_UART_CONNECT) failed, errno=${err}", ("err", errno));
        return -1;
    }

    dlog("UART DIAGNOSTIC: ioctl(SET_UART_CONNECT) success");
    return 0;
}

int bus_uart::port_connect_uart_from_port_raw(uint8_t src_port, uint8_t dst_uart)
{
    std::lock_guard<std::mutex> lock(uart_connect_mutex);

    int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
    if (fd < 0) {
        dlog("UART DIAGNOSTIC: Failed to open uart_connect device, errno=${err}", ("err", errno));
        return -1;
    }

    struct uart_connect_cfg cfg;
    cfg.mode = UART_FROM_PORT_RAW;
    cfg.src  = src_port;
    cfg.dst  = dst_uart;

    dlog("UART DIAGNOSTIC: Configuring port connect: src=${src}(UART RX), dst=${dst}(PORT TX), mode=UART_FROM_PORT_RAW",
         ("src", src_port)("dst", dst_uart));

    int ret = ioctl(fd, SET_UART_CONNECT, &cfg);
    close(fd);

    if (ret < 0) {
        dlog("UART DIAGNOSTIC: ioctl(SET_UART_CONNECT) failed, errno=${err}", ("err", errno));
        return -1;
    }

    dlog("UART DIAGNOSTIC: ioctl(SET_UART_CONNECT) success");
    return 0;
}

int bus_uart::reset_uart_connection()
{
    std::lock_guard<std::mutex> lock(uart_connect_mutex);

    int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
    if (fd < 0) {
        elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
        return -1;
    }

    int ret = ioctl(fd, RESET_UART_CONNECT, 0);
    close(fd);
    return ret;
}

int bus_uart::get_host_baudrate(uint8_t host_uart_chan, uint32_t* baudrate)
{
    std::lock_guard<std::mutex> lock(uart_connect_mutex);

    int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
    if (fd < 0) {
        elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
        return -1;
    }

    struct host_uart_baud_info info;
    info.host_uart_chan     = host_uart_chan;
    info.baud_constant_list = nullptr;

    int ret = ioctl(fd, GET_HOST_BAUDRATE_INFO, &info);
    if (ret == 0) {
        *baudrate = info.uart_baud;
    }
    close(fd);
    return ret;
}

int bus_uart::port_disconnect(uint8_t port_id)
{
    std::lock_guard<std::mutex> lock(uart_connect_mutex);

    int fd = open(DEV_UART_CONNECT_NAME, O_RDWR);
    if (fd < 0) {
        elog("Failed to open uart_connect device, errno=${err}", ("err", errno));
        return -1;
    }

    struct uart_connect_cfg cfg;
    cfg.mode = PORT_DISCONNECT;
    cfg.src  = port_id;
    cfg.dst  = port_id;

    int ret = ioctl(fd, SET_UART_CONNECT, &cfg);
    close(fd);
    return ret;
}

void bus_uart::flush_rx_only()
{
    if (m_fd >= 0 && m_device_open) {
        tcflush(m_fd, TCIFLUSH);
        dlog("UART DIAG: flush_rx_only() - cleared RX buffer (parity unchanged)");
    }
}

void bus_uart::flush_tx_only()
{
    if (m_fd >= 0 && m_device_open) {
        tcflush(m_fd, TCOFLUSH);
        dlog("UART DIAG: flush_tx_only() - cleared TX buffer (parity unchanged)");
    }
}