rustisan_core/

app.rs

//! Application module for the Rustisan framework
//!
//! This module provides the main Application struct that coordinates
//! the entire web application, similar to Laravel's Application.

use std::collections::HashMap;
use std::net::SocketAddr;
use std::sync::Arc;

use axum::{
    extract::{Path, Query},
    http::Method,
    middleware::{self, Next},
    response::{IntoResponse, Response as AxumResponse},
    routing::{delete, get, patch, post, put},
    Json, Router as AxumRouter,
};
use serde_json::{json, Value};
use tokio::net::TcpListener;
use tower::ServiceBuilder;
use tower_http::{
    cors::CorsLayer,
    trace::TraceLayer,
};
use tracing::{info, warn};

use crate::{
    config::Config,
    errors::{Result, RustisanError},
    routing::{Route, RouteGroup, Router},
};

/// The main application struct that manages the entire web application
pub struct Application {
    /// Application configuration
    config: Config,
    /// Application router
    router: Router,
    /// Application state
    state: HashMap<String, Value>,
    /// Whether the application has been built
    built: bool,
    /// The built Axum router
    axum_router: Option<AxumRouter>,
}

/// Application state that can be shared across handlers
#[derive(Clone)]
pub struct AppState {
    /// Application configuration
    pub config: Arc<Config>,
    /// Shared application data
    pub data: Arc<HashMap<String, Value>>,
}

impl Application {
    /// Creates a new Rustisan application
    pub fn new() -> Self {
        Self {
            config: Config::default(),
            router: Router::new(),
            state: HashMap::new(),
            built: false,
            axum_router: None,
        }
    }

    /// Creates a new application with custom configuration
    pub fn with_config(config: Config) -> Self {
        Self {
            config,
            router: Router::new(),
            state: HashMap::new(),
            built: false,
            axum_router: None,
        }
    }

    /// Gets a mutable reference to the router for route registration
    pub fn router(&mut self) -> &mut Router {
        &mut self.router
    }

    /// Sets application state
    pub fn set_state<K, V>(&mut self, key: K, value: V)
    where
        K: Into<String>,
        V: Into<Value>,
    {
        self.state.insert(key.into(), value.into());
    }

    /// Gets application state
    pub fn get_state(&self, key: &str) -> Option<&Value> {
        self.state.get(key)
    }

    /// Builds the application and prepares it for serving
    pub async fn build(&mut self) -> Result<()> {
        if self.built {
            return Ok(());
        }

        info!("🔧 Building Rustisan application...");

        // Create the app state
        let app_state = AppState {
            config: Arc::new(self.config.clone()),
            data: Arc::new(self.state.clone()),
        };

        // Start with a new Axum router
        let mut axum_router = AxumRouter::new();

        // Register all routes
        axum_router = self.register_routes(axum_router).await?;

        // Add middleware
        axum_router = axum_router
            .layer(
                ServiceBuilder::new()
                    .layer(TraceLayer::new_for_http())
                    .layer(CorsLayer::permissive())
                    .layer(middleware::from_fn(error_handler)),
            );

        self.axum_router = Some(axum_router);
        self.built = true;

        info!("✅ Application built successfully");
        Ok(())
    }

    /// Registers all routes with the Axum router
    async fn register_routes(
        &self,
        mut axum_router: AxumRouter,
    ) -> Result<AxumRouter> {
        info!("📍 Registering routes...");

        // Register individual routes
        for route in &self.router.routes {
            axum_router = self.register_single_route(axum_router, route)?;
        }

        // Register route groups
        for group in &self.router.groups {
            axum_router = self.register_group_routes(axum_router, group)?;
        }

        info!("📍 {} routes registered", self.router.routes.len());
        Ok(axum_router)
    }

