use std::process::Output;

use async_trait::async_trait;
use serde::Deserialize;
use util::command::Command;

use crate::devcontainer_api::DevContainerError;

pub(crate) struct DefaultCommandRunner;

impl DefaultCommandRunner {
    pub(crate) fn new() -> Self {
        Self
    }
}

#[async_trait]
impl CommandRunner for DefaultCommandRunner {
    async fn run_command(&self, command: &mut Command) -> Result<Output, std::io::Error> {
        command.output().await
    }
}

#[async_trait]
pub(crate) trait CommandRunner: Send + Sync {
    async fn run_command(&self, command: &mut Command) -> Result<Output, std::io::Error>;
}

pub(crate) async fn evaluate_json_command<T>(
    mut command: Command,
) -> Result<Option<T>, DevContainerError>
where
    T: for<'de> Deserialize<'de>,
{
    let output = command.output().await.map_err(|e| {
        log::error!("Error running command {:?}: {e}", command);
        DevContainerError::CommandFailed(command.get_program().display().to_string())
    })?;

    deserialize_json_output(output).map_err(|e| {
        log::error!("Error running command {:?}: {e}", command);
        DevContainerError::CommandFailed(command.get_program().display().to_string())
    })
}

pub(crate) fn deserialize_json_output<T>(output: Output) -> Result<Option<T>, String>
where
    T: for<'de> Deserialize<'de>,
{
    if output.status.success() {
        let raw = String::from_utf8_lossy(&output.stdout);
        if raw.is_empty() || raw.trim() == "[]" || raw.trim() == "{}" {
            return Ok(None);
        }
        serde_json_lenient::from_str(&raw)
            .map_err(|e| format!("Error deserializing from raw json: {e}"))
    } else {
        let std_err = String::from_utf8_lossy(&output.stderr);
        Err(format!(
            "Sent non-successful output; cannot deserialize. StdErr: {std_err}"
        ))
    }
}

#[cfg(test)]
mod tests {
    use std::process::ExitStatus;

    use super::*;

    fn success_output(stdout: &str) -> Output {
        Output {
            status: ExitStatus::default(),
            stdout: stdout.as_bytes().to_vec(),
            stderr: Vec::new(),
        }
    }

    #[derive(Debug, Deserialize, PartialEq)]
    struct TestItem {
        id: String,
    }

    #[test]
    fn test_deserialize_newline_delimited_json_rejected() {
        // Strict single-value contract: NDJSON must be rejected. Commands that
        // may legitimately return multiple rows (e.g. `docker ps`) parse their
        // output themselves rather than routing through this helper.
        let output = success_output("{\"id\":\"first\"}\n{\"id\":\"second\"}\n");
        let result: Result<Option<TestItem>, String> = deserialize_json_output(output);
        assert!(result.is_err(), "expected parse error, got {result:?}");
    }

    #[test]
    fn test_deserialize_empty_output() {
        let output = success_output("");
        let result: Option<TestItem> = deserialize_json_output(output).unwrap();
        assert_eq!(result, None);
    }

    #[test]
    fn test_deserialize_empty_object() {
        let output = success_output("{}");
        let result: Option<TestItem> = deserialize_json_output(output).unwrap();
        assert_eq!(result, None);
    }
}