use anyhow::{Context as _, Result};
use async_trait::async_trait;
use dap::{DapLocator, DebugRequest, adapters::DebugAdapterName};
use gpui::{BackgroundExecutor, SharedString};
use serde_json::{Value, json};
use smol::{io::AsyncReadExt, process::Stdio as SmolStdio};
use std::time::Duration;
use task::{BuildTaskDefinition, DebugScenario, ShellBuilder, SpawnInTerminal, TaskTemplate};
use util::command::{Stdio, new_command};

pub(crate) struct CargoLocator;

async fn find_best_executable(
    executables: &[String],
    test_name: &str,
    executor: BackgroundExecutor,
) -> Option<String> {
    if executables.len() == 1 {
        return executables.first().cloned();
    }
    for executable in executables {
        let Some(mut child) = new_command(&executable)
            .arg("--list")
            .stdout(Stdio::piped())
            .spawn()
            .ok()
        else {
            continue;
        };
        let mut test_lines = String::default();
        let exec_result = smol::future::race(
            async {
                if let Some(mut stdout) = child.stdout.take() {
                    stdout.read_to_string(&mut test_lines).await?;
                }
                Ok(())
            },
            async {
                executor.timer(Duration::from_secs(3)).await;
                anyhow::bail!("Timed out waiting for executable stdout")
            },
        );

        if let Err(err) = exec_result.await {
            log::warn!("Failed to list tests for {executable}: {err}");
        } else {
            for line in test_lines.lines() {
                if line.contains(&test_name) {
                    return Some(executable.clone());
                }
            }
        }
        let _ = child.kill();
    }
    None
}
#[async_trait]
impl DapLocator for CargoLocator {
    fn name(&self) -> SharedString {
        SharedString::new_static("rust-cargo-locator")
    }
    async fn create_scenario(
        &self,
        build_config: &TaskTemplate,
        resolved_label: &str,
        adapter: &DebugAdapterName,
    ) -> Option<DebugScenario> {
        if build_config.command != "cargo" {
            return None;
        }
        let mut task_template = build_config.clone();
        let cargo_action = task_template.args.first_mut()?;
        if cargo_action == "check" || cargo_action == "clean" {
            return None;
        }

        match cargo_action.as_ref() {
            "run" | "r" => {
                *cargo_action = "build".to_owned();
            }
            "test" | "t" | "bench" => {
                let delimiter = task_template
                    .args
                    .iter()
                    .position(|arg| arg == "--")
                    .unwrap_or(task_template.args.len());
                if !task_template.args[..delimiter]
                    .iter()
                    .any(|arg| arg == "--no-run")
                {
                    task_template.args.insert(delimiter, "--no-run".to_owned());
                }
            }
            _ => {}
        }

        let config = if adapter.as_ref() == "CodeLLDB" {
            json!({
                "sourceLanguages": ["rust"]
            })
        } else {
            Value::Null
        };
        Some(DebugScenario {
            adapter: adapter.0.clone(),
            label: resolved_label.to_string().into(),
            build: Some(BuildTaskDefinition::Template {
                task_template,
                locator_name: Some(self.name()),
            }),
            config,
            tcp_connection: None,
        })
    }

