/*******************************************************************************
 * @file    ble_service.c
 * @brief   BLE NUS service module
 *
 * Original VesiScan-Basic BLE implementation ported to Zephyr/NCS:
 *   - NUS (Nordic UART Service) for data exchange
 *   - Advertising: 40ms interval, 10-min timeout
 *   - Connection: 15ms interval, 0 latency, 10s supervision timeout
 *   - TX power +8 dBm, 2M PHY preferred
 *   - Dev mode: no security / Production mode: bonding + passkey
 ******************************************************************************/
#include <zephyr/kernel.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/bluetooth/gatt.h>
#if IS_ENABLED(CONFIG_SETTINGS)
#include <zephyr/settings/settings.h>
#endif
#include <zephyr/mgmt/mcumgr/transport/smp_bt.h>
#include <bluetooth/services/nus.h>
#include <errno.h>

#include "ble_service.h"
#include "ble_tx_power.h"
#include "main.h"
#include "debug_print.h"
#include "led_control.h"

LOG_MODULE_REGISTER(ble_svc, LOG_LEVEL_INF);

/* BLE service 상태 */
static struct bt_conn *current_conn;
static ble_data_rx_cb_t rx_callback;
static bool dfu_advertising_mode;
static bool advertising_unlimited;
static uint8_t conn_param_update_attempts;
static int64_t last_rx_conn_param_update_ms;
static uint16_t current_notify_mtu = 23U;

#if IS_ENABLED(CONFIG_BT_SMP)
#define BLE_REQUIRED_SECURITY_LEVEL    BT_SECURITY_L4
static uint32_t pairing_passkey = BT_PASSKEY_RAND;
#endif

/*
 * - mutex: 여러 곳에서 동시에 NUS 전송을 시작하지 못하게 막음
 * - sem : 직전 전송이 정말 끝났는지 기다리는 신호
 */
static struct k_mutex nus_tx_lock;
static struct k_sem nus_tx_done_sem;

/* BLE API는 ISR/콜백에서 직접 호출하면 안전하지 않을 수 있으므로 k_work 사용 */
static struct k_work adv_restart_work;
static struct k_work_delayable adv_timeout_work;
static struct k_work_delayable conn_param_update_work;

/*
 * Store the UATT MTU used by normal GATT/NUS notifications.
 * NUS notifications can carry application payload up to UATT MTU - 3 bytes.
 */
static void att_mtu_updated(struct bt_conn *conn, uint16_t tx, uint16_t rx)
{
    uint16_t uatt = bt_gatt_get_uatt_mtu(conn);

    if (uatt != 0U)
    {
        current_notify_mtu = uatt;
    }
    else
    {
        current_notify_mtu = (tx < rx) ? tx : rx;
    }

    DBG_PRINTF("[BLE] ATT MTU updated tx=%u rx=%u uatt=%u used=%u notify_payload=%u\r\n",
               tx, rx, uatt, current_notify_mtu,
               (current_notify_mtu > 3U) ? (current_notify_mtu - 3U) : 0U);
}


/* MTU Exchange 연결 직후 요청 */
static void mtu_exchange_cb(struct bt_conn *conn, uint8_t err, struct bt_gatt_exchange_params *params)
{
    uint16_t uatt;

    ARG_UNUSED(params);

    if (err)
    {
        DBG_ERR("[BLE] MTU exchange failed err=%u\r\n", err);
        return;
    }

    uatt = bt_gatt_get_uatt_mtu(conn);
    if (uatt != 0U)
    {
        current_notify_mtu = uatt;
    }

    DBG_PRINTF("[BLE] MTU exchange complete uatt=%u notify_payload=%u\r\n",
               uatt,
               (uatt > 3U) ? (uatt - 3U) : 0U);
}

static struct bt_gatt_exchange_params mtu_exchange_params =
{
    .func = mtu_exchange_cb,
};
static struct bt_gatt_cb gatt_callbacks =
{
    .att_mtu_updated = att_mtu_updated,
};

