mrapids 0.1.31

//! Unified output module for agent-friendly CLI responses
//!
//! This module provides consistent JSON output formatting for all mrapids commands,
//! making it easy for agents and automation tools to parse responses.

#![allow(dead_code)]

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::process;

/// Standard exit codes for mrapids CLI
pub mod exit_codes {
    pub const SUCCESS: i32 = 0;
    pub const GENERAL_ERROR: i32 = 1;
    pub const INVALID_ARGUMENTS: i32 = 2;
    pub const NETWORK_ERROR: i32 = 3;
    pub const AUTH_ERROR: i32 = 4;
    pub const VALIDATION_ERROR: i32 = 5;
    pub const NOT_FOUND: i32 = 6;
    pub const TIMEOUT: i32 = 7;
    pub const PARTIAL_SUCCESS: i32 = 10; // For batch operations
}

/// Environment variable names for mrapids configuration
pub mod env_vars {
    pub const DB_PATH: &str = "MRAPIDS_DB_PATH";
    pub const CONFIG_PATH: &str = "MRAPIDS_CONFIG_PATH";
    pub const SPEC_PATH: &str = "MRAPIDS_SPEC_PATH";
    pub const OUTPUT_FORMAT: &str = "MRAPIDS_OUTPUT";
    pub const AUTH_TOKEN: &str = "MRAPIDS_AUTH_TOKEN";
    pub const BASE_URL: &str = "MRAPIDS_BASE_URL";
    pub const LOG_LEVEL: &str = "MRAPIDS_LOG_LEVEL";
    pub const NO_COLOR: &str = "MRAPIDS_NO_COLOR";
    pub const MACHINE_MODE: &str = "MRAPIDS_MACHINE";
}

/// Unified response envelope for all CLI commands
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResponseEnvelope<T: Serialize> {
    /// Whether the command succeeded
    pub success: bool,

    /// The command that was executed
    pub command: String,

    /// The actual response data
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<T>,

    /// Metadata about the execution
    pub metadata: ResponseMetadata,

    /// Any errors that occurred
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub errors: Vec<ErrorDetail>,

    /// Any warnings
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub warnings: Vec<String>,
}

/// Metadata about the command execution
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResponseMetadata {
    /// Run ID (for run command)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,

    /// Request ID (for run command)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub request_id: Option<String>,

    /// Execution duration in milliseconds
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duration_ms: Option<f64>,

    /// CLI version
    pub version: String,

    /// Timestamp of execution
    pub timestamp: DateTime<Utc>,

    /// Exit code that will be used
    pub exit_code: i32,
}

/// Detailed error information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ErrorDetail {
    /// Error code (e.g., "NETWORK_ERROR", "AUTH_FAILED")
    pub code: String,

    /// Human-readable error message
    pub message: String,

    /// Additional context
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context: Option<String>,

    /// Suggested fix
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suggestion: Option<String>,
}

/// Response specifically for the run command
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RunResponse {
    /// The operation that was executed
    pub operation: String,

    /// HTTP method used
    pub method: String,

    /// Full URL that was called
    pub url: String,

    /// HTTP status code
    pub status_code: u16,

    /// Status text
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_text: Option<String>,

    /// Response headers
    #[serde(skip_serializing_if = "Option::is_none")]
    pub headers: Option<serde_json::Value>,

    /// Response body
    #[serde(skip_serializing_if = "Option::is_none")]
    pub body: Option<serde_json::Value>,

    /// Response body as raw string (if not JSON)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub body_raw: Option<String>,

    /// Response size in bytes
    #[serde(skip_serializing_if = "Option::is_none")]
    pub body_size_bytes: Option<usize>,

    /// Request details (for debugging)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub request: Option<RequestDetails>,
}

/// Request details for debugging
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RequestDetails {
    /// Request headers sent
    #[serde(skip_serializing_if = "Option::is_none")]
    pub headers: Option<serde_json::Value>,

    /// Query parameters
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query_params: Option<serde_json::Value>,

    /// Path parameters
    #[serde(skip_serializing_if = "Option::is_none")]
    pub path_params: Option<serde_json::Value>,

    /// Request body sent
    #[serde(skip_serializing_if = "Option::is_none")]
    pub body: Option<serde_json::Value>,
}

impl<T: Serialize> ResponseEnvelope<T> {
    /// Create a successful response
    pub fn success(command: &str, data: T) -> Self {
        Self {
            success: true,
            command: command.to_string(),
            data: Some(data),
            metadata: ResponseMetadata::new(exit_codes::SUCCESS),
            errors: vec![],
            warnings: vec![],
        }
    }

    /// Create a successful response with run metadata
    pub fn success_with_run(
        command: &str,
        data: T,
        run_id: String,
        request_id: Option<String>,
        duration_ms: f64,
    ) -> Self {
        let mut envelope = Self::success(command, data);
        envelope.metadata.run_id = Some(run_id);
        envelope.metadata.request_id = request_id;
        envelope.metadata.duration_ms = Some(duration_ms);
        envelope
    }

    /// Add a warning
    pub fn with_warning(mut self, warning: &str) -> Self {
        self.warnings.push(warning.to_string());
        self
    }

    /// Output as JSON and exit
    pub fn output_and_exit(self) -> ! {
        let exit_code = self.metadata.exit_code;
        println!(
            "{}",
            serde_json::to_string_pretty(&self).unwrap_or_else(|_| "{}".to_string())
        );
        process::exit(exit_code);
    }

    /// Output as JSON string
    pub fn to_json(&self) -> String {
        serde_json::to_string_pretty(self).unwrap_or_else(|_| "{}".to_string())
    }

    /// Output as compact JSON string (single line)
    pub fn to_json_compact(&self) -> String {
        serde_json::to_string(self).unwrap_or_else(|_| "{}".to_string())
    }
}

/// Create an error response (without generic data type)
pub fn error_response(
    command: &str,
    code: &str,
    message: &str,
    exit_code: i32,
) -> ResponseEnvelope<serde_json::Value> {
    ResponseEnvelope {
        success: false,
        command: command.to_string(),
        data: None,
        metadata: ResponseMetadata::new(exit_code),
        errors: vec![ErrorDetail {
            code: code.to_string(),
            message: message.to_string(),
            context: None,
            suggestion: None,
        }],
        warnings: vec![],
    }
}

/// Create an error response with suggestion
pub fn error_with_suggestion(
    command: &str,
    code: &str,
    message: &str,
    suggestion: &str,
    exit_code: i32,
) -> ResponseEnvelope<serde_json::Value> {
    ResponseEnvelope {
        success: false,
        command: command.to_string(),
        data: None,
        metadata: ResponseMetadata::new(exit_code),
        errors: vec![ErrorDetail {
            code: code.to_string(),
            message: message.to_string(),
            context: None,
            suggestion: Some(suggestion.to_string()),
        }],
        warnings: vec![],
    }
}

impl ResponseMetadata {
    pub fn new(exit_code: i32) -> Self {
        Self {
            run_id: None,
            request_id: None,
            duration_ms: None,
            version: env!("CARGO_PKG_VERSION").to_string(),
            timestamp: Utc::now(),
            exit_code,
        }
    }
}

impl ErrorDetail {
    pub fn new(code: &str, message: &str) -> Self {
        Self {
            code: code.to_string(),
            message: message.to_string(),
            context: None,
            suggestion: None,
        }
    }

    pub fn with_context(mut self, context: &str) -> Self {
        self.context = Some(context.to_string());
        self
    }

    pub fn with_suggestion(mut self, suggestion: &str) -> Self {
        self.suggestion = Some(suggestion.to_string());
        self
    }
}

/// Global output configuration
#[derive(Debug, Clone, Default)]
pub struct OutputConfig {
    /// Output as JSON
    pub json: bool,
    /// Machine mode (no colors, no decorations)
    pub machine: bool,
    /// Quiet mode (errors only)
    pub quiet: bool,
    /// Verbose mode
    pub verbose: bool,
    /// No color output
    pub no_color: bool,
}

impl OutputConfig {
    /// Load from environment variables
    pub fn from_env() -> Self {
        Self {
            json: std::env::var("MRAPIDS_JSON")
                .map(|v| v == "1" || v.to_lowercase() == "true")
                .unwrap_or(false)
                || std::env::var(env_vars::OUTPUT_FORMAT)
                    .map(|v| v.to_lowercase() == "json")
                    .unwrap_or(false),
            machine: std::env::var(env_vars::MACHINE_MODE)
                .map(|v| v == "1" || v.to_lowercase() == "true")
                .unwrap_or(false),
            quiet: std::env::var("MRAPIDS_QUIET")
                .map(|v| v == "1" || v.to_lowercase() == "true")
                .unwrap_or(false),
            verbose: std::env::var("MRAPIDS_VERBOSE")
                .map(|v| v == "1" || v.to_lowercase() == "true")
                .unwrap_or(false),
            no_color: std::env::var(env_vars::NO_COLOR)
                .map(|v| v == "1" || v.to_lowercase() == "true")
                .unwrap_or(false),
        }
    }

    /// Check if we should output decorations (banners, spinners)
    pub fn show_decorations(&self) -> bool {
        !self.machine && !self.json && !self.quiet
    }

    /// Check if colors should be used
    pub fn use_colors(&self) -> bool {
        !self.no_color && !self.machine && !self.json
    }
}

/// Check if JSON output mode is enabled globally
/// This checks environment variables set by main.rs from CLI args
pub fn is_json_mode() -> bool {
    std::env::var("MRAPIDS_JSON")
        .map(|v| v == "1" || v.to_lowercase() == "true")
        .unwrap_or(false)
        || std::env::var("MRAPIDS_OUTPUT")
            .map(|v| v.to_lowercase() == "json")
            .unwrap_or(false)
}

/// Check if machine mode is enabled globally
pub fn is_machine_mode() -> bool {
    std::env::var("MRAPIDS_MACHINE")
        .map(|v| v == "1" || v.to_lowercase() == "true")
        .unwrap_or(false)
}

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

    #[test]
    fn test_success_response() {
        let response = ResponseEnvelope::success("run", serde_json::json!({"status": "ok"}));
        assert!(response.success);
        assert_eq!(response.command, "run");
        assert_eq!(response.metadata.exit_code, exit_codes::SUCCESS);
    }

    #[test]
    fn test_error_response() {
        let response = error_response(
            "run",
            "NETWORK_ERROR",
            "Connection failed",
            exit_codes::NETWORK_ERROR,
        );
        assert!(!response.success);
        assert_eq!(response.errors.len(), 1);
        assert_eq!(response.errors[0].code, "NETWORK_ERROR");
        assert_eq!(response.metadata.exit_code, exit_codes::NETWORK_ERROR);
    }

    #[test]
    fn test_success_with_run() {
        let response = ResponseEnvelope::success_with_run(
            "run",
            serde_json::json!({"data": "test"}),
            "abc123".to_string(),
            Some("req_xyz".to_string()),
            150.5,
        );
        assert!(response.success);
        assert_eq!(response.metadata.run_id, Some("abc123".to_string()));
        assert_eq!(response.metadata.request_id, Some("req_xyz".to_string()));
        assert_eq!(response.metadata.duration_ms, Some(150.5));
    }

    #[test]
    fn test_json_serialization() {
        let response = ResponseEnvelope::success("test", serde_json::json!({"key": "value"}));
        let json = response.to_json();
        assert!(json.contains("\"success\": true"));
        assert!(json.contains("\"command\": \"test\""));
    }

    #[test]
    fn test_output_config_from_env() {
        // Default config
        let config = OutputConfig::default();
        assert!(!config.json);
        assert!(!config.machine);
        assert!(config.show_decorations());
    }

    #[test]
    fn test_exit_codes() {
        assert_eq!(exit_codes::SUCCESS, 0);
        assert_eq!(exit_codes::GENERAL_ERROR, 1);
        assert_eq!(exit_codes::NETWORK_ERROR, 3);
        assert_eq!(exit_codes::PARTIAL_SUCCESS, 10);
    }
}