maxbot 0.6.0

//! Webhook-сервер на базе Actix-web для приёма HTTPS-вызовов от MAX.
//!
//! Активируется параметром сборки `webhook`:
//! ```toml
//! maxbot = { version = "0.6", features = ["webhook"] }
//! ```
//!
//! ## Пример использования
//!
//! ```no_run
//! use maxbot::{Dispatcher, MaxClient};
//! use maxbot::webhook::WebhookServer;
//!
//! #[actix_web::main]
//! async fn main() -> std::io::Result<()> {
//!     let bot = MaxClient::from_env().unwrap();
//!     let mut dp = Dispatcher::new(bot);
//!
//!     dp.on_message(|ctx| async move {
//!         ctx.reply_text("hello").await?;
//!         Ok(())
//!     });
//!
//!     WebhookServer::new(dp)
//!         .secret("my_secret")
//!         .path("/webhook")
//!         .serve("0.0.0.0:8443")
//!         .await
//! }
//! ```

use std::sync::Arc;

use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer, Responder};
use log::{error, info, warn};

use crate::dispatcher::Dispatcher;

// -----------------------------------------------------------------------------
// WebhookServer
// -----------------------------------------------------------------------------

/// Webhook-сервер на базе Actix-web.
pub struct WebhookServer {
    dispatcher: Arc<Dispatcher>,
    secret: Option<String>,
    path: String,
}

impl WebhookServer {
    /// Создаёт новый сервер с указанным диспетчером.
    pub fn new(dispatcher: Dispatcher) -> Self {
        Self {
            dispatcher: Arc::new(dispatcher),
            secret: None,
            path: "/".to_string(),
        }
    }

    /// Устанавливает секрет для проверки заголовка `X-Max-Bot-Api-Secret`.
    pub fn secret(mut self, secret: impl Into<String>) -> Self {
        self.secret = Some(secret.into());
        self
    }

    /// Устанавливает путь, на котором сервер будет принимать обновления.
    /// По умолчанию – `"/"`.
    pub fn path(mut self, path: impl Into<String>) -> Self {
        self.path = path.into();
        self
    }

    /// Запускает сервер и слушает указанный адрес (например, `"0.0.0.0:8443"`).
    ///
    /// Для продуктивного использования рекомендуется ставить за TLS-терминирующим прокси (nginx, Caddy),
    /// так как MAX требует HTTPS на порту 443.
    pub async fn serve(self, bind: impl AsRef<str>) -> std::io::Result<()> {
        let bind = bind.as_ref().to_string();
        let data = Arc::new(self);

        info!("Starting webhook server on {}", bind);
        info!("Webhook path: {}", data.path);

        HttpServer::new(move || {
            let data = data.clone();
            App::new()
                .app_data(web::Data::new(data.clone()))
                .route(&data.path, web::post().to(handle_update))
        })
        .bind(bind)?
        .run()
        .await
    }
}

// -----------------------------------------------------------------------------
// Обработчик запросов
// -----------------------------------------------------------------------------

async fn handle_update(
    state: web::Data<Arc<WebhookServer>>,
    req: HttpRequest,
    body: web::Bytes,
) -> impl Responder {
    // 1. Проверка секрета, если установлен
    if let Some(expected) = &state.secret {
        let provided = req
            .headers()
            .get("x-max-bot-api-secret")
            .and_then(|v| v.to_str().ok());

        match provided {
            Some(secret) if secret == expected => {}
            Some(secret) => {
                warn!("Webhook secret mismatch: got '{}'", secret);
                return HttpResponse::Unauthorized().body("Invalid secret");
            }
            None => {
                warn!("Missing X-Max-Bot-Api-Secret header");
                return HttpResponse::Unauthorized().body("Missing secret header");
            }
        }
    }

    // 2. Разбор JSON (сначала как Value, чтобы сохранить неизвестные поля)
    let update_json = match serde_json::from_slice(&body) {
        Ok(json) => json,
        Err(e) => {
            error!("Failed to parse webhook payload: {}", e);
            // Возвращаем 200, чтобы MAX не повторял бесконечно
            return HttpResponse::Ok().finish();
        }
    };

    // 3. Отправляем в диспетчер (raw + typed)
    state.dispatcher.dispatch_raw(update_json).await;

    // 4. Всегда отвечаем 200 OK – MAX ожидает успешный ответ в течение 30 секунд
    HttpResponse::Ok().finish()
}