/* 로컬 BLE MAC 주소 로그 */
static void ble_log_local_identity(void)
{
    bt_addr_le_t addr = {0};
    size_t count = 1;
    char addr_str[BT_ADDR_LE_STR_LEN];

    bt_id_get(&addr, &count);
    if (count == 0U)
    {
        DBG_ERR("[BLE] No local identity (MAC address) configured\r\n");
        return;
    }

    bt_addr_le_to_str(&addr, addr_str, sizeof(addr_str));
    DBG_CORE("[BLE] Local identity (MAC address): %s\r\n", addr_str);
}

#if IS_ENABLED(CONFIG_BT_SMP)
/* NUS 접근 전 보안 level 확인 */
static bool ble_conn_is_secure(const struct bt_conn *conn)
{
    return (conn != NULL) && (bt_conn_get_security(conn) >= BLE_REQUIRED_SECURITY_LEVEL);
}

/* 6자리 ASCII passkey를 숫자로 변환 */
static int ble_passkey_to_uint(const char *passkey, unsigned int *value)
{
    unsigned int parsed = 0U;

    // 입력 포인터 방어
    if ((passkey == NULL) || (value == NULL))
    {
        return -EINVAL;
    }

    for (size_t i = 0; i < PASSKEY_LENGTH; i++)
    {
        // 숫자 6자리만 허용
        if ((passkey[i] < '0') || (passkey[i] > '9'))
        {
            return -EINVAL;
        }

        parsed = (parsed * 10U) + (unsigned int)(passkey[i] - '0');
    }

    *value = parsed;
    return 0;
}

/* 저장된 passkey 검증, 실패 시 기본값 사용 */
static int ble_security_configure(void)
{
    unsigned int passkey;
    int err = ble_passkey_to_uint(m_static_passkey, &passkey);

    if (err)
    {
        DBG_ERR("[BLE] Invalid stored passkey, using default\r\n");
        memset(m_static_passkey, 0, sizeof(m_static_passkey));
        memcpy(m_static_passkey, DEFAULT_PASSKEY, PASSKEY_LENGTH);

        err = ble_passkey_to_uint(m_static_passkey, &passkey);
        if (err)
        {
            return err;
        }
    }

    pairing_passkey = passkey;
    DBG_CORE("[BLE] Fixed passkey configured\r\n");
    return 0;
}

/* Just Works/passkey pairing 요청 자동 승인 */
static void auth_pairing_confirm(struct bt_conn *conn)
{
    int err = bt_conn_auth_pairing_confirm(conn);

    if (err)
    {
        DBG_ERR("[BLE] Pairing confirm failed err=%d\r\n", err);
        return;
    }

    DBG_CORE("[BLE] Pairing confirmed\r\n");
}

/* pairing 취소 로그 */
static void auth_cancel(struct bt_conn *conn)
{
    ARG_UNUSED(conn);
    DBG_ERR("[BLE] Pairing cancelled\r\n");
}

#if IS_ENABLED(CONFIG_BT_APP_PASSKEY)
/* Zephyr pairing callback에 현재 passkey 제공 */
static uint32_t auth_app_passkey(struct bt_conn *conn)
{
    unsigned int passkey;

    ARG_UNUSED(conn);

    if (ble_passkey_to_uint(m_static_passkey, &passkey) == 0)
    {
        return passkey;
    }

    DBG_ERR("[BLE] Invalid runtime passkey, using configured fallback\r\n");
    return pairing_passkey;
}
#endif

/* pairing 처리 callback 묶음 */
static struct bt_conn_auth_cb auth_cb =
{
    .pairing_confirm = auth_pairing_confirm,
    .cancel = auth_cancel,
#if IS_ENABLED(CONFIG_BT_APP_PASSKEY)
    .app_passkey = auth_app_passkey,
#endif
};

/* pairing 성공 로그 */
static void auth_pairing_complete(struct bt_conn *conn, bool bonded)
{
    ARG_UNUSED(conn);
    DBG_CORE("[BLE] Pairing complete bonded=%u\r\n", bonded ? 1U : 0U);
}

/* pairing 실패 시 연결 종료 */
static void auth_pairing_failed(struct bt_conn *conn, enum bt_security_err reason)
{
    DBG_ERR("[BLE] Pairing failed reason=%u\r\n", reason);
    (void)bt_conn_disconnect(conn, BT_HCI_ERR_AUTH_FAIL);
}

