use crate::{
    handlers::{FileHandler, DirectoryHandler, DefaultFileHandler, DefaultDirectoryHandler},
    config::GurtConfig,
    security::SecurityMiddleware,
};
use gurtlib::prelude::*;
use std::path::Path;
use std::sync::Arc;
use tracing;

pub struct RequestHandlerBuilder {
    file_handler: Arc<dyn FileHandler>,
    directory_handler: Arc<dyn DirectoryHandler>,
    base_directory: std::path::PathBuf,
    config: Option<Arc<GurtConfig>>,
}

impl RequestHandlerBuilder {
    pub fn new<P: AsRef<Path>>(base_directory: P) -> Self {
        Self {
            file_handler: Arc::new(DefaultFileHandler),
            directory_handler: Arc::new(DefaultDirectoryHandler),
            base_directory: base_directory.as_ref().to_path_buf(),
            config: None,
        }
    }

    pub fn with_file_handler<H: FileHandler + 'static>(mut self, handler: H) -> Self {
        self.file_handler = Arc::new(handler);
        self
    }

    pub fn with_directory_handler<H: DirectoryHandler + 'static>(mut self, handler: H) -> Self {
        self.directory_handler = Arc::new(handler);
        self
    }

    pub fn with_config(mut self, config: Arc<GurtConfig>) -> Self {
        self.config = Some(config);
        self
    }

    pub fn build(self) -> RequestHandler {
        let security = self.config.as_ref().map(|config| SecurityMiddleware::new(config.clone()));
        
        RequestHandler {
            file_handler: self.file_handler,
            directory_handler: self.directory_handler,
            base_directory: self.base_directory,
            config: self.config,
            security,
        }
    }
}

pub struct RequestHandler {
    file_handler: Arc<dyn FileHandler>,
    directory_handler: Arc<dyn DirectoryHandler>,
    base_directory: std::path::PathBuf,
    config: Option<Arc<GurtConfig>>,
    security: Option<SecurityMiddleware>,
}

impl RequestHandler {
    pub fn builder<P: AsRef<Path>>(base_directory: P) -> RequestHandlerBuilder {
        RequestHandlerBuilder::new(base_directory)
    }

    fn apply_custom_error_page(&self, mut response: GurtResponse) -> GurtResponse {
        if response.status_code >= 400 {
            let custom_content = self.get_custom_error_page(response.status_code)
                .unwrap_or_else(|| self.get_fallback_error_page(response.status_code));
            
            response.body = custom_content.into_bytes();
            response = response.with_header("Content-Type", "text/html");
            tracing::debug!("Applied error page for status {}", response.status_code);
        }
        response
    }

    fn get_custom_error_page(&self, status_code: u16) -> Option<String> {
        if let Some(config) = &self.config {
            if let Some(error_pages) = &config.error_pages {
                error_pages.get_page_content(status_code, &self.base_directory)
            } else {
                None
            }
        } else {
            None
        }
    }

    fn get_fallback_error_page(&self, status_code: u16) -> String {
        let (title, message) = match status_code {
            400 => ("Bad Request", "The request could not be understood by the server."),
            401 => ("Unauthorized", "Authentication is required to access this resource."),
            403 => ("Forbidden", "Access to this resource is denied by server policy."),
            404 => ("Not Found", "The requested resource was not found on this server."),
            405 => ("Method Not Allowed", "The request method is not allowed for this resource."),
            429 => ("Too Many Requests", "You have exceeded the rate limit. Please try again later."),
            500 => ("Internal Server Error", "The server encountered an error processing your request."),
            502 => ("Bad Gateway", "The server received an invalid response from an upstream server."),
            503 => ("Service Unavailable", "The server is temporarily unavailable. Please try again later."),
            504 => ("Gateway Timeout", "The server did not receive a timely response from an upstream server."),
            _ => ("Error", "An error occurred while processing your request."),
        };

        format!(include_str!("../templates/error.html"), status_code, title, status_code, title, message)
    }

    pub fn check_security(&self, ctx: &ServerContext) -> Option<std::result::Result<GurtResponse, GurtError>> {
        if let Some(security) = &self.security {
            let client_ip = ctx.client_ip();
            let method = ctx.method();

            if !security.is_method_allowed(method) {
                tracing::warn!("Method {} not allowed from {}", method, client_ip);
                let response = security.create_method_not_allowed_response()
                    .map(|r| self.apply_global_headers(r));
                return Some(response);
            }

            if !security.check_rate_limit(client_ip) {
                let response = security.create_rate_limit_response()
                    .map(|r| self.apply_global_headers(r));
                return Some(response);
            }

            if !security.check_connection_limit(client_ip) {
                let response = security.create_rate_limit_response()
                    .map(|r| self.apply_global_headers(r));
                return Some(response);
            }
        }

        None
    }

