use std::collections::HashMap;

use aster_core::analysis::{self, SymbolKind};
use aster_core::lexer::Lexer;
use aster_core::parser::Parser;
use lsp_server::{Connection, Message, Request};
use lsp_types::{HoverContents, MarkupContent, MarkupKind, TextDocumentPositionParams, Uri};

use crate::completion;

const BUILTINS: &[&str] = &[
    "print", "input", "clock", "len", "typeof", "push", "pop",
    "split", "trim", "substring", "replace", "contains",
    "upper", "lower", "starts_with", "ends_with", "require",
];

pub fn handle_hover(
    documents: &HashMap<Uri, String>,
    connection: &Connection,
    req: Request,
) {
    let id = req.id;
    let params: TextDocumentPositionParams = match serde_json::from_value(req.params) {
        Ok(p) => p,
        Err(e) => {
            eprintln!("Invalid hover params: {}", e);
            return;
        }
    };

    let uri = params.text_document.uri;
    let position = params.position;

    let text = documents.get(&uri).map(|s| s.as_str()).unwrap_or("");
    let word = completion::get_word_at_position(text, position);

    if word.is_empty() {
        let resp = lsp_server::Response::new_ok::<Option<()>>(id, None);
        let _ = connection.sender.send(Message::Response(resp));
        return;
    }

    // Check builtins
    if BUILTINS.contains(&word.as_str()) {
        let contents = HoverContents::Markup(MarkupContent {
            kind: MarkupKind::Markdown,
            value: format!("**builtin** `{}`", word),
        });
        let hover = lsp_types::Hover {
            contents,
            range: None,
        };
        let resp = lsp_server::Response::new_ok(id, hover);
        let _ = connection.sender.send(Message::Response(resp));
        return;
    }

    // Check keywords
    const KEYWORDS: &[&str] = &[
        "let", "const", "fn", "if", "else", "while", "for", "in",
        "break", "continue", "return", "true", "false", "nil",
    ];
    if KEYWORDS.contains(&word.as_str()) {
        let contents = HoverContents::Markup(MarkupContent {
            kind: MarkupKind::Markdown,
            value: format!("**keyword** `{}`", word),
        });
        let hover = lsp_types::Hover { contents, range: None };
        let resp = lsp_server::Response::new_ok(id, hover);
        let _ = connection.sender.send(Message::Response(resp));
        return;
    }

    // Check user-defined symbols
    let (tokens, _) = Lexer::new(text).tokenize();
    let mut parser = Parser::new(tokens);
    let (stmts, _) = parser.parse();
    let symbols = analysis::collect_symbols(&stmts);

    for sym in &symbols {
        if sym.name == word {
            let markdown = match &sym.kind {
                SymbolKind::Variable => {
                    format!("**variable** `{}`", sym.name)
                }
                SymbolKind::Function { params } => {
                    format!("**fn** `{}({})`", sym.name, params.join(", "))
                }
            };
            let contents = HoverContents::Markup(MarkupContent {
                kind: MarkupKind::Markdown,
                value: markdown,
            });
            let hover = lsp_types::Hover { contents, range: None };
            let resp = lsp_server::Response::new_ok(id, hover);
            let _ = connection.sender.send(Message::Response(resp));
            return;
        }
    }

    // Not found — return null
    let resp = lsp_server::Response::new_ok::<Option<()>>(id, None);
    let _ = connection.sender.send(Message::Response(resp));
}