/* pairing 결과 callback 묶음 */
static struct bt_conn_auth_info_cb auth_info_cb =
{
    .pairing_complete = auth_pairing_complete,
    .pairing_failed = auth_pairing_failed,
};

/* BLE 보안 callback 등록, passkey 설정 */
static int ble_security_init(void)
{
    int err = bt_conn_auth_cb_register(&auth_cb);

    if (err)
    {
        DBG_ERR("[BLE] auth cb register failed err=%d\r\n", err);
        return err;
    }

    err = bt_conn_auth_info_cb_register(&auth_info_cb);
    if (err)
    {
        DBG_ERR("[BLE] auth info cb register failed err=%d\r\n", err);
        return err;
    }

    return ble_security_configure();
}
#endif

/* callback context 밖에서 advertising 재시작 */
static void adv_restart_handler(struct k_work *work)
{
    ARG_UNUSED(work);
    ble_advertising_start();
    led_set_state(LED_STATE_ADVERTISING);
}

/*
 * 연결 해제 후 재광고 정책
 * - 앱이 연결을 정상 종료(0x13)한 경우만 10분 타임아웃 후 자동 전원 OFF
 * - 그 외(거리 이탈, 링크 타임아웃, 폰 전원 OFF, 페어링/보안 실패 등)는 재연결 대기를 위해 무제한 광고
 */
static bool ble_disconnect_reason_uses_unlimited_adv(uint8_t reason)
{
    switch (reason)
    {
        case BT_HCI_ERR_REMOTE_USER_TERM_CONN:  // 0x13 앱이 연결을 정상 종료
            return false;                       // 10분 타임아웃 후 전원 OFF

        default:
            return true;                        // 그 외 전부 → 무제한 광고
    }
}

/* 광고 timeout 시 자동 전원 OFF 판단 */
static void adv_timeout_handler(struct k_work *work)
{
    ARG_UNUSED(work);

    // 미연결 상태에서만 발동하므로 DFU 광고도 동일하게 10분 후 종료(연결 중이면 발동 안 함)
    if (!ble_connection_st && !advertising_unlimited)
    {
        DBG_PRINTF("[BLE] Advertising timeout\r\n");
        (void)ble_advertising_stop();
        device_power_off_reason("ble-advertising-timeout");
    }
}

/* 현재 연결 파라미터가 목표값인지 비교 */
static bool ble_conn_param_is_preferred(uint16_t interval, uint16_t latency,
                                        uint16_t timeout)
{
    return (interval == BLE_MIN_CONN_INTERVAL) && (latency == BLE_SLAVE_LATENCY) && (timeout == BLE_CONN_SUP_TIMEOUT);
}

/* 15ms interval 목표로 connection parameter update 요청 */
static int ble_request_preferred_conn_params(bool count_attempt)
{
    struct bt_le_conn_param conn_param =
    {
        .interval_min = BLE_MIN_CONN_INTERVAL,
        .interval_max = BLE_MAX_CONN_INTERVAL,
        .latency = BLE_SLAVE_LATENCY,
        .timeout = BLE_CONN_SUP_TIMEOUT,
    };
    struct bt_conn_info info;
    int err;

    // 연결 없으면 요청 불가
    if (current_conn == NULL)
    {
        return -ENOTCONN;
    }

    // 현재 체결된 파라미터를 조회해서, 이미 목표값이면 재요청/재시도 불필요
    err = bt_conn_get_info(current_conn, &info);
    if ((err == 0) && (info.type == BT_CONN_TYPE_LE))
    {
        uint16_t cur_interval = info.le.interval;
        uint16_t cur_latency = info.le.latency;
        uint16_t cur_timeout = info.le.timeout;

        DBG_PRINTF("[BLE] Current params: interval=%u(%u.%01ums) latency=%u timeout=%u(%ums)\r\n",
                   cur_interval,
                   (cur_interval * 125U) / 100U,
                   ((cur_interval * 125U) % 100U) / 10U,
                   cur_latency,
                   cur_timeout,
                   cur_timeout * 10U);

        if (ble_conn_param_is_preferred(cur_interval, cur_latency, cur_timeout))
        {
            DBG_PRINTF("[BLE] Already at preferred params, skip request\r\n");
            return -EALREADY;
        }
    }

    // 예약 재시도에서만 attempt 증가
    if (count_attempt)
    {
        conn_param_update_attempts++;
    }

    DBG_PRINTF("[BLE] Request params: interval=%u(%u.%01ums) latency=%u timeout=%u(%ums) attempt=%u\r\n",
               BLE_MIN_CONN_INTERVAL,
               (BLE_MIN_CONN_INTERVAL * 125U) / 100U,
               ((BLE_MIN_CONN_INTERVAL * 125U) % 100U) / 10U,
               BLE_SLAVE_LATENCY,
               BLE_CONN_SUP_TIMEOUT,
               BLE_CONN_SUP_TIMEOUT * 10U,
               conn_param_update_attempts);

    err = bt_conn_le_param_update(current_conn, &conn_param);
    if (err)
    {
        DBG_ERR("[BLE] Param update failed err=%d\r\n", err);
        return err;
    }

    return 0;
}