    pub fn register_connection(&self, client_ip: std::net::IpAddr) {
        if let Some(security) = &self.security {
            security.register_connection(client_ip);
        }
    }

    pub fn unregister_connection(&self, client_ip: std::net::IpAddr) {
        if let Some(security) = &self.security {
            security.unregister_connection(client_ip);
        }
    }

    fn is_file_denied(&self, file_path: &Path) -> bool {
        if let Some(config) = &self.config {
            let path_str = file_path.to_string_lossy();
            
            let relative_path = if let Ok(canonical_file) = file_path.canonicalize() {
                if let Ok(canonical_base) = self.base_directory.canonicalize() {
                    canonical_file.strip_prefix(&canonical_base)
                        .map(|p| p.to_string_lossy().to_string())
                        .unwrap_or_else(|_| path_str.to_string())
                } else {
                    path_str.to_string()
                }
            } else {
                path_str.to_string()
            };

            let is_denied = config.should_deny_file(&path_str) || config.should_deny_file(&relative_path);
            
            if is_denied {
                tracing::warn!("File access denied by security policy: {}", relative_path);
            }
            
            is_denied
        } else {
            false
        }
    }

    fn apply_global_headers(&self, mut response: GurtResponse) -> GurtResponse {
        response = self.apply_custom_error_page(response);
        
        if let Some(config) = &self.config {
            if let Some(headers) = &config.headers {
                for (key, value) in headers {
                    response = response.with_header(key, value);
                }
            }
        }
        response
    }

    fn create_forbidden_response(&self) -> std::result::Result<GurtResponse, GurtError> {
        let response = GurtResponse::forbidden()
            .with_header("Content-Type", "text/html");
        
        Ok(self.apply_global_headers(response))
    }

    pub async fn handle_root_request_with_context(&self, ctx: ServerContext) -> std::result::Result<GurtResponse, GurtError> {
        let client_ip = ctx.client_ip();
        
        self.register_connection(client_ip);
        
        if let Some(security_response) = self.check_security(&ctx) {
            self.unregister_connection(client_ip);
            return security_response;
        }
        
        let result = self.handle_root_request().await;
        self.unregister_connection(client_ip);
        result
    }

    pub async fn handle_file_request_with_context(&self, request_path: &str, ctx: ServerContext) -> std::result::Result<GurtResponse, GurtError> {
        let client_ip = ctx.client_ip();
        
        self.register_connection(client_ip);
        
        if let Some(security_response) = self.check_security(&ctx) {
            self.unregister_connection(client_ip);
            return security_response;
        }
        
        let result = self.handle_file_request(request_path).await;
        self.unregister_connection(client_ip);
        result
    }

    pub async fn handle_method_request_with_context(&self, ctx: ServerContext) -> std::result::Result<GurtResponse, GurtError> {
        let client_ip = ctx.client_ip();
        let method = ctx.method();
        
        self.register_connection(client_ip);
        
        if let Some(security_response) = self.check_security(&ctx) {
            self.unregister_connection(client_ip);
            return security_response;
        }
        
        let result = match method {
            gurtlib::message::GurtMethod::GET => {
                if ctx.path() == "/" {
                    self.handle_root_request().await
                } else {
                    self.handle_file_request(ctx.path()).await
                }
            }
            gurtlib::message::GurtMethod::HEAD => {
                let mut response = if ctx.path() == "/" {
                    self.handle_root_request().await?
                } else {
                    self.handle_file_request(ctx.path()).await?
                };
                response.body = Vec::new();
                Ok(response)
            }
            gurtlib::message::GurtMethod::OPTIONS => {
                let allowed_methods = if let Some(config) = &self.config {
                    if let Some(security) = &config.security {
                        security.allowed_methods.join(", ")
                    } else {
                        "GET, POST, PUT, DELETE, HEAD, OPTIONS, PATCH".to_string()
                    }
                } else {
                    "GET, POST, PUT, DELETE, HEAD, OPTIONS, PATCH".to_string()
                };
                
                let response = GurtResponse::ok()
                    .with_header("Allow", &allowed_methods)
                    .with_header("Content-Type", "text/plain")
                    .with_string_body("Allowed methods");
                Ok(self.apply_global_headers(response))
            }
            _ => {
                let response = GurtResponse::new(gurtlib::protocol::GurtStatusCode::MethodNotAllowed)
                    .with_header("Content-Type", "text/html");
                Ok(self.apply_global_headers(response))
            }
        };
        
        self.unregister_connection(client_ip);
        result
    }