    async fn run(
        &self,
        build_config: SpawnInTerminal,
        executor: BackgroundExecutor,
    ) -> Result<DebugRequest> {
        let cwd = build_config
            .cwd
            .clone()
            .context("Couldn't get cwd from debug config which is needed for locators")?;
        let builder = ShellBuilder::new(&build_config.shell, cfg!(windows)).non_interactive();
        let mut child = builder
            .build_smol_command(
                Some("cargo".into()),
                &build_config
                    .args
                    .iter()
                    .cloned()
                    .take_while(|arg| arg != "--")
                    .chain(Some("--message-format=json".to_owned()))
                    .collect::<Vec<_>>(),
            )
            .envs(build_config.env.iter().map(|(k, v)| (k.clone(), v.clone())))
            .current_dir(cwd)
            .stdout(SmolStdio::piped())
            .spawn()?;

        let mut output = String::new();
        if let Some(mut stdout) = child.stdout.take() {
            stdout.read_to_string(&mut output).await?;
        }

        let status = child.status().await?;
        anyhow::ensure!(status.success(), "Cargo command failed");

        let is_test = build_config
            .args
            .first()
            .is_some_and(|arg| arg == "test" || arg == "t");

        let is_ignored = build_config.args.contains(&"--include-ignored".to_owned());

        let executables = output
            .lines()
            .filter(|line| !line.trim().is_empty())
            .filter_map(|line| serde_json::from_str(line).ok())
            .filter(|json: &Value| {
                let is_test_binary = json
                    .get("profile")
                    .and_then(|profile| profile.get("test"))
                    .and_then(Value::as_bool)
                    .unwrap_or(false);

                if is_test {
                    is_test_binary
                } else {
                    !is_test_binary
                }
            })
            .filter_map(|json: Value| {
                json.get("executable")
                    .and_then(Value::as_str)
                    .map(String::from)
            })
            .collect::<Vec<_>>();
        anyhow::ensure!(
            !executables.is_empty(),
            "Couldn't get executable in cargo locator"
        );

        let mut test_name = None;
        if is_test {
            test_name = build_config
                .args
                .iter()
                .rev()
                .take_while(|name| "--" != name.as_str())
                .find(|name| !name.starts_with("-"))
                .cloned();
        }
        let executable = {
            if let Some(name) = test_name.as_ref().and_then(|name| {
                name.strip_prefix('$')
                    .map(|name| build_config.env.get(name))
                    .unwrap_or(Some(name))
            }) {
                find_best_executable(&executables, name, executor).await
            } else {
                None
            }
        };

        let Some(executable) = executable.or_else(|| executables.first().cloned()) else {
            anyhow::bail!("Couldn't get executable in cargo locator");
        };

        let args = build_test_binary_args(test_name.as_deref(), is_test, is_ignored);

        Ok(DebugRequest::Launch(task::LaunchRequest {
            program: executable,
            cwd: build_config.cwd,
            args,
            env: build_config.env.into_iter().collect(),
        }))
    }
}

fn build_test_binary_args(test_name: Option<&str>, is_test: bool, is_ignored: bool) -> Vec<String> {
    let mut args: Vec<String> = test_name.map(str::to_owned).into_iter().collect();
    if is_test {
        args.push("--nocapture".to_owned());
        if is_ignored {
            args.push("--include-ignored".to_owned());
            // Append `--exact` only if we can be sure the name is fully
            // qualified. Runnables produced from tree-sitter are not qualified
            // (see #51810).
            if test_name.is_some_and(|name| name.contains("::")) {
                args.push("--exact".to_owned());
            }
        }
    }
    args
}

#[cfg(test)]
mod tests {
    use super::build_test_binary_args;

    #[test]
    fn non_test_invocation_has_no_test_args() {
        assert_eq!(
            build_test_binary_args(None, false, false),
            Vec::<String>::new()
        );
    }

    #[test]
    fn bare_test_name_does_not_get_exact() {
        // Zed's tree-sitter runnable template for Rust tests captures only the function
        // identifier and always passes `--include-ignored`, so `is_ignored` is true here
        // for a regular (non-ignored) test.
        assert_eq!(
            build_test_binary_args(Some("get_complex_variant"), true, true),
            vec![
                "get_complex_variant".to_owned(),
                "--nocapture".to_owned(),
                "--include-ignored".to_owned(),
            ],
        );
    }

    #[test]
    fn qualified_test_name_gets_exact() {
        assert_eq!(
            build_test_binary_args(Some("variant_get::test::get_complex_variant"), true, true,),
            vec![
                "variant_get::test::get_complex_variant".to_owned(),
                "--nocapture".to_owned(),
                "--include-ignored".to_owned(),
                "--exact".to_owned(),
            ],
        );
    }

    #[test]
    fn test_without_include_ignored_never_gets_exact() {
        assert_eq!(
            build_test_binary_args(Some("variant_get::test::get_complex_variant"), true, false,),
            vec![
                "variant_get::test::get_complex_variant".to_owned(),
                "--nocapture".to_owned(),
            ],
        );
    }
}