/* connection parameter 재시도 work */
static void conn_param_update_handler(struct k_work *work)
{
    ARG_UNUSED(work);

    if (current_conn == NULL)
    {
        return;
    }

    // central이 계속 거부하면 최대 횟수에서 중지
    if (conn_param_update_attempts >= BLE_CONN_PARAM_MAX_ATTEMPTS)
    {
        return;
    }

    if (ble_request_preferred_conn_params(true) == 0 && conn_param_update_attempts < BLE_CONN_PARAM_MAX_ATTEMPTS)
    {
        k_work_schedule(&conn_param_update_work, K_MSEC(BLE_CONN_PARAM_RETRY_INTERVAL_MS));
    }
}

/* Advertising scan response data */
static const struct bt_data sd[] =
{
    // 평상시 Web Bluetooth 앱이 찾을 수 있도록 NUS UUID 광고
    BT_DATA_BYTES(BT_DATA_UUID128_ALL, BT_UUID_NUS_VAL),
};

static const struct bt_data sd_dfu[] =
{
    // DFU 진입 후 mcumgr 앱이 찾을 수 있도록 SMP UUID 광고
    BT_DATA_BYTES(BT_DATA_UUID128_SOME, SMP_BT_SVC_UUID_VAL),
};

/* BLE 연결 완료 처리 */
static void connected(struct bt_conn *conn, uint8_t err)
{
    if (err)
    {
        DBG_ERR("[BLE] Connect failed (err %d) -> re-adv\r\n", err);
        k_work_submit(&adv_restart_work);
        return;
    }

    current_conn = bt_conn_ref(conn);
    ble_connection_st = true;
    ble_tx_power_on_connected(conn); // TX power/RSSI 상태는 별도 모듈에서 관리

    char addr_str[BT_ADDR_LE_STR_LEN];
    bt_addr_le_to_str(bt_conn_get_dst(conn), addr_str, sizeof(addr_str));
    DBG_CORE("[BLE] Peer: %s\r\n", addr_str); // 연결 정보 출력


    err = bt_gatt_exchange_mtu(conn, &mtu_exchange_params);
    if (err)
    {
        DBG_ERR("[BLE] MTU exchange request failed err=%d\r\n", err);
    }
    else
    {
        DBG_PRINTF("[BLE] MTU exchange requested\r\n");
    }
    conn_param_update_attempts = 0U;
    last_rx_conn_param_update_ms = 0;

    // 연결 직후 약간 기다린 뒤 preferred parameter 요청
    k_work_schedule(&conn_param_update_work, K_MSEC(BLE_CONN_PARAM_FIRST_DELAY_MS));

#if IS_ENABLED(CONFIG_BT_SMP)
    err = bt_conn_set_security(conn, BLE_REQUIRED_SECURITY_LEVEL);
    if (err)
    {
        DBG_ERR("[BLE] Security request failed err=%d\r\n", err);
        (void)bt_conn_disconnect(conn, BT_HCI_ERR_AUTH_FAIL);
        return;
    }
    DBG_CORE("[BLE] Security requested level=%u\r\n", BLE_REQUIRED_SECURITY_LEVEL);
#endif

    led_set_state(LED_STATE_OFF);
    DBG_CORE("[BLE] Connected\r\n");
}