    pub async fn handle_root_request(&self) -> std::result::Result<GurtResponse, GurtError> {
        let index_path = self.base_directory.join("index.html");

        if index_path.exists() && index_path.is_file() {
            if self.is_file_denied(&index_path) {
                return self.create_forbidden_response();
            }

            match self.file_handler.handle_file(&index_path) {
                Ok(content) => {
                    let content_type = self.file_handler.get_content_type(&index_path);
                    let response = GurtResponse::ok()
                        .with_header("Content-Type", &content_type)
                        .with_body(content);
                    return Ok(self.apply_global_headers(response));
                }
                Err(_) => {
                    // fall
                }
            }
        }

        match self.directory_handler.handle_directory(&self.base_directory, "/") {
            Ok(listing) => {
                let response = GurtResponse::ok()
                    .with_header("Content-Type", "text/html")
                    .with_string_body(listing);
                Ok(self.apply_global_headers(response))
            }
            Err(_) => {
                let response = GurtResponse::internal_server_error()
                    .with_header("Content-Type", "text/html");
                Ok(self.apply_global_headers(response))
            }
        }
    }

    pub async fn handle_file_request(&self, request_path: &str) -> std::result::Result<GurtResponse, GurtError> {
        let path_without_query = if let Some(query_start) = request_path.find('?') {
            &request_path[..query_start]
        } else {
            request_path
        };
        
        let mut relative_path = path_without_query.strip_prefix('/').unwrap_or(path_without_query).to_string();
        
        while relative_path.starts_with('/') || relative_path.starts_with('\\') {
            relative_path = relative_path[1..].to_string();
        }
        
        let relative_path = if relative_path.is_empty() { 
            ".".to_string() 
        } else { 
            relative_path 
        };
        
        let file_path = self.base_directory.join(&relative_path);

        if self.is_file_denied(&file_path) {
            return self.create_forbidden_response();
        }

        match file_path.canonicalize() {
            Ok(canonical_path) => {
                let canonical_base = match self.base_directory.canonicalize() {
                    Ok(base) => base,
                    Err(_) => {
                        return Ok(GurtResponse::internal_server_error()
                            .with_header("Content-Type", "text/html"));
                    }
                };

                if !canonical_path.starts_with(&canonical_base) {
                    let response = GurtResponse::bad_request()
                        .with_header("Content-Type", "text/html");
                    return Ok(self.apply_global_headers(response));
                }
                
                if self.is_file_denied(&canonical_path) {
                    return self.create_forbidden_response();
                }
                
                if canonical_path.is_file() {
                    self.handle_file_response(&canonical_path).await
                } else if canonical_path.is_dir() {
                    self.handle_directory_response(&canonical_path, request_path).await
                } else {
                    self.handle_not_found_response().await
                }
            }
            Err(_) => {
                self.handle_not_found_response().await
            }
        }
    }

    async fn handle_file_response(&self, path: &Path) -> std::result::Result<GurtResponse, GurtError> {
        match self.file_handler.handle_file(path) {
            Ok(content) => {
                let content_type = self.file_handler.get_content_type(path);
                let response = GurtResponse::ok()
                    .with_header("Content-Type", &content_type)
                    .with_body(content);
                Ok(self.apply_global_headers(response))
            }
            Err(_) => {
                let response = GurtResponse::internal_server_error()
                    .with_header("Content-Type", "text/html");
                Ok(self.apply_global_headers(response))
            }
        }
    }

    async fn handle_directory_response(&self, canonical_path: &Path, request_path: &str) -> std::result::Result<GurtResponse, GurtError> {
        let index_path = canonical_path.join("index.html");
        if index_path.is_file() {
            self.handle_file_response(&index_path).await
        } else {
            match self.directory_handler.handle_directory(canonical_path, request_path) {
                Ok(listing) => {
                    let response = GurtResponse::ok()
                        .with_header("Content-Type", "text/html")
                        .with_string_body(listing);
                    Ok(self.apply_global_headers(response))
                }
                Err(_) => {
                    let response = GurtResponse::internal_server_error()
                        .with_header("Content-Type", "text/html");
                    Ok(self.apply_global_headers(response))
                }
            }
        }
    }

