fundaia 0.30.1

use serde::Serialize;

use crate::api::client::ApiError;
use crate::exit::classify;

/// How the answer leaves the process: drawn for a person, or serialised for a
/// program.
///
/// One switch rather than a flag per command, because the reader is a property
/// of the invocation, not of the question — an AI agent asking `status` and an
/// agent asking `history` want the same shape, and a person wants neither.
///
/// JSON is compact, one value per line. A pretty-printed object is for a
/// person, and a person asked for the table; what a machine pays for is every
/// byte it has to read back, so the machine gets the short form.
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum Format {
    Human,
    Json,
}

impl Format {
    pub fn is_json(self) -> bool {
        matches!(self, Format::Json)
    }
}

/// The flag, or the environment, in that order.
///
/// `FUNDAIA_JSON=1` exists for the same reason `FUNDAIA_TOKEN` does: an agent
/// is configured once with environment variables and then types plain
/// commands, and threading `--json` into every invocation is ceremony it will
/// eventually forget somewhere.
pub fn chosen(flag: bool) -> Format {
    if flag || wants_json() {
        Format::Json
    } else {
        Format::Human
    }
}

fn wants_json() -> bool {
    std::env::var("FUNDAIA_JSON").is_ok_and(|value| truthy(&value))
}

/// `=1` turns it on; `=0` and an empty value do not — the same reading every
/// other switch in this tool gives the environment.
fn truthy(value: &str) -> bool {
    let value = value.trim();
    !value.is_empty() && value != "0"
}

/// One value, one line, on stdout.
pub fn emit<T: Serialize>(value: &T) {
    println!(
        "{}",
        serde_json::to_string(value).expect("the DTOs serialise to JSON by construction")
    );
}

/// A failure as one JSON object on stderr, mirroring the human error block.
///
/// `code` is the server's own error code when there is one, so an agent can
/// branch on `unauthorized` or `conflict` without parsing a sentence written
/// for a person — the same reason `hint` keys on it.
///
/// `exit` and `retryable` are here so the object and the exit code cannot tell
/// different stories about the same failure: the process is about to stop with
/// that number, and an agent that read the JSON should not have to also consult
/// `$?` to learn whether repeating the call is worth anything.
pub fn emit_error(error: &anyhow::Error, hint: Option<&str>) {
    eprintln!("{}", described(error, hint));
}

/// The object, without printing it.
///
/// Split for the reason `Table::rendered` is split from `print`: what is worth
/// asserting is the shape an agent reads, and a test that had to capture stderr
/// to see it would be a test about plumbing.
fn described(error: &anyhow::Error, hint: Option<&str>) -> serde_json::Value {
    let mut body = serde_json::Map::new();
    body.insert("message".into(), error.to_string().into());

    let exit = classify(error);
    body.insert("exit".into(), exit.code().into());
    body.insert("retryable".into(), exit.retryable().into());

    match error.downcast_ref::<ApiError>() {
        Some(api) => {
            body.insert("code".into(), api.code.clone().into());
            body.insert("status".into(), api.status.as_u16().into());
        }
        // No server answered — a failed deployment, an unreachable host, a bug
        // here — so the class names itself. `unreachable` and
        // `deployment_failed` rather than one `cli_error` covering both: the
        // word and the number then always agree, and every value this field can
        // take is one `fundaia schema` publishes.
        None => {
            body.insert("code".into(), exit.name().into());
        }
    }

    let causes: Vec<String> = error
        .chain()
        .skip(1)
        .map(|cause| cause.to_string())
        .collect();
    if !causes.is_empty() {
        body.insert("causes".into(), causes.into());
    }
    if let Some(hint) = hint {
        body.insert("hint".into(), hint.into());
    }

    serde_json::Value::Object(serde_json::Map::from_iter([(
        "error".to_string(),
        serde_json::Value::Object(body),
    )]))
}

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

    #[test]
    fn it_should_answer_json_when_the_flag_is_given() {
        assert!(chosen(true).is_json());
    }

    #[test]
    fn it_should_be_turned_on_by_a_one() {
        assert!(truthy("1"));
    }

    #[test]
    fn it_should_not_be_turned_on_by_a_zero() {
        assert!(!truthy("0"));
    }

    #[test]
    fn it_should_not_be_turned_on_by_an_empty_value() {
        assert!(!truthy(""));
    }

    fn refused() -> anyhow::Error {
        ApiError {
            status: reqwest::StatusCode::CONFLICT,
            code: "conflict".to_owned(),
            message: "there is a deployment running".to_owned(),
        }
        .into()
    }

    #[test]
    fn it_should_carry_the_server_s_own_code() {
        assert_eq!(described(&refused(), None)["error"]["code"], "conflict");
    }

    /// The number the process is about to leave, in the object, so a caller
    /// that read one does not have to consult the other.
    #[test]
    fn it_should_carry_the_exit_code_the_process_will_leave() {
        assert_eq!(described(&refused(), None)["error"]["exit"], 7);
    }

    #[test]
    fn it_should_say_whether_repeating_the_call_is_worth_anything() {
        assert_eq!(described(&refused(), None)["error"]["retryable"], false);
    }

    /// With no server to ask, the class names itself: every value this field
    /// takes is one `fundaia schema` publishes, and `cli_error` was not.
    #[test]
    fn it_should_name_the_class_when_no_server_answered() {
        let failed: anyhow::Error = crate::exit::DeploymentFailed("exit 137".to_owned()).into();
        assert_eq!(
            described(&failed, None)["error"]["code"],
            "deployment_failed"
        );
    }

    #[test]
    fn it_should_leave_the_hint_out_when_there_is_nothing_to_advise() {
        assert!(described(&anyhow::anyhow!("a bug"), None)["error"]
            .get("hint")
            .is_none());
    }
}