/* BLE 연결 해제 처리 */
static void disconnected(struct bt_conn *conn, uint8_t reason)
{
    k_work_cancel_delayable(&conn_param_update_work);
    ble_tx_power_on_disconnected();
    conn_param_update_attempts = 0U;
    last_rx_conn_param_update_ms = 0;

    if (current_conn)
    {
        bt_conn_unref(current_conn);
        current_conn = NULL;
    }

    ble_connection_st = false;
    current_notify_mtu = 23U;
    if (dfu_advertising_mode)
    {
        // DFU 광고는 미연결 10분 타임아웃 적용
        advertising_unlimited = false;
    }
    else
    {
        advertising_unlimited = ble_disconnect_reason_uses_unlimited_adv(reason);
    }
    DBG_CORE("[BLE] Disconnected reason=0x%02x adv=%s\r\n",
             reason,
             advertising_unlimited ? "unlimited" : "10min");

    // 워크큐에서 advertising 재시작
    k_work_submit(&adv_restart_work);
}

/* central의 connection parameter 요청 허용 */
static bool le_param_req(struct bt_conn *conn, struct bt_le_conn_param *param)
{
    ARG_UNUSED(conn);
    ARG_UNUSED(param);

    return true;
}

/* connection parameter 변경 결과 확인 */
static void le_param_updated(struct bt_conn *conn, uint16_t interval, uint16_t latency, uint16_t timeout)
{
    ARG_UNUSED(conn);

    DBG_PRINTF("[BLE] Params: interval=%u(%u.%01ums) latency=%u timeout=%u(%ums)\r\n",
               interval,
               (interval * 125U) / 100U,
               ((interval * 125U) % 100U) / 10U,
               latency,
               timeout,
               timeout * 10U);

    // 목표값 도달 시 재시도 work 중지
    if (ble_conn_param_is_preferred(interval, latency, timeout))
    {
        k_work_cancel_delayable(&conn_param_update_work);
    }
    else if (conn_param_update_attempts < BLE_CONN_PARAM_MAX_ATTEMPTS)
    {
        k_work_schedule(&conn_param_update_work, K_MSEC(BLE_CONN_PARAM_RETRY_INTERVAL_MS));
    }
}

#if IS_ENABLED(CONFIG_BT_SMP)
/* BLE security level 변경 결과 확인 */
static void security_changed(struct bt_conn *conn, bt_security_t level, enum bt_security_err err)
{
    ARG_UNUSED(conn);

    if (err)
    {
        DBG_ERR("[BLE] Security failed level=%u err=%u\r\n", level, err);
        return;
    }

    DBG_CORE("[BLE] Security ready level=%u\r\n", level);
}
#endif

BT_CONN_CB_DEFINE(conn_callbacks) =
{
    .connected = connected,
    .disconnected = disconnected,
    .le_param_req = le_param_req,
    .le_param_updated = le_param_updated,
#if IS_ENABLED(CONFIG_BT_SMP)
    .security_changed = security_changed,
#endif
};

/* NUS RX: 보안 확인 후 app parser로 전달 */
static void nus_received(struct bt_conn *conn, const uint8_t *data, uint16_t len)
{
#if IS_ENABLED(CONFIG_BT_SMP)
    if (!ble_conn_is_secure(conn))
    {
        DBG_ERR("[NUS RX] blocked until BLE security is ready\r\n");
        return;
    }
#else
    ARG_UNUSED(conn);
#endif

    //DBG_CORE("[NUS RX] len=%u\r\n", len);

    if (current_conn == conn)
    {
        int64_t now_ms = k_uptime_get();

        ARG_UNUSED(now_ms);
    }

    if (rx_callback)
    {
        rx_callback(data, len);
    }
}

/* NUS TX 완료 callback */
static void nus_sent(struct bt_conn *conn)
{
    ARG_UNUSED(conn);
    // 직전 NUS 패킷 전송 완료
    k_sem_give(&nus_tx_done_sem);
    //DBG_CORE("[NUS TX] complete\r\n");
}

static struct bt_nus_cb nus_cb =
{
    .received = nus_received,
    .sent = nus_sent,
};

