//! Telegram Bot API compatibility layer.
//!
//! Bots register with a fingerprint and get a token.
//! They use `/bot<token>/getUpdates` and `/bot<token>/sendMessage`
//! to communicate with featherChat users.
//!
//! Supported endpoints (Telegram-compatible):
//! - `POST /bot/register`           (featherChat-specific)
//! - `GET  /bot/:token/getMe`
//! - `POST /bot/:token/getUpdates`
//! - `POST /bot/:token/sendMessage`
//! - `POST /bot/:token/answerCallbackQuery`
//! - `POST /bot/:token/editMessageText`
//! - `POST /bot/:token/setWebhook`
//! - `POST /bot/:token/deleteWebhook`
//! - `GET  /bot/:token/getWebhookInfo`
//! - `POST /bot/:token/sendDocument`

use axum::{
    extract::{Path, State},
    routing::{get, post},
    Json, Router,
};
use serde::Deserialize;

use base64::Engine;

use crate::errors::AppResult;
use crate::state::AppState;

/// Build the bot API routes (nested under `/v1`).
pub fn routes() -> Router<AppState> {
    Router::new()
        .route("/bot/list", get(list_system_bots))
        .route("/bot/register", post(register_bot))
        .route("/bot/:token/getMe", get(get_me))
        .route("/bot/:token/getUpdates", post(get_updates))
        .route("/bot/:token/sendMessage", post(send_message))
        .route("/bot/:token/answerCallbackQuery", post(answer_callback_query))
        .route("/bot/:token/editMessageText", post(edit_message_text))
        .route("/bot/:token/setWebhook", post(set_webhook))
        .route("/bot/:token/deleteWebhook", post(delete_webhook))
        .route("/bot/:token/getWebhookInfo", get(get_webhook_info))
        .route("/bot/:token/sendDocument", post(send_document_flexible))
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// System bot list (public, no auth needed)
// ---------------------------------------------------------------------------

/// GET /v1/bot/list — returns system bots for welcome screen.
async fn list_system_bots(
    State(state): State<AppState>,
) -> Json<serde_json::Value> {
    let bots = state.db.tokens.get(b"system:bot_list")
        .ok().flatten()
        .and_then(|v| serde_json::from_slice::<Vec<serde_json::Value>>(&v).ok())
        .unwrap_or_default();
    Json(serde_json::json!({ "ok": true, "bots": bots }))
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

/// Validate a bot token against the `tokens` sled tree.
/// Returns the stored bot info JSON if the token is valid.
/// Returns `None` if bots are disabled on this server instance.
fn validate_bot_token(state: &AppState, token: &str) -> Option<serde_json::Value> {
    if !state.bots_enabled {
        return None;
    }
    let key = format!("bot:{}", token);
    let ivec = state.db.tokens.get(key.as_bytes()).ok()??;
    serde_json::from_slice(&ivec).ok()
}

/// Resolve a `chat_id` that may be a string fingerprint, ETH address, or numeric ID.
fn resolve_chat_id(state: &AppState, chat_id: &serde_json::Value) -> Option<String> {
    match chat_id {
        serde_json::Value::String(s) => {
            let clean: String = s
                .chars()
                .filter(|c| c.is_ascii_hexdigit())
                .collect::<String>()
                .to_lowercase();
            if clean.len() >= 16 {
                Some(clean)
            } else if s.starts_with("0x") {
                // ETH address -- resolve
                state
                    .db
                    .eth_addresses
                    .get(s.to_lowercase().as_bytes())
                    .ok()?
                    .map(|v| String::from_utf8_lossy(&v).to_string())
            } else {
                Some(s.clone())
            }
        }
        serde_json::Value::Number(n) => {
            let num = n.as_i64().unwrap_or(0);
            // Look up per-bot numeric ID reverse mapping
            let numid_key = format!("numid:{}", num);
            if let Some(fp_bytes) = state.db.tokens.get(numid_key.as_bytes()).ok().flatten() {
                return Some(String::from_utf8_lossy(&fp_bytes).to_string());
            }
            // Fallback: scan all keys with global hash (legacy)
            for item in state.db.keys.iter().flatten() {
                let key_str = String::from_utf8_lossy(&item.0).to_string();
                if !key_str.contains(':') && key_str.len() == 32 {
                    if crate::routes::resolve::fp_to_numeric_id(&key_str) == num {
                        return Some(key_str);
                    }
                }
            }
            None
        }
        _ => None,
    }
}

/// Get the next update_id for a bot and atomically increment the counter.
///
/// The counter is stored in the `tokens` tree under `bot_update_id:<bot_fp>`.
fn next_update_id(state: &AppState, bot_fp: &str) -> u64 {
    let key = format!("bot_update_id:{}", bot_fp);
    let current = state
        .db
        .tokens
        .get(key.as_bytes())
        .ok()
        .flatten()
        .and_then(|v| {
            let bytes: [u8; 8] = v.as_ref().try_into().ok()?;
            Some(u64::from_be_bytes(bytes))
        })
        .unwrap_or(1);
    let next = current + 1;
    let _ = state
        .db
        .tokens
        .insert(key.as_bytes(), &next.to_be_bytes());
    current
}

/// Store an update in the bot's persistent queue with an assigned update_id.
///
/// Key format: `bot_queue:<bot_fp>:<update_id_padded>` to ensure lexicographic ordering.
fn enqueue_bot_update(state: &AppState, bot_fp: &str, update: serde_json::Value) {
    let uid = next_update_id(state, bot_fp);
    let queue_key = format!("bot_queue:{}:{:020}", bot_fp, uid);
    let mut enriched = update;
    enriched["update_id"] = serde_json::json!(uid);
    if let Ok(bytes) = serde_json::to_vec(&enriched) {
        let _ = state.db.messages.insert(queue_key.as_bytes(), bytes);
    }
}

// ---------------------------------------------------------------------------
// Webhook delivery (public -- called from state.rs deliver_or_queue)
// ---------------------------------------------------------------------------

/// Check if a fingerprint belongs to a bot with a webhook, and deliver the message.
///
/// Called from `AppState::deliver_or_queue` after queueing. Returns `true` if
/// the webhook accepted the update (HTTP 2xx), meaning the queued entry can be
/// removed.
pub async fn try_bot_webhook(state: &AppState, to_fp: &str, message: &[u8]) -> bool {
    // 1. Check if this fingerprint is a bot
    let token_key = format!("bot_fp:{}", to_fp);
    let token = match state.db.tokens.get(token_key.as_bytes()) {
        Ok(Some(v)) => String::from_utf8_lossy(&v).to_string(),
        _ => return false,
    };

    // 2. Load bot info and check for webhook URL
    let bot_info: serde_json::Value =
        match state.db.tokens.get(format!("bot:{}", token).as_bytes()) {
            Ok(Some(v)) => match serde_json::from_slice(&v) {
                Ok(v) => v,
                Err(_) => return false,
            },
            _ => return false,
        };

    let webhook_url = match bot_info.get("webhook_url").and_then(|v| v.as_str()) {
        Some(url) if !url.is_empty() => url.to_string(),
        _ => return false,
    };

    // 3. Build Telegram-style update from the raw message bytes
    let update = if let Ok(wire) =
        bincode::deserialize::<warzone_protocol::message::WireMessage>(message)
    {
        wire_message_to_update(state, &wire, message, &token)
    } else if let Ok(bot_msg) = serde_json::from_slice::<serde_json::Value>(message) {
        bot_json_to_update(state, &bot_msg, &token)
    } else {
        None
    };

    let mut update = match update {
        Some(u) => u,
        None => return false,
    };

    // Assign a real update_id so the webhook consumer can track ordering
    let uid = next_update_id(state, to_fp);
    update["update_id"] = serde_json::json!(uid);

    // 4. POST to webhook URL with a short timeout
    let client = reqwest::Client::builder()
        .timeout(std::time::Duration::from_secs(5))
        .build()
        .unwrap_or_default();

    match client
        .post(&webhook_url)
        .header("Content-Type", "application/json")
        .json(&update)
        .send()
        .await
    {
        Ok(resp) if resp.status().is_success() => {
            tracing::info!("Webhook delivered to {} for bot {}", webhook_url, to_fp);
            true
        }
        Ok(resp) => {
            tracing::warn!(
                "Webhook {} returned {} for bot {}",
                webhook_url,
                resp.status(),
                to_fp
            );
            false
        }
        Err(e) => {
            tracing::warn!("Webhook {} failed for bot {}: {}", webhook_url, to_fp, e);
            false
        }
    }
}

// ---------------------------------------------------------------------------
// Handlers
// ---------------------------------------------------------------------------

#[derive(Deserialize)]
struct RegisterBotRequest {
    name: String,
    fingerprint: String,
    #[serde(default)]
    bundle: Option<Vec<u8>>,      // bincode PreKeyBundle for E2E bots
    #[serde(default)]
    eth_address: Option<String>,
    #[serde(default)]
    e2e: Option<bool>,            // true = E2E bot, false/None = plaintext bot
    #[serde(default)]
    owner: Option<String>,        // fingerprint of the bot creator
    #[serde(default)]
    botfather_token: Option<String>,
}

/// Register a bot and receive a token.
///
/// `POST /v1/bot/register`
///
/// ```json
/// { "name": "mybot", "fingerprint": "aabbccdd..." }
/// ```
async fn register_bot(
    State(state): State<AppState>,
    Json(req): Json<RegisterBotRequest>,
) -> AppResult<Json<serde_json::Value>> {
    if !state.bots_enabled {
        return Ok(Json(serde_json::json!({"ok": false, "description": "Bot API is disabled on this server. Use a server with --enable-bots"})));
    }

    // Only BotFather can register bots
    // Require botfather_token field matching the stored BotFather token
    if let Some(ref bf_token) = req.botfather_token {
        let botfather_fp = "00000000000000000b0ffa00e000000f";
        let bf_key = format!("bot_fp:{}", botfather_fp);
        let stored_token = state.db.tokens.get(bf_key.as_bytes())
            .ok().flatten()
            .map(|v| String::from_utf8_lossy(&v).to_string());
        if stored_token.as_deref() != Some(bf_token.as_str()) {
            return Ok(Json(serde_json::json!({"ok": false, "description": "invalid BotFather token"})));
        }
    } else {
        return Ok(Json(serde_json::json!({"ok": false, "description": "bot registration requires BotFather authorization. Message @botfather to create a bot."})));
    }

    let fp = req
        .fingerprint
        .chars()
        .filter(|c| c.is_ascii_hexdigit())
        .collect::<String>()
        .to_lowercase();

    let random_bytes: [u8; 16] = rand::random();
    let token = format!(
        "{}:{}",
        &fp[..fp.len().min(16)],
        hex::encode(random_bytes),
    );

    let bot_info = serde_json::json!({
        "name": req.name,
        "fingerprint": fp,
        "token": token,
        "owner": req.owner.as_deref().unwrap_or(&fp),
        "e2e": req.e2e.unwrap_or(false),
        "created_at": chrono::Utc::now().timestamp(),
    });

    // Store bot info keyed by token.
    let key = format!("bot:{}", token);
    state
        .db
        .tokens
        .insert(key.as_bytes(), serde_json::to_vec(&bot_info)?.as_slice())?;

    // Reverse lookup: fingerprint -> token.
    let fp_key = format!("bot_fp:{}", fp);
    state
        .db
        .tokens
        .insert(fp_key.as_bytes(), token.as_bytes())?;

    // If E2E bot, register pre-key bundle (bot can receive encrypted messages)
    if req.e2e.unwrap_or(false) {
        if let Some(ref bundle_bytes) = req.bundle {
            let _ = state.db.keys.insert(fp.as_bytes(), bundle_bytes.as_slice());
            let device_key = format!("device:{}:bot", fp);
            let _ = state.db.keys.insert(device_key.as_bytes(), bundle_bytes.as_slice());
            tracing::info!("E2E bot: registered pre-key bundle for {}", fp);
        }
    }

    // Store ETH address mapping if provided
    if let Some(ref eth) = req.eth_address {
        let eth_lower = eth.to_lowercase();
        let _ = state.db.eth_addresses.insert(eth_lower.as_bytes(), fp.as_bytes());
        let _ = state.db.eth_addresses.insert(format!("rev:{}", fp).as_bytes(), eth_lower.as_bytes());
    }

    tracing::info!(
        "Bot registered: {} ({}) token={}... e2e={}",
        req.name,
        fp,
        &token[..token.len().min(20)],
        req.e2e.unwrap_or(false),
    );

    // Auto-register bot alias (name must end with Bot or _bot)
    let bot_alias = if req.name.ends_with("Bot") || req.name.ends_with("_bot") || req.name.ends_with("bot") {
        req.name.to_lowercase()
    } else {
        format!("{}_bot", req.name.to_lowercase())
    };
    let alias_key = format!("a:{}", bot_alias);
    let _ = state.db.aliases.insert(alias_key.as_bytes(), fp.as_bytes());
    let fp_key = format!("fp:{}", fp);
    let _ = state.db.aliases.insert(fp_key.as_bytes(), bot_alias.as_bytes());
    tracing::info!("Bot alias @{} registered for {}", bot_alias, fp);

    Ok(Json(serde_json::json!({
        "ok": true,
        "result": {
            "token": token,
            "name": req.name,
            "fingerprint": fp,
            "alias": format!("@{}", bot_alias),
            "e2e": req.e2e.unwrap_or(false),
        }
    })))
}

/// `GET /bot/:token/getMe` -- returns bot info (Telegram-compatible shape).
async fn get_me(
    State(state): State<AppState>,
    Path(token): Path<String>,
) -> Json<serde_json::Value> {
    match validate_bot_token(&state, &token) {
        Some(info) => {
            let fp = info["fingerprint"].as_str().unwrap_or("");
            Json(serde_json::json!({
                "ok": true,
                "result": {
                    "id": crate::routes::resolve::fp_to_numeric_id_for_bot(fp, &token),
                    "is_bot": true,
                    "first_name": info["name"],
                    "username": info["name"],
                }
            }))
        }
        None => Json(serde_json::json!({
            "ok": false,
            "description": "invalid token",
        })),
    }
}

// ---------------------------------------------------------------------------
// getUpdates — with offset/limit/timeout support
// ---------------------------------------------------------------------------

#[derive(Deserialize)]
struct GetUpdatesParams {
    #[serde(default)]
    offset: Option<i64>,
    #[serde(default)]
    limit: Option<usize>,
    #[serde(default)]
    timeout: Option<u64>,
}

/// `POST /bot/:token/getUpdates` -- long-poll for messages sent to this bot.
///
/// Migrates raw queue entries (from `queue:<bot_fp>:*`) into the persistent
/// bot update queue (`bot_queue:<bot_fp>:<update_id>`) on each call, then
/// returns updates filtered by `offset` and capped by `limit`.
///
/// When `offset` is provided, all updates with `update_id < offset` are
/// acknowledged (deleted), matching Telegram Bot API semantics.
async fn get_updates(
    State(state): State<AppState>,
    Path(token): Path<String>,
    Json(params): Json<GetUpdatesParams>,
) -> Json<serde_json::Value> {
    let bot_info = match validate_bot_token(&state, &token) {
        Some(info) => info,
        None => {
            return Json(serde_json::json!({
                "ok": false,
                "description": "invalid token",
            }))
        }
    };
    let bot_fp = bot_info["fingerprint"].as_str().unwrap_or("");
    let limit = params.limit.unwrap_or(100).min(100);
    let timeout = params.timeout.unwrap_or(0);

    // Step 1: Migrate raw queue entries into the persistent bot_queue.
    migrate_raw_queue(&state, bot_fp, &token);

    // Step 2: If offset is provided, delete all acknowledged updates (update_id < offset).
    if let Some(offset) = params.offset {
        let prefix = format!("bot_queue:{}:", bot_fp);
        let mut to_delete = Vec::new();
        for item in state.db.messages.scan_prefix(prefix.as_bytes()) {
            let (key, value) = match item {
                Ok(pair) => pair,
                Err(_) => continue,
            };
            if let Ok(update) = serde_json::from_slice::<serde_json::Value>(&value) {
                let uid = update["update_id"].as_i64().unwrap_or(0);
                if uid < offset {
                    to_delete.push(key);
                } else {
                    // Keys are ordered, so once we pass offset we can stop scanning
                    // for deletions.
                    break;
                }
            }
        }
        for key in &to_delete {
            let _ = state.db.messages.remove(key);
        }
    }

    // Step 3: Collect remaining updates up to `limit`.
    let updates = collect_updates(&state, bot_fp, limit);

    // Step 4: Long-poll if empty. Minimum 1s delay to prevent tight-loop abuse.
    if updates.is_empty() {
        let timeout = if timeout == 0 { 1 } else { timeout }; // force min 1s
        let wait = std::cmp::min(timeout, 50);
        // Poll in 1-second intervals so new messages are picked up promptly.
        let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(wait);
        loop {
            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
            // Check for newly arrived raw messages.
            migrate_raw_queue(&state, bot_fp, &token);
            let polled = collect_updates(&state, bot_fp, limit);
            if !polled.is_empty() {
                return Json(serde_json::json!({
                    "ok": true,
                    "result": polled,
                }));
            }
            if tokio::time::Instant::now() >= deadline {
                break;
            }
        }
    }

    Json(serde_json::json!({
        "ok": true,
        "result": updates,
    }))
}

/// Migrate raw `queue:<bot_fp>:*` entries into `bot_queue:<bot_fp>:<update_id>`.
///
/// Each raw entry is converted into a Telegram-style Update JSON object, assigned
/// a persistent update_id, and stored. The original raw key is deleted.
fn migrate_raw_queue(state: &AppState, bot_fp: &str, bot_token: &str) {
    let prefix = format!("queue:{}", bot_fp);
    let mut keys_to_delete = Vec::new();

    for item in state.db.messages.scan_prefix(prefix.as_bytes()) {
        let (key, value) = match item {
            Ok(pair) => pair,
            Err(_) => continue,
        };

        let update = if let Ok(wire) =
            bincode::deserialize::<warzone_protocol::message::WireMessage>(&value)
        {
            wire_message_to_update(state, &wire, &value, bot_token)
        } else if let Ok(bot_msg) = serde_json::from_slice::<serde_json::Value>(&value) {
            bot_json_to_update(state, &bot_msg, bot_token)
        } else {
            None
        };

        if let Some(upd) = update {
            enqueue_bot_update(state, bot_fp, upd);
        }
        keys_to_delete.push(key);
    }

    for key in &keys_to_delete {
        let _ = state.db.messages.remove(key);
    }
}

/// Store a per-bot numeric ID → fingerprint reverse mapping.
fn store_numid_mapping(state: &AppState, numeric_id: i64, fingerprint: &str) {
    let key = format!("numid:{}", numeric_id);
    let _ = state.db.tokens.insert(key.as_bytes(), fingerprint.as_bytes());
}

/// Convert a `WireMessage` into a Telegram-style update JSON (without update_id).
fn wire_message_to_update(
    state: &AppState,
    wire: &warzone_protocol::message::WireMessage,
    raw_bytes: &[u8],
    bot_token: &str,
) -> Option<serde_json::Value> {
    match wire {
        warzone_protocol::message::WireMessage::Message {
            id,
            sender_fingerprint,
            ..
        } => {
            let raw_b64 = base64::engine::general_purpose::STANDARD.encode(raw_bytes);
            let numeric = crate::routes::resolve::fp_to_numeric_id_for_bot(sender_fingerprint, bot_token); store_numid_mapping(state, numeric, sender_fingerprint);
            Some(serde_json::json!({
                "message": {
                    "message_id": id,
                    "from": {
                        "id": numeric,
                            "is_bot": false,
                        "first_name": &sender_fingerprint[..sender_fingerprint.len().min(12)],
                    },
                    "chat": {
                        "id": numeric,
                            "type": "private",
                    },
                    "date": chrono::Utc::now().timestamp(),
                    "text": null,
                    "raw_encrypted": raw_b64,
                }
            }))
        }
        warzone_protocol::message::WireMessage::KeyExchange {
            id,
            sender_fingerprint,
            ..
        } => {
            let raw_b64 = base64::engine::general_purpose::STANDARD.encode(raw_bytes);
            let numeric = crate::routes::resolve::fp_to_numeric_id_for_bot(sender_fingerprint, bot_token); store_numid_mapping(state, numeric, sender_fingerprint);
            Some(serde_json::json!({
                "message": {
                    "message_id": id,
                    "from": {
                        "id": numeric,
                            "is_bot": false,
                        "first_name": &sender_fingerprint[..sender_fingerprint.len().min(12)],
                    },
                    "chat": {
                        "id": numeric,
                            "type": "private",
                    },
                    "date": chrono::Utc::now().timestamp(),
                    "text": null,
                    "raw_encrypted": raw_b64,
                }
            }))
        }
        warzone_protocol::message::WireMessage::CallSignal {
            id,
            sender_fingerprint,
            signal_type,
            payload,
            ..
        } => {
            let numeric = crate::routes::resolve::fp_to_numeric_id_for_bot(sender_fingerprint, bot_token); store_numid_mapping(state, numeric, sender_fingerprint);
            Some(serde_json::json!({
                "message": {
                    "message_id": id,
                    "from": {
                        "id": numeric,
                            "is_bot": false,
                        "first_name": &sender_fingerprint[..sender_fingerprint.len().min(12)],
                    },
                    "chat": {
                        "id": numeric,
                            "type": "private",
                    },
                    "date": chrono::Utc::now().timestamp(),
                    "text": format!("/call_{:?}", signal_type),
                    "call_signal": {
                        "type": format!("{:?}", signal_type),
                        "payload": payload,
                    },
                }
            }))
        }
        warzone_protocol::message::WireMessage::FileHeader {
            id,
            sender_fingerprint,
            filename,
            file_size,
            ..
        } => {
            let numeric = crate::routes::resolve::fp_to_numeric_id_for_bot(sender_fingerprint, bot_token); store_numid_mapping(state, numeric, sender_fingerprint);
            Some(serde_json::json!({
                "message": {
                    "message_id": id,
                    "from": {
                        "id": numeric,
                            "is_bot": false,
                        "first_name": &sender_fingerprint[..sender_fingerprint.len().min(12)],
                    },
                    "chat": {
                        "id": numeric,
                            "type": "private",
                    },
                    "date": chrono::Utc::now().timestamp(),
                    "document": {
                        "file_name": filename,
                        "file_size": file_size,
                    },
                }
            }))
        }
        // Skip receipts and other variants.
        warzone_protocol::message::WireMessage::Receipt { .. } => None,
        _ => None,
    }
}

/// Convert a plaintext bot JSON message into a Telegram-style update (without update_id).
fn bot_json_to_update(state: &AppState, bot_msg: &serde_json::Value, bot_token: &str) -> Option<serde_json::Value> {
    let msg_type = bot_msg.get("type").and_then(|v| v.as_str())?;
    match msg_type {
        "bot_message" => {
            let from_fp = bot_msg.get("from").and_then(|v| v.as_str()).unwrap_or("");
            let numeric = crate::routes::resolve::fp_to_numeric_id_for_bot(from_fp, bot_token); store_numid_mapping(state, numeric, from_fp);
            Some(serde_json::json!({
                "message": {
                    "message_id": bot_msg.get("id").and_then(|v| v.as_str()).unwrap_or(""),
                    "from": {
                        "id": numeric,
                            "is_bot": true,
                    },
                    "chat": {
                        "id": numeric,
                            "type": "private",
                    },
                    "date": bot_msg.get("timestamp").and_then(|v| v.as_i64()).unwrap_or(0),
                    "text": bot_msg.get("text").and_then(|v| v.as_str()).unwrap_or(""),
                }
            }))
        }
        "callback_query" => {
            let from_fp = bot_msg.get("from").and_then(|v| v.as_str()).unwrap_or("");
            let numeric = crate::routes::resolve::fp_to_numeric_id_for_bot(from_fp, bot_token); store_numid_mapping(state, numeric, from_fp);
            Some(serde_json::json!({
                "callback_query": {
                    "id": bot_msg.get("id").and_then(|v| v.as_str()).unwrap_or(""),
                    "from": {
                        "id": numeric,
                            "is_bot": false,
                    },
                    "data": bot_msg.get("data").and_then(|v| v.as_str()).unwrap_or(""),
                    "message": bot_msg.get("message"),
                }
            }))
        }
        _ => None,
    }
}

/// Collect up to `limit` updates from `bot_queue:<bot_fp>:*`, preserving order.
fn collect_updates(state: &AppState, bot_fp: &str, limit: usize) -> Vec<serde_json::Value> {
    let prefix = format!("bot_queue:{}:", bot_fp);
    let mut updates = Vec::new();
    for item in state.db.messages.scan_prefix(prefix.as_bytes()) {
        let (_key, value) = match item {
            Ok(pair) => pair,
            Err(_) => continue,
        };
        if let Ok(update) = serde_json::from_slice::<serde_json::Value>(&value) {
            updates.push(update);
            if updates.len() >= limit {
                break;
            }
        }
    }
    updates
}

// ---------------------------------------------------------------------------
// sendMessage — enhanced with parse_mode, reply_to, reply_markup
// ---------------------------------------------------------------------------

#[derive(Deserialize)]
struct SendMessageRequest {
    chat_id: serde_json::Value, // Accept string (fingerprint) or number (numeric ID)
    text: String,
    #[serde(default)]
    parse_mode: Option<String>,
    #[serde(default)]
    reply_to_message_id: Option<String>,
    #[serde(default)]
    reply_markup: Option<serde_json::Value>,
}

/// `POST /bot/:token/sendMessage` -- send a plaintext message to a user.
///
/// In v1, bot messages are **not** E2E-encrypted; they are delivered as
/// plain JSON envelopes through the normal routing layer.
async fn send_message(
    State(state): State<AppState>,
    Path(token): Path<String>,
    Json(req): Json<SendMessageRequest>,
) -> Json<serde_json::Value> {
    let bot_info = match validate_bot_token(&state, &token) {
        Some(info) => info,
        None => {
            return Json(serde_json::json!({
                "ok": false,
                "description": "invalid token",
            }))
        }
    };

    let to_fp = match resolve_chat_id(&state, &req.chat_id) {
        Some(fp) => fp,
        None => {
            return Json(serde_json::json!({"ok": false, "description": "chat_id not found"}))
        }
    };
    let bot_fp = bot_info["fingerprint"].as_str().unwrap_or("bot");

    let msg_id = uuid::Uuid::new_v4().to_string();
    let bot_msg = serde_json::json!({
        "type": "bot_message",
        "id": msg_id,
        "from": bot_fp,
        "from_name": bot_info["name"],
        "text": req.text,
        "parse_mode": req.parse_mode,
        "reply_to_message_id": req.reply_to_message_id,
        "reply_markup": req.reply_markup,
        "timestamp": chrono::Utc::now().timestamp(),
    });
    let msg_bytes = serde_json::to_vec(&bot_msg).unwrap_or_default();

    let delivered = state.deliver_or_queue(&to_fp, &msg_bytes).await;

    Json(serde_json::json!({
        "ok": true,
        "result": {
            "message_id": msg_id,
            "chat": { "id": to_fp, "type": "private" },
            "text": req.text,
            "date": chrono::Utc::now().timestamp(),
            "delivered": delivered,
        }
    }))
}

// ---------------------------------------------------------------------------
// answerCallbackQuery
// ---------------------------------------------------------------------------

#[derive(Deserialize)]
struct AnswerCallbackRequest {
    callback_query_id: String,
    #[serde(default)]
    text: Option<String>,
    #[serde(default)]
    show_alert: Option<bool>,
}

/// `POST /bot/:token/answerCallbackQuery` -- acknowledge a callback query.
///
/// In v1 this is a no-op acknowledgement; no popup is delivered to the client.
async fn answer_callback_query(
    State(state): State<AppState>,
    Path(token): Path<String>,
    Json(req): Json<AnswerCallbackRequest>,
) -> Json<serde_json::Value> {
    if validate_bot_token(&state, &token).is_none() {
        return Json(serde_json::json!({"ok": false, "description": "invalid token"}));
    }
    tracing::debug!(
        "answerCallbackQuery id={} text={:?} alert={:?}",
        req.callback_query_id,
        req.text,
        req.show_alert,
    );
    Json(serde_json::json!({"ok": true, "result": true}))
}

// ---------------------------------------------------------------------------
// editMessageText
// ---------------------------------------------------------------------------

#[derive(Deserialize)]
struct EditMessageRequest {
    chat_id: serde_json::Value, // Accept string (fingerprint) or number (numeric ID)
    message_id: String,
    text: String,
    #[serde(default)]
    reply_markup: Option<serde_json::Value>,
}

/// `POST /bot/:token/editMessageText` -- edit a previously sent message.
async fn edit_message_text(
    State(state): State<AppState>,
    Path(token): Path<String>,
    Json(req): Json<EditMessageRequest>,
) -> Json<serde_json::Value> {
    let bot_info = match validate_bot_token(&state, &token) {
        Some(i) => i,
        None => return Json(serde_json::json!({"ok": false, "description": "invalid token"})),
    };
    let bot_fp = bot_info["fingerprint"].as_str().unwrap_or("bot");
    let to_fp = match resolve_chat_id(&state, &req.chat_id) {
        Some(fp) => fp,
        None => {
            return Json(serde_json::json!({"ok": false, "description": "chat_id not found"}))
        }
    };

    let edit_msg = serde_json::json!({
        "type": "bot_edit",
        "id": req.message_id,
        "from": bot_fp,
        "text": req.text,
        "reply_markup": req.reply_markup,
        "timestamp": chrono::Utc::now().timestamp(),
    });
    let msg_bytes = serde_json::to_vec(&edit_msg).unwrap_or_default();
    state.deliver_or_queue(&to_fp, &msg_bytes).await;

    Json(serde_json::json!({
        "ok": true,
        "result": {
            "message_id": req.message_id,
            "chat": {"id": to_fp},
            "text": req.text,
            "date": chrono::Utc::now().timestamp(),
        }
    }))
}

// ---------------------------------------------------------------------------
// setWebhook / deleteWebhook / getWebhookInfo
// ---------------------------------------------------------------------------

#[derive(Deserialize)]
struct SetWebhookRequest {
    url: String,
}

/// `POST /bot/:token/setWebhook` -- register a webhook URL for push delivery.
async fn set_webhook(
    State(state): State<AppState>,
    Path(token): Path<String>,
    Json(req): Json<SetWebhookRequest>,
) -> Json<serde_json::Value> {
    let mut bot_info = match validate_bot_token(&state, &token) {
        Some(i) => i,
        None => return Json(serde_json::json!({"ok": false, "description": "invalid token"})),
    };
    bot_info["webhook_url"] = serde_json::json!(req.url);
    let key = format!("bot:{}", token);
    let _ = state
        .db
        .tokens
        .insert(key.as_bytes(), serde_json::to_vec(&bot_info).unwrap_or_default());
    tracing::info!("Bot webhook set: {}", req.url);
    Json(serde_json::json!({"ok": true, "result": true, "description": "Webhook was set"}))
}

/// `POST /bot/:token/deleteWebhook` -- remove a previously set webhook.
async fn delete_webhook(
    State(state): State<AppState>,
    Path(token): Path<String>,
) -> Json<serde_json::Value> {
    let mut bot_info = match validate_bot_token(&state, &token) {
        Some(i) => i,
        None => return Json(serde_json::json!({"ok": false, "description": "invalid token"})),
    };
    bot_info.as_object_mut().map(|o| o.remove("webhook_url"));
    let key = format!("bot:{}", token);
    let _ = state
        .db
        .tokens
        .insert(key.as_bytes(), serde_json::to_vec(&bot_info).unwrap_or_default());
    Json(serde_json::json!({"ok": true, "result": true, "description": "Webhook was deleted"}))
}

/// `GET /bot/:token/getWebhookInfo` -- return current webhook configuration.
async fn get_webhook_info(
    State(state): State<AppState>,
    Path(token): Path<String>,
) -> Json<serde_json::Value> {
    match validate_bot_token(&state, &token) {
        Some(info) => {
            let url = info
                .get("webhook_url")
                .and_then(|v| v.as_str())
                .unwrap_or("");
            Json(serde_json::json!({
                "ok": true,
                "result": {
                    "url": url,
                    "has_custom_certificate": false,
                    "pending_update_count": 0,
                }
            }))
        }
        None => Json(serde_json::json!({"ok": false, "description": "invalid token"})),
    }
}

// ---------------------------------------------------------------------------
// sendDocument — accepts both JSON and multipart/form-data
// ---------------------------------------------------------------------------

/// `POST /bot/:token/sendDocument` -- send a document reference to a user.
///
/// Accepts both `application/json` and `multipart/form-data` content types
/// so Telegram bot libraries that upload files via multipart work out of the box.
async fn send_document_flexible(
    State(state): State<AppState>,
    Path(token): Path<String>,
    headers: axum::http::HeaderMap,
    body: axum::body::Bytes,
) -> Json<serde_json::Value> {
    let bot_info = match validate_bot_token(&state, &token) {
        Some(i) => i,
        None => return Json(serde_json::json!({"ok": false, "description": "invalid token"})),
    };
    let bot_fp = bot_info["fingerprint"].as_str().unwrap_or("bot");
    let bot_name = bot_info["name"].as_str().unwrap_or("bot");

    let content_type = headers
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("");

    let (chat_id_val, document, caption) = if content_type.contains("multipart") {
        // Parse multipart fields from raw bytes (simplified text-field extraction).
        let body_str = String::from_utf8_lossy(&body);
        let mut chat_id = String::new();
        let mut doc = String::new();
        let mut cap = String::new();

        // Split on boundary markers (lines starting with --)
        for part in body_str.split("------") {
            if part.contains("name=\"chat_id\"") {
                if let Some(val) = part.split("\r\n\r\n").nth(1) {
                    chat_id = val.trim().to_string();
                }
            }
            if part.contains("name=\"document\"") {
                if let Some(val) = part.split("\r\n\r\n").nth(1) {
                    doc = val.trim().to_string();
                }
            }
            if part.contains("name=\"caption\"") {
                if let Some(val) = part.split("\r\n\r\n").nth(1) {
                    cap = val.trim().to_string();
                }
            }
        }

        (
            serde_json::Value::String(chat_id),
            doc,
            if cap.is_empty() { None } else { Some(cap) },
        )
    } else {
        // JSON body
        match serde_json::from_slice::<serde_json::Value>(&body) {
            Ok(json) => {
                let chat_id = json
                    .get("chat_id")
                    .cloned()
                    .unwrap_or(serde_json::Value::String(String::new()));
                let doc = json
                    .get("document")
                    .and_then(|v| v.as_str())
                    .unwrap_or("")
                    .to_string();
                let cap = json
                    .get("caption")
                    .and_then(|v| v.as_str())
                    .map(String::from);
                (chat_id, doc, cap)
            }
            Err(e) => {
                return Json(
                    serde_json::json!({"ok": false, "description": format!("invalid body: {}", e)}),
                )
            }
        }
    };

    let to_fp = match resolve_chat_id(&state, &chat_id_val) {
        Some(fp) => fp,
        None => {
            return Json(serde_json::json!({"ok": false, "description": "invalid chat_id"}))
        }
    };

    let msg_id = uuid::Uuid::new_v4().to_string();
    let doc_msg = serde_json::json!({
        "type": "bot_document",
        "id": msg_id,
        "from": bot_fp,
        "from_name": bot_name,
        "document": document,
        "caption": caption,
        "timestamp": chrono::Utc::now().timestamp(),
    });
    let msg_bytes = serde_json::to_vec(&doc_msg).unwrap_or_default();
    let delivered = state.deliver_or_queue(&to_fp, &msg_bytes).await;

    Json(serde_json::json!({
        "ok": true,
        "result": {
            "message_id": msg_id,
            "chat": {"id": to_fp},
            "document": {"file_name": document},
            "caption": caption,
            "delivered": delivered,
        }
    }))
}