use std::sync::Arc;

use crate::Editor;
use collections::HashMap;
use futures::stream::FuturesUnordered;
use gpui::{App, AppContext as _, Entity, Task};
use itertools::Itertools;
use language::Buffer;
use language::Language;
use lsp::LanguageServerId;
use lsp::LanguageServerName;
use multi_buffer::Anchor;
use project::LanguageServerToQuery;
use project::LocationLink;
use project::Project;
use project::TaskSourceKind;
use project::lsp_store::lsp_ext_command::GetLspRunnables;
use smol::stream::StreamExt;
use task::ResolvedTask;
use task::TaskContext;
use text::BufferId;
use util::ResultExt as _;

pub(crate) fn find_specific_language_server_in_selection<F>(
    editor: &Editor,
    cx: &mut App,
    filter_language: F,
    language_server_name: &str,
) -> Task<Option<(Anchor, Arc<Language>, LanguageServerId, Entity<Buffer>)>>
where
    F: Fn(&Language) -> bool,
{
    let Some(project) = &editor.project else {
        return Task::ready(None);
    };

    let applicable_buffers = editor
        .selections
        .disjoint_anchors()
        .iter()
        .filter(|selection| selection.start == selection.end)
        .filter_map(|selection| Some((selection.start, selection.start.buffer_id?)))
        .filter_map(|(trigger_anchor, buffer_id)| {
            let buffer = editor.buffer().read(cx).buffer(buffer_id)?;
            let language = buffer.read(cx).language_at(trigger_anchor.text_anchor)?;
            if filter_language(&language) {
                Some((trigger_anchor, buffer, language))
            } else {
                None
            }
        })
        .unique_by(|(_, buffer, _)| buffer.read(cx).remote_id())
        .collect::<Vec<_>>();

    let applicable_buffer_tasks = applicable_buffers
        .into_iter()
        .map(|(trigger_anchor, buffer, language)| {
            let task = buffer.update(cx, |buffer, cx| {
                project.update(cx, |project, cx| {
                    project.language_server_id_for_name(buffer, language_server_name, cx)
                })
            });
            (trigger_anchor, buffer, language, task)
        })
        .collect::<Vec<_>>();
    cx.background_spawn(async move {
        for (trigger_anchor, buffer, language, task) in applicable_buffer_tasks {
            if let Some(server_id) = task.await {
                return Some((trigger_anchor, language, server_id, buffer));
            }
        }

        None
    })
}

pub fn lsp_tasks(
    project: Entity<Project>,
    task_sources: &HashMap<LanguageServerName, Vec<BufferId>>,
    for_position: Option<text::Anchor>,
    cx: &mut App,
) -> Task<Vec<(TaskSourceKind, Vec<(Option<LocationLink>, ResolvedTask)>)>> {
    let mut lsp_task_sources = task_sources
        .iter()
        .map(|(name, buffer_ids)| {
            let buffers = buffer_ids
                .iter()
                .filter(|&&buffer_id| match for_position {
                    Some(for_position) => for_position.buffer_id == Some(buffer_id),
                    None => true,
                })
                .filter_map(|&buffer_id| project.read(cx).buffer_for_id(buffer_id, cx))
                .collect::<Vec<_>>();
            language_server_for_buffers(project.clone(), name.clone(), buffers, cx)
        })
        .collect::<FuturesUnordered<_>>();

    cx.spawn(async move |cx| {
        let mut lsp_tasks = Vec::new();
        let lsp_task_context = TaskContext::default();
        while let Some(server_to_query) = lsp_task_sources.next().await {
            if let Some((server_id, buffers)) = server_to_query {
                let source_kind = TaskSourceKind::Lsp(server_id);
                let id_base = source_kind.to_id_base();
                let mut new_lsp_tasks = Vec::new();
                for buffer in buffers {
                    if let Ok(runnables_task) = project.update(cx, |project, cx| {
                        let buffer_id = buffer.read(cx).remote_id();
                        project.request_lsp(
                            buffer,
                            LanguageServerToQuery::Other(server_id),
                            GetLspRunnables {
                                buffer_id,
                                position: for_position,
                            },
                            cx,
                        )
                    }) {
                        if let Some(new_runnables) = runnables_task.await.log_err() {
                            new_lsp_tasks.extend(new_runnables.runnables.into_iter().filter_map(
                                |(location, runnable)| {
                                    let resolved_task =
                                        runnable.resolve_task(&id_base, &lsp_task_context)?;
                                    Some((location, resolved_task))
                                },
                            ));
                        }
                    }
                }
                lsp_tasks.push((source_kind, new_lsp_tasks));
            }
        }
        lsp_tasks
    })
}

fn language_server_for_buffers(
    project: Entity<Project>,
    name: LanguageServerName,
    candidates: Vec<Entity<Buffer>>,
    cx: &mut App,
) -> Task<Option<(LanguageServerId, Vec<Entity<Buffer>>)>> {
    cx.spawn(async move |cx| {
        for buffer in &candidates {
            let server_id = buffer
                .update(cx, |buffer, cx| {
                    project.update(cx, |project, cx| {
                        project.language_server_id_for_name(buffer, &name.0, cx)
                    })
                })
                .ok()?
                .await;
            if let Some(server_id) = server_id {
                return Some((server_id, candidates));
            }
        }
        None
    })
}