/* BLE stack, security, NUS service 초기화 */
int ble_service_init(ble_data_rx_cb_t rx_cb)
{
    int err;

    rx_callback = rx_cb;
    k_mutex_init(&nus_tx_lock);
    k_sem_init(&nus_tx_done_sem, 0, 1);

    k_work_init(&adv_restart_work, adv_restart_handler);
    k_work_init_delayable(&adv_timeout_work, adv_timeout_handler);
    k_work_init_delayable(&conn_param_update_work, conn_param_update_handler);
    ble_tx_power_init();
    // BLE stack 활성화
    err = bt_enable(NULL);
    if (err)
    {
    DBG_ERR("[BLE] bt_enable failed (err %d)\r\n", err);
        return err;
    }
    DBG_CORE("[BLE] Stack enabled\r\n");

#if IS_ENABLED(CONFIG_BT_SETTINGS)
    err = settings_load_subtree("bt");
    if (err)
    {
        DBG_ERR("[BLE] BT settings load failed err=%d\r\n", err);
        return err;
    }
    DBG_CORE("[BLE] BT settings loaded\r\n");
#endif

    ble_log_local_identity();

    bt_gatt_cb_register(&gatt_callbacks);
#if IS_ENABLED(CONFIG_BT_SMP)
    err = ble_security_init();
    if (err)
    {
        return err;
    }
#endif

    // NUS service 초기화
    err = bt_nus_init(&nus_cb);
    if (err)
    {
        DBG_ERR("[BLE] NUS init failed (err %d)\r\n", err);
        return err;
    }
    DBG_CORE("[BLE] NUS initialized\r\n");

    return 0;
}

/* 현재 모드에 맞는 advertising 시작 */
int ble_advertising_start(void)
{
    int err;
    const struct bt_data *scan_data = dfu_advertising_mode ? sd_dfu : sd;
    size_t scan_data_count = dfu_advertising_mode ? ARRAY_SIZE(sd_dfu) : ARRAY_SIZE(sd);
    size_t serial_name_len = strnlen(SERIAL_NO, SERIAL_NO_LENGTH);
    const struct bt_data ad[] =
    {
        BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
        BT_DATA(BT_DATA_NAME_COMPLETE, SERIAL_NO, serial_name_len),
    };

    struct bt_le_adv_param adv_param = BT_LE_ADV_PARAM_INIT(
        BT_LE_ADV_OPT_CONN,
        APP_ADV_INTERVAL,           // min interval
        APP_ADV_INTERVAL,           // max interval
        NULL                        // undirected
    );

    err = bt_set_name(SERIAL_NO);
    if (err)
    {
        DBG_ERR("[BLE] Name set failed (err %d)\r\n", err);
        return err;
    }

    err = bt_le_adv_start(&adv_param, ad, ARRAY_SIZE(ad), scan_data, scan_data_count);
    if (err)
    {
        DBG_ERR("[BLE] Adv start failed (err %d)\r\n", err);
        return err;
    }

    ble_tx_power_apply_advertising();

    k_work_cancel_delayable(&adv_timeout_work);
    if (!advertising_unlimited)   // DFU 광고 포함, 미연결 10분 시 전원 OFF
    {
        k_work_schedule(&adv_timeout_work, K_MSEC(APP_ADV_DURATION * 10));
    }

    DBG_PRINTF("[BLE] Advertising started (%s)\r\n", dfu_advertising_mode ? "SMP" : "NUS");
    return 0;
}

/* advertising 중지, timeout work 취소 */
int ble_advertising_stop(void)
{
    int err = bt_le_adv_stop();
    if (err)
    {
        DBG_ERR("[BLE] Adv stop failed (err %d)\r\n", err);
        return err;
    }

    k_work_cancel_delayable(&adv_timeout_work);
    DBG_PRINTF("[BLE] Advertising stopped\r\n");
    return 0;
}