    async fn handle_not_found_response(&self) -> std::result::Result<GurtResponse, GurtError> {
        let content = self.get_custom_error_page(404)
            .unwrap_or_else(|| crate::handlers::get_404_html().to_string());
        
        let response = GurtResponse::not_found()
            .with_header("Content-Type", "text/html")
            .with_string_body(content);
        Ok(self.apply_global_headers(response))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use gurtlib::GurtStatusCode;
    use std::fs;
    use std::env;

    fn create_test_handler() -> RequestHandler {
        let temp_dir = env::temp_dir().join("gurty_request_handler_test");
        let _ = fs::create_dir_all(&temp_dir);
        
        RequestHandler::builder(&temp_dir).build()
    }

    fn create_test_handler_with_config() -> RequestHandler {
        let temp_dir = env::temp_dir().join("gurty_request_handler_test_config");
        let _ = fs::create_dir_all(&temp_dir);
        
        let config = Arc::new(GurtConfig::default());
        RequestHandler::builder(&temp_dir)
            .with_config(config)
            .build()
    }

    #[test]
    fn test_request_handler_builder() {
        let temp_dir = env::temp_dir().join("gurty_builder_test");
        let _ = fs::create_dir_all(&temp_dir);
        
        let handler = RequestHandler::builder(&temp_dir).build();
        
        assert_eq!(handler.base_directory, temp_dir);
        assert!(handler.config.is_none());
        assert!(handler.security.is_none());
        
        let _ = fs::remove_dir_all(&temp_dir);
    }

    #[test]
    fn test_request_handler_builder_with_config() {
        let temp_dir = env::temp_dir().join("gurty_builder_config_test");
        let _ = fs::create_dir_all(&temp_dir);
        
        let config = Arc::new(GurtConfig::default());
        let handler = RequestHandler::builder(&temp_dir)
            .with_config(config.clone())
            .build();
        
        assert!(handler.config.is_some());
        assert!(handler.security.is_some());
        
        let _ = fs::remove_dir_all(&temp_dir);
    }

    #[test]
    fn test_fallback_error_page_generation() {
        let handler = create_test_handler();
        
        let error_404 = handler.get_fallback_error_page(404);
        assert!(error_404.contains("404 Not Found"));
        assert!(error_404.contains("not found"));
        
        let error_500 = handler.get_fallback_error_page(500);
        assert!(error_500.contains("500 Internal Server Error"));
        assert!(error_500.contains("processing your request"));
        
        let error_429 = handler.get_fallback_error_page(429);
        assert!(error_429.contains("429 Too Many Requests"));
        assert!(error_429.contains("rate limit"));
    }

    #[test]
    fn test_custom_error_page_with_config() {
        let handler = create_test_handler_with_config();
        
        let result = handler.get_custom_error_page(404);
        assert!(result.is_none());
    }

    #[test]
    fn test_apply_global_headers_without_config() {
        let handler = create_test_handler();
        let response = GurtResponse::ok();
        
        let modified_response = handler.apply_global_headers(response);
        
        assert_eq!(modified_response.status_code, 200);
    }

    #[test]
    fn test_apply_global_headers_with_config() {
        let temp_dir = env::temp_dir().join("gurty_headers_test");
        let _ = fs::create_dir_all(&temp_dir);
        
        let mut config = GurtConfig::default();
        let mut headers = std::collections::HashMap::new();
        headers.insert("X-Test-Header".to_string(), "test-value".to_string());
        config.headers = Some(headers);
        
        let handler = RequestHandler::builder(&temp_dir)
            .with_config(Arc::new(config))
            .build();
        
        let response = GurtResponse::ok();
        let modified_response = handler.apply_global_headers(response);
        
        assert!(modified_response.headers.contains_key("x-test-header"));
        assert_eq!(modified_response.headers.get("x-test-header").unwrap(), "test-value");
        
        let _ = fs::remove_dir_all(&temp_dir);
    }

    #[test]
    fn test_apply_custom_error_page() {
        let handler = create_test_handler();
        let mut response = GurtResponse::new(GurtStatusCode::NotFound);
        response.body = b"Not Found".to_vec();
        
        let modified_response = handler.apply_custom_error_page(response);
        
        assert!(modified_response.status_code >= 400);
        let body_str = String::from_utf8_lossy(&modified_response.body);
        assert!(body_str.contains("html"));
    }

    #[test]
    fn test_apply_custom_error_page_for_success() {
        let handler = create_test_handler();
        let mut response = GurtResponse::ok();
        response.body = b"Success".to_vec();
        
        let modified_response = handler.apply_custom_error_page(response);
        
        assert_eq!(modified_response.status_code, 200);
        assert_eq!(modified_response.body, b"Success".to_vec());
    }
}