use collections::HashMap;
use futures::future::join_all;
use gpui::{App, Entity, Task};
use itertools::Itertools;
use language::{Buffer, BufferSnapshot};
use lsp::LanguageServerId;
use project::lsp_store::{BufferDocumentLinks, LspDocumentLink, ResolvedDocumentLink};
use settings::Settings;
use text::BufferId;
use ui::Context;

use crate::{Editor, LSP_REQUEST_DEBOUNCE_TIMEOUT, editor_settings::EditorSettings};

pub(super) struct LspDocumentLinks {
    pub(super) enabled: bool,
    pub(super) per_buffer: HashMap<BufferId, BufferDocumentLinks>,
    pub(super) refresh_task: Task<()>,
}

impl LspDocumentLinks {
    pub(super) fn new(cx: &App) -> Self {
        Self {
            enabled: EditorSettings::get_global(cx).lsp_document_links,
            per_buffer: HashMap::default(),
            refresh_task: Task::ready(()),
        }
    }
}

impl Editor {
    pub(super) fn refresh_document_links(
        &mut self,
        for_buffer: Option<BufferId>,
        cx: &mut Context<Self>,
    ) {
        if !self.lsp_data_enabled() || !self.lsp_document_links.enabled {
            return;
        }
        let Some(project) = self.project.as_ref().map(|p| p.downgrade()) else {
            return;
        };

        let buffers_to_query = self
            .visible_buffers(cx)
            .into_iter()
            .filter(|buffer| self.is_lsp_relevant(buffer.read(cx).file(), cx))
            .chain(for_buffer.and_then(|id| self.buffer.read(cx).buffer(id)))
            .filter(|buffer| {
                let id = buffer.read(cx).remote_id();
                for_buffer.is_none_or(|target| target == id)
                    && self.registered_buffers.contains_key(&id)
            })
            .unique_by(|buffer| buffer.read(cx).remote_id())
            .collect::<Vec<_>>();
        if buffers_to_query.is_empty() {
            self.lsp_document_links.refresh_task = Task::ready(());
            return;
        }

        self.lsp_document_links.refresh_task = cx.spawn(async move |editor, cx| {
            cx.background_executor()
                .timer(LSP_REQUEST_DEBOUNCE_TIMEOUT)
                .await;

            let Some(tasks_for_buffers) = project
                .update(cx, |project, cx| {
                    project.lsp_store().update(cx, |lsp_store, cx| {
                        buffers_to_query
                            .into_iter()
                            .map(|buffer| {
                                let buffer_id = buffer.read(cx).remote_id();
                                let task = lsp_store.fetch_document_links(&buffer, cx);
                                async move { (buffer_id, task.await) }
                            })
                            .collect::<Vec<_>>()
                    })
                })
                .ok()
            else {
                return;
            };

            let new_links_for_buffers = join_all(tasks_for_buffers).await;
            editor
                .update(cx, |editor, _| {
                    for (buffer_id, links) in new_links_for_buffers {
                        let Some(links) = links else {
                            continue;
                        };
                        if links.is_empty() {
                            editor.lsp_document_links.per_buffer.remove(&buffer_id);
                        } else {
                            editor
                                .lsp_document_links
                                .per_buffer
                                .insert(buffer_id, links);
                        }
                    }
                })
                .ok();
        });
    }

    /// Returns a task yielding the resolved document links covering `position`
    /// in `buffer`, paired with the language server that owns each link.
    /// Resolution is deduplicated through `LspStore`'s per-`(server_id,
    /// link_id)` `Shared` task; the editor's mirror is updated when the
    /// resolves complete so subsequent renders/hovers find resolved data
    /// without re-issuing requests.
    ///
    /// Returns `None` when nothing is cached at `position` so callers can skip
    /// spawning anything.
    pub fn document_links_at(
        &mut self,
        buffer: Entity<Buffer>,
        position: text::Anchor,
        cx: &mut Context<Self>,
    ) -> Option<Task<Vec<(LanguageServerId, LspDocumentLink)>>> {
        let buffer_id = buffer.read(cx).remote_id();
        let snapshot = buffer.read(cx).snapshot();
        let matches = self
            .lsp_document_links
            .per_buffer
            .get(&buffer_id)?
            .iter()
            .flat_map(|(server_id, per_server)| {
                per_server
                    .iter()
                    .map(move |(link_id, link)| (*server_id, *link_id, link))
            })
            .filter(|(_, _, link)| link_contains(link, &position, &snapshot))
            .map(|(server_id, link_id, link)| (server_id, link_id, link.clone()))
            .collect::<Vec<_>>();
        if matches.is_empty() {
            return None;
        }

        let project = self.project.clone()?;
        let mut resolved_links = Vec::with_capacity(matches.len());
        let mut pending = Vec::new();
        project.update(cx, |project, cx| {
            project.lsp_store().update(cx, |lsp_store, cx| {
                for (server_id, link_id, _link) in matches {
                    match lsp_store.resolved_document_link(&buffer, server_id, link_id, cx) {
                        Some(ResolvedDocumentLink::Resolved(resolved)) => {
                            resolved_links.push((server_id, link_id, resolved));
                        }
                        Some(ResolvedDocumentLink::Resolving(task)) => {
                            pending.push((server_id, task));
                        }
                        None => {
                            // Cache no longer holds the link (likely a version
                            // bump between the mirror snapshot and now); skip.
                        }
                    }
                }
            })
        });

        if pending.is_empty() {
            return Some(Task::ready(
                resolved_links
                    .into_iter()
                    .map(|(server_id, _, link)| (server_id, link))
                    .collect(),
            ));
        }

        Some(cx.spawn(async move |editor, cx| {
            let pending_results =
                join_all(pending.into_iter().map(|(server_id, task)| async move {
                    task.await.map(|(link_id, link)| (server_id, link_id, link))
                }))
                .await;
            resolved_links.extend(pending_results.into_iter().flatten());
            editor
                .update(cx, |editor, cx| {
                    if let Some(by_server) =
                        editor.lsp_document_links.per_buffer.get_mut(&buffer_id)
                    {
                        for (server_id, link_id, resolved) in &resolved_links {
                            if let Some(slot) = by_server
                                .get_mut(server_id)
                                .and_then(|links| links.get_mut(link_id))
                            {
                                *slot = resolved.clone();
                            }
                        }
                    }
                    cx.notify();
                })
                .ok();

            resolved_links
                .into_iter()
                .map(|(server_id, _, link)| (server_id, link))
                .collect()
        }))
    }
}

fn link_contains(
    link: &LspDocumentLink,
    position: &text::Anchor,
    snapshot: &BufferSnapshot,
) -> bool {
    link.range.start.cmp(position, snapshot).is_le()
        && link.range.end.cmp(position, snapshot).is_ge()
}