oauth-db-cli 0.1.0

use crate::error::Result;
use colored::Colorize;
use comfy_table::{presets::UTF8_FULL, Cell, CellAlignment, ContentArrangement, Table};
use serde::Serialize;

#[derive(Debug, Clone, Copy)]
pub enum OutputFormat {
    Table,
    Json,
    Yaml,
}

impl OutputFormat {
    pub fn from_str(s: &str) -> Self {
        match s.to_lowercase().as_str() {
            "json" => Self::Json,
            "yaml" => Self::Yaml,
            _ => Self::Table,
        }
    }
}

pub fn print_success(message: &str) {
    println!("{} {}", "✓".green().bold(), message);
}

pub fn print_error(message: &str) {
    eprintln!("{} {}", "✗".red().bold(), message);
}

pub fn print_warning(message: &str) {
    println!("{} {}", "⚠".yellow().bold(), message);
}

pub fn print_info(message: &str) {
    println!("{} {}", "ℹ".blue().bold(), message);
}

pub fn format_output<T: Serialize>(data: &T, format: OutputFormat) -> Result<String> {
    match format {
        OutputFormat::Json => {
            let json = serde_json::to_string_pretty(data)?;
            Ok(json)
        }
        OutputFormat::Yaml => {
            let yaml = serde_yaml::to_string(data)?;
            Ok(yaml)
        }
        OutputFormat::Table => {
            // For table format, we'll need custom formatting per data type
            // This is a fallback to JSON
            let json = serde_json::to_string_pretty(data)?;
            Ok(json)
        }
    }
}

pub fn create_table_with_headers(headers: Vec<&str>) -> Table {
    let mut table = Table::new();
    table
        .load_preset(UTF8_FULL)
        .set_content_arrangement(ContentArrangement::Dynamic);

    let header_cells: Vec<Cell> = headers
        .into_iter()
        .map(|h| Cell::new(h).set_alignment(CellAlignment::Center))
        .collect();
    table.set_header(header_cells);

    table
}

pub fn create_table() -> Table {
    let mut table = Table::new();
    table
        .load_preset(UTF8_FULL)
        .set_content_arrangement(ContentArrangement::Dynamic);
    table
}

pub fn print_table(table: Table) {
    println!("{}", table);
}

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

    #[derive(Serialize)]
    struct TestData {
        name: String,
        value: i32,
    }

    #[test]
    fn test_format_json() {
        let data = TestData {
            name: "test".to_string(),
            value: 42,
        };
        let result = format_output(&data, OutputFormat::Json);
        assert!(result.is_ok());
        assert!(result.unwrap().contains("test"));
    }

    #[test]
    fn test_format_yaml() {
        let data = TestData {
            name: "test".to_string(),
            value: 42,
        };
        let result = format_output(&data, OutputFormat::Yaml);
        assert!(result.is_ok());
        assert!(result.unwrap().contains("test"));
    }
}