    /// Registers a single route
    fn register_single_route(
        &self,
        axum_router: AxumRouter,
        route: &Route,
    ) -> Result<AxumRouter> {
        let path = route.path.clone();
        let method = route.method.clone();

        // Create a simple handler that returns a JSON response
        let handler = move || async move {
            Json(json!({
                "message": format!("Route {} {} handled", method, path),
                "status": "success"
            }))
        };

        let router = match route.method {
            Method::GET => axum_router.route(&route.path, get(handler)),
            Method::POST => axum_router.route(&route.path, post(handler)),
            Method::PUT => axum_router.route(&route.path, put(handler)),
            Method::PATCH => axum_router.route(&route.path, patch(handler)),
            Method::DELETE => axum_router.route(&route.path, delete(handler)),
            _ => {
                warn!("Unsupported HTTP method: {}", route.method);
                return Ok(axum_router);
            }
        };

        Ok(router)
    }

    /// Registers routes from a group
    fn register_group_routes(
        &self,
        mut axum_router: AxumRouter,
        group: &RouteGroup,
    ) -> Result<AxumRouter> {
        for route in &group.routes {
            axum_router = self.register_single_route(axum_router, route)?;
        }
        Ok(axum_router)
    }

    /// Starts the HTTP server
    pub async fn serve(&mut self, addr: SocketAddr) -> Result<()> {
        if !self.built {
            self.build().await?;
        }

        let axum_router = self
            .axum_router
            .take()
            .ok_or_else(|| RustisanError::InternalError("Application not built".to_string()))?;

        info!("🚀 Starting Rustisan server on {}", addr);
        info!("📚 Routes available:");

        // Log all registered routes
        for route in &self.router.routes {
            info!("   {} {}", route.method, route.path);
        }

        for group in &self.router.groups {
            for route in &group.routes {
                info!("   {} {}", route.method, route.path);
            }
        }

        let listener = TcpListener::bind(addr).await.map_err(|e| {
            RustisanError::InternalError(format!("Failed to bind to address {}: {}", addr, e))
        })?;

        info!("✅ Server running on http://{}", addr);

        axum::serve(listener, axum_router).await.map_err(|e| {
            RustisanError::InternalError(format!("Server error: {}", e))
        })?;

        Ok(())
    }

    /// Convenience method to serve on default address
    pub async fn serve_default(&mut self) -> Result<()> {
        let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
        self.serve(addr).await
    }

    /// Gets the application configuration
    pub fn config(&self) -> &Config {
        &self.config
    }

    /// Updates the application configuration
    pub fn set_config(&mut self, config: Config) {
        self.config = config;
        self.built = false; // Mark as needing rebuild
    }
}

impl Default for Application {
    fn default() -> Self {
        Self::new()
    }
}

/// Global error handling middleware
async fn error_handler(
    request: axum::extract::Request,
    next: Next,
) -> AxumResponse {
    next.run(request).await
}

/// Handler for routes with path parameters
pub async fn route_with_params_handler(
    Path(params): Path<HashMap<String, String>>,
    Query(query): Query<HashMap<String, String>>,
) -> impl IntoResponse {
    Json(json!({
        "path_params": params,
        "query_params": query,
        "message": "Route with parameters handled successfully"
    }))
}

/// Handler for JSON body requests
pub async fn json_handler(
    Json(payload): Json<Value>,
) -> impl IntoResponse {
    Json(json!({
        "received": payload,
        "message": "JSON payload processed successfully"
    }))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_application_creation() {
        let app = Application::new();
        assert!(!app.built);
        assert!(app.axum_router.is_none());
    }

    #[tokio::test]
    async fn test_application_build() {
        let mut app = Application::new();

        // Add a simple route
        app.router().get("/test", || async {
            crate::Response::ok("Test route").unwrap()
        });

        let result = app.build().await;
        assert!(result.is_ok());
        assert!(app.built);
        assert!(app.axum_router.is_some());
    }

    #[test]
    fn test_application_state() {
        let mut app = Application::new();
        app.set_state("test_key", "test_value");

        assert_eq!(
            app.get_state("test_key"),
            Some(&Value::String("test_value".to_string()))
        );
    }

    #[test]
    fn test_application_config() {
        let config = Config::default();
        let app = Application::with_config(config.clone());
        assert_eq!(app.config().app_name, config.app_name);
    }
}