/* DFU 모드 진입, SMP advertising 준비 */
int ble_dfu_advertising_enable(void)
{
    if (dfu_advertising_mode)
    {
        DBG_ERR("[BLE] DFU advertising already enabled\r\n");
        return -EALREADY;
    }

    // mdf? 응답 전송 후 현재 연결을 끊고 SMP UUID 광고로 재시작
    dfu_advertising_mode = true;
    DBG_PRINTF("[BLE] DFU advertising mode enabled\r\n");

    if (current_conn)
    {
        int err = bt_conn_disconnect(current_conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
        if (err)
        {
            DBG_ERR("[BLE] DFU disconnect failed err=%d\r\n", err);
            return err;
        }
        return 0;
    }

    (void)ble_advertising_stop();
    return ble_advertising_start();
}

/* DFU 진입용 disconnect */
bool ble_dfu_advertising_is_enabled(void)
{
    return dfu_advertising_mode;
}

/* DFU watchdog: 현재 연결 강제 disconnect */
int ble_disconnect_active(void)
{
    // 연결 없으면 요청 불가
    if (current_conn == NULL)
    {
        return -ENOTCONN;
    }

    return bt_conn_disconnect(current_conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
}

/* NUS TX: 직렬화, retry, 완료 대기 */
int ble_data_send(const uint8_t *data, uint16_t len)
{
    int err;
    int64_t tx_start_ms;

    if (!current_conn)
    {
        DBG_ERR("[NUS TX] not connected\r\n");
        return -ENOTCONN;
    }

#if IS_ENABLED(CONFIG_BT_SMP)
    if (!ble_conn_is_secure(current_conn))
    {
        DBG_ERR("[NUS TX] blocked until BLE security is ready\r\n");
        return -EACCES;
    }
#endif

    // 먼저 들어온 전송이 끝나기 전 다음 전송이 겹치지 않게 잠금 (NUS는 한 번에 한 패킷씩 보내는 것이 안전)
    k_mutex_lock(&nus_tx_lock, K_FOREVER);

    // 혹시 남아 있는 완료 신호가 있으면 비우고 이번 전송 전용 상태로 만듦
    while (k_sem_take(&nus_tx_done_sem, K_NO_WAIT) == 0)
    {
        // stale completion 비우기
    }

    //DBG_CORE("[NUS TX] send len=%u\r\n", len);
    tx_start_ms = k_uptime_get();
    for (int retry = 0; ; retry++)
    {
        err = bt_nus_send(current_conn, data, len);
        // -ENOMEM만 짧게 재시도, 그 외 error는 즉시 종료
        if (err != -ENOMEM || retry >= 20)
        {
            break;
        }

        // -ENOMEM : BLE TX 버퍼가 가득찬 경우: 바로 포기하지 않고 짧게 쉬었다가 다시 시도
        DBG_ERR("[NUS TX] busy, retry=%d\r\n", retry + 1);
        
        // busy 반복 시 TX power boost 판단
        ble_tx_power_on_tx_busy_retry(retry + 1);
        k_msleep(5);
    }

    if (err)
    {
        DBG_ERR("[NUS TX] failed (err %d)\r\n", err);
        k_mutex_unlock(&nus_tx_lock);
        return err;
    }

    // bt_nus_send() 성공 후 sent 콜백이 올 때까지 기다림 (다음 패킷을 보내도 되는 시점)
    err = k_sem_take(&nus_tx_done_sem, K_MSEC(ble_tx_power_tx_stuck_ms()));
    if (err)
    {
        // sent callback 지연도 링크 stress로 처리
        ble_tx_power_on_tx_complete_timeout();
        err = k_sem_take(&nus_tx_done_sem, K_MSEC(1000 - ble_tx_power_tx_stuck_ms()));
        if (err)
        {
            DBG_ERR("[NUS TX] completion timeout (err %d)\r\n", err);
        }
    }

    if (!err)
    {
        int64_t tx_elapsed_ms = k_uptime_get() - tx_start_ms;

        // 완료 시간 기반 TX power 복구/boost 판단
        ble_tx_power_on_tx_complete(tx_elapsed_ms);
    }

    k_mutex_unlock(&nus_tx_lock);
    return err;
}

/* BLE 연결 상태 */
bool ble_is_connected(void)
{
    return (current_conn != NULL);
}

/* ATT MTU used to calculate notify payload size */
uint16_t ble_current_mtu(void)
{
    return current_notify_mtu;
}