use crate::Editor;

use std::{path::Path, sync::Arc};

use anyhow::Context;
use gpui::WindowContext;
use language::{BasicContextProvider, ContextProvider};
use project::{Location, WorktreeId};
use task::{TaskContext, TaskVariables, VariableName};
use util::ResultExt;
use workspace::Workspace;

pub(crate) fn task_context_for_location(
    workspace: &Workspace,
    location: Location,
    cx: &mut WindowContext<'_>,
) -> Option<TaskContext> {
    let cwd = workspace::tasks::task_cwd(workspace, cx)
        .log_err()
        .flatten();

    let buffer = location.buffer.clone();
    let language_context_provider = buffer
        .read(cx)
        .language()
        .and_then(|language| language.context_provider())
        .unwrap_or_else(|| Arc::new(BasicContextProvider));

    let worktree_abs_path = buffer
        .read(cx)
        .file()
        .map(|file| WorktreeId::from_usize(file.worktree_id()))
        .and_then(|worktree_id| {
            workspace
                .project()
                .read(cx)
                .worktree_for_id(worktree_id, cx)
                .map(|worktree| worktree.read(cx).abs_path())
        });
    let task_variables = combine_task_variables(
        worktree_abs_path.as_deref(),
        location,
        language_context_provider.as_ref(),
        cx,
    )
    .log_err()?;
    Some(TaskContext {
        cwd,
        task_variables,
    })
}

pub(crate) fn task_context_with_editor(
    workspace: &Workspace,
    editor: &mut Editor,
    cx: &mut WindowContext<'_>,
) -> Option<TaskContext> {
    let (selection, buffer, editor_snapshot) = {
        let selection = editor.selections.newest::<usize>(cx);
        let (buffer, _, _) = editor
            .buffer()
            .read(cx)
            .point_to_buffer_offset(selection.start, cx)?;
        let snapshot = editor.snapshot(cx);
        Some((selection, buffer, snapshot))
    }?;
    let selection_range = selection.range();
    let start = editor_snapshot
        .display_snapshot
        .buffer_snapshot
        .anchor_after(selection_range.start)
        .text_anchor;
    let end = editor_snapshot
        .display_snapshot
        .buffer_snapshot
        .anchor_after(selection_range.end)
        .text_anchor;
    let location = Location {
        buffer,
        range: start..end,
    };
    task_context_for_location(workspace, location.clone(), cx).map(|mut task_context| {
        for range in location
            .buffer
            .read(cx)
            .snapshot()
            .runnable_ranges(location.range)
        {
            for (capture_name, value) in range.extra_captures {
                task_context
                    .task_variables
                    .insert(VariableName::Custom(capture_name.into()), value);
            }
        }
        task_context
    })
}

pub fn task_context(workspace: &Workspace, cx: &mut WindowContext<'_>) -> TaskContext {
    let Some(editor) = workspace
        .active_item(cx)
        .and_then(|item| item.act_as::<Editor>(cx))
    else {
        return Default::default();
    };
    editor.update(cx, |editor, cx| {
        task_context_with_editor(workspace, editor, cx).unwrap_or_default()
    })
}

fn combine_task_variables(
    worktree_abs_path: Option<&Path>,
    location: Location,
    context_provider: &dyn ContextProvider,
    cx: &mut WindowContext<'_>,
) -> anyhow::Result<TaskVariables> {
    if context_provider.is_basic() {
        context_provider
            .build_context(worktree_abs_path, &location, cx)
            .context("building basic provider context")
    } else {
        let mut basic_context = BasicContextProvider
            .build_context(worktree_abs_path, &location, cx)
            .context("building basic default context")?;
        basic_context.extend(
            context_provider
                .build_context(worktree_abs_path, &location, cx)
                .context("building provider context ")?,
        );
        Ok(basic_context)
    }
}