use std::collections::HashMap;

use aster_core::analysis;
use aster_core::lexer::Lexer;
use lsp_server::{Connection, Message, Request};
use lsp_types::{GotoDefinitionParams, GotoDefinitionResponse, Location, Position, Range, Uri};

use crate::completion;

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

    let uri = params.text_document_position_params.text_document.uri;
    let position = params.text_document_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<GotoDefinitionResponse>>(id, None);
        let _ = connection.sender.send(Message::Response(resp));
        return;
    }

    let (tokens, _) = Lexer::new(text).tokenize();

    if let Some((line, col)) = analysis::find_declaration(&tokens, &word) {
        let l = (line as u32).saturating_sub(1);
        let c = (col as u32).saturating_sub(1);
        let location = Location {
            uri: uri.clone(),
            range: Range {
                start: Position { line: l, character: c },
                end: Position { line: l, character: c + word.len() as u32 },
            },
        };
        let response: GotoDefinitionResponse = GotoDefinitionResponse::Scalar(location);
        let resp = lsp_server::Response::new_ok(id, response);
        let _ = connection.sender.send(Message::Response(resp));
    } else {
        let resp = lsp_server::Response::new_ok::<Option<GotoDefinitionResponse>>(id, None);
        let _ = connection.sender.send(Message::Response(resp));
    }
}