molten-herald 0.1.0

//! Pretty terminal UI using Molten's full TUI stack
//!
//! This module showcases all of Molten's TUI libraries:
//! - `glyphs` - ANSI styling and gradients
//! - `lacquer` - Style definitions and layouts
//! - `scoria` - TUI components (spinners, progress, tables)
//! - `aglow` - Markdown rendering
//! - `censer` - Beautiful logging
//! - `molten_brand` - Brand colors and design tokens

use glyphs::{style, gradient, Color};
use scoria::{Spinner, SpinnerStyle, Progress, ProgressStyle};
use std::io::{stdout, Write};

// Re-export glyphs color for scoria compatibility
use glyphs::Color as GlyphsColor;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::thread;
use std::time::Duration;

/// Convert molten_brand::Color to glyphs::Color  
pub fn brand_color(color: molten_brand::Color) -> Color {
    let rgb = color.to_rgb();
    Color::Rgb { r: rgb.r, g: rgb.g, b: rgb.b }
}

/// Beautiful color palette using Molten brand colors (from molten_brand crate)
pub mod colors {
    use glyphs::Color;
    
    // ═══════════════════════════════════════════════════════════════════════════
    // FORGE BRAND COLORS - from molten_brand::colors::forge
    // ═══════════════════════════════════════════════════════════════════════════
    
    /// Molten Orange - primary brand color (molten_brand::colors::forge::MOLTEN)
    pub const MOLTEN: Color = Color::Rgb { r: 249, g: 115, b: 22 };
    
    /// Forge Black - deep background (molten_brand::colors::forge::BLACK)
    pub const FORGE: Color = Color::Rgb { r: 10, g: 10, b: 10 };
    
    /// Steel Gray - secondary elements (molten_brand::colors::forge::STEEL)
    pub const STEEL: Color = Color::Rgb { r: 113, g: 113, b: 122 };
    
    /// Iron Blue - links and interactive (molten_brand::colors::forge::IRON)
    pub const IRON: Color = Color::Rgb { r: 59, g: 130, b: 246 };
    
    /// Ember Red - alerts and destructive (molten_brand::colors::forge::EMBER)
    pub const EMBER: Color = Color::Rgb { r: 239, g: 68, b: 68 };

    // ═══════════════════════════════════════════════════════════════════════════
    // PRODUCT COLORS - from molten_brand::products
    // ═══════════════════════════════════════════════════════════════════════════
    
    /// Lair/Goblin Purple - terminal product (molten_brand::products::lair::PRIMARY)
    pub const GOBLIN: Color = Color::Rgb { r: 124, g: 58, b: 237 };
    
    /// Hearth Blue - content product (molten_brand::products::hearth::PRIMARY)
    pub const HEARTH: Color = Color::Rgb { r: 59, g: 130, b: 246 };
    
    /// Alloy Orange - design system (molten_brand::products::alloy::PRIMARY)
    pub const ALLOY: Color = Color::Rgb { r: 249, g: 115, b: 22 };

    // ═══════════════════════════════════════════════════════════════════════════
    // SEMANTIC COLORS - from molten_brand::semantic
    // ═══════════════════════════════════════════════════════════════════════════
    
    /// Success green (molten_brand::semantic::SUCCESS)
    pub const SUCCESS: Color = Color::Rgb { r: 16, g: 185, b: 129 };
    pub const GREEN: Color = SUCCESS;
    
    /// Warning amber (molten_brand::semantic::WARNING)
    pub const WARNING: Color = Color::Rgb { r: 245, g: 158, b: 11 };
    pub const YELLOW: Color = WARNING;
    
    /// Error red (molten_brand::semantic::ERROR)
    pub const ERROR: Color = Color::Rgb { r: 239, g: 68, b: 68 };
    pub const RED: Color = ERROR;
    
    /// Info blue (molten_brand::semantic::INFO)
    pub const INFO: Color = Color::Rgb { r: 59, g: 130, b: 246 };
    
    /// Cyan accent (molten_brand::semantic::agent::COMPLETE)
    pub const CYAN: Color = Color::Rgb { r: 6, g: 182, b: 212 };

    // ═══════════════════════════════════════════════════════════════════════════
    // GRADIENT & ACCENT COLORS
    // ═══════════════════════════════════════════════════════════════════════════
    
    /// Pink accent (for gradients)
    pub const PINK: Color = Color::Rgb { r: 255, g: 135, b: 175 };
    
    /// Purple accent (molten_brand::semantic::agent::PAUSED)
    pub const PURPLE: Color = Color::Rgb { r: 167, g: 139, b: 250 };
    
    /// Violet (mid gradient)
    pub const VIOLET: Color = Color::Rgb { r: 147, g: 112, b: 219 };
    
    /// Blue accent
    pub const BLUE: Color = Color::Rgb { r: 135, g: 175, b: 255 };

    // ═══════════════════════════════════════════════════════════════════════════
    // TEXT & NEUTRAL COLORS - from molten_brand::colors::text/neutral
    // ═══════════════════════════════════════════════════════════════════════════
    
    /// Primary text - near white (molten_brand::colors::text::PRIMARY)
    pub const WHITE: Color = Color::Rgb { r: 250, g: 250, b: 250 };
    
    /// Secondary text (molten_brand::colors::text::SECONDARY)
    pub const MUTED: Color = Color::Rgb { r: 161, g: 161, b: 170 };
    
    /// Dim/muted text (molten_brand::colors::text::MUTED)
    pub const DIM: Color = Color::Rgb { r: 113, g: 113, b: 122 };
    
    /// Border color (molten_brand::colors::neutral::SCALE_700)
    pub const BORDER: Color = Color::Rgb { r: 63, g: 63, b: 70 };
    
    /// Raised surface (molten_brand::colors::surface::RAISED)
    pub const SURFACE: Color = Color::Rgb { r: 24, g: 24, b: 27 };
}

/// Print the herald banner with gradient
pub fn banner() {
    println!();
    
    // ASCII art with gradient
    let lines = [
        "  ██╗  ██╗███████╗██████╗  █████╗ ██╗     ██████╗ ",
        "  ██║  ██║██╔════╝██╔══██╗██╔══██╗██║     ██╔══██╗",
        "  ███████║█████╗  ██████╔╝███████║██║     ██║  ██║",
        "  ██╔══██║██╔══╝  ██╔══██╗██╔══██║██║     ██║  ██║",
        "  ██║  ██║███████╗██║  ██║██║  ██║███████╗██████╔╝",
        "  ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝╚═════╝ ",
    ];
    
    for (i, line) in lines.iter().enumerate() {
        // Gradient from pink to purple across lines
        let t = i as f32 / (lines.len() - 1) as f32;
        let r = (255.0 - t * 43.0) as u8;  // 255 -> 212
        let g = (135.0 - t * 43.0) as u8;  // 135 -> 92
        let b = (175.0 + t * 60.0) as u8;  // 175 -> 235
        println!("{}", style(*line).fg(Color::Rgb { r, g, b }).bold());
    }
    
    println!();
    println!(
        "  {}",
        gradient("📢 Viral tweets for developers who ship", colors::PINK, colors::PURPLE)
    );
    println!();
}

/// Print a success message with style
pub fn success(msg: &str) {
    println!(
        " {} {}",
        style("✓").fg(colors::GREEN).bold(),
        style(msg).fg(colors::WHITE)
    );
}

/// Print an error message with style
pub fn error(msg: &str) {
    eprintln!(
        " {} {}",
        style("✗").fg(colors::RED).bold(),
        style(msg).fg(colors::WHITE)
    );
}

/// Print a warning message with style
pub fn warning(msg: &str) {
    println!(
        " {} {}",
        style("⚠").fg(colors::YELLOW).bold(),
        style(msg).fg(colors::MUTED)
    );
}

/// Print an info message with style
pub fn info(msg: &str) {
    println!(
        " {} {}",
        style("ℹ").fg(colors::CYAN).bold(),
        style(msg).fg(colors::MUTED)
    );
}

/// Print a step in a process
pub fn step(num: usize, msg: &str) {
    let bullet = match num {
        1 => "❶",
        2 => "❷",
        3 => "❸",
        4 => "❹",
        5 => "❺",
        _ => "●",
    };
    println!(
        " {} {}",
        style(bullet).fg(colors::PURPLE).bold(),
        style(msg).fg(colors::WHITE)
    );
}

/// Print a header with gradient
pub fn header(msg: &str) {
    println!();
    println!(" {}", gradient(msg, colors::PINK, colors::PURPLE));
    println!(" {}", style("─".repeat(msg.len().min(50))).fg(colors::BORDER));
}

/// Print a subheader with style
pub fn subheader(msg: &str) {
    println!(
        " {} {}",
        style("▸").fg(colors::PINK).bold(),
        style(msg).fg(colors::VIOLET)
    );
}

/// Print a tweet preview in a beautiful box
pub fn tweet_preview(content: &str, chars: usize) {
    let width = 54;
    let top = format!("╭{}╮", "─".repeat(width));
    let bottom = format!("╰{}╯", "─".repeat(width));
    let divider = format!("├{}┤", "─".repeat(width));
    
    println!();
    println!(" {}", style(&top).fg(colors::BORDER));
    println!(" {} {} {}", 
        style("│").fg(colors::BORDER),
        style(format!("{:^width$}", "🐦 Tweet Preview")).fg(colors::PURPLE),
        style("│").fg(colors::BORDER)
    );
    println!(" {}", style(&divider).fg(colors::BORDER));
    
    // Word wrap the content
    for line in word_wrap(content, width - 2) {
        println!(" {} {} {}", 
            style("│").fg(colors::BORDER),
            style(format!("{:<width$}", line, width = width - 2)).fg(colors::WHITE),
            style("│").fg(colors::BORDER)
        );
    }
    
    println!(" {}", style(&divider).fg(colors::BORDER));
    
    let char_display = format!("{} characters", chars);
    let status = if chars <= 280 { 
        format!("✓ {}", char_display)
    } else { 
        format!("✗ {} (over limit!)", char_display)
    };
    let status_color = if chars <= 280 { colors::GREEN } else { colors::RED };
    
    println!(" {} {} {}", 
        style("│").fg(colors::BORDER),
        style(format!("{:^width$}", status, width = width - 2)).fg(status_color),
        style("│").fg(colors::BORDER)
    );
    println!(" {}", style(&bottom).fg(colors::BORDER));
    println!();
}

/// Simple word wrap helper
fn word_wrap(text: &str, max_width: usize) -> Vec<String> {
    let mut lines = Vec::new();
    let mut current_line = String::new();
    
    for word in text.split_whitespace() {
        if current_line.is_empty() {
            current_line = word.to_string();
        } else if current_line.len() + 1 + word.len() <= max_width {
            current_line.push(' ');
            current_line.push_str(word);
        } else {
            lines.push(current_line);
            current_line = word.to_string();
        }
    }
    
    if !current_line.is_empty() {
        lines.push(current_line);
    }
    
    if lines.is_empty() {
        lines.push(String::new());
    }
    
    lines
}

/// Print a key-value pair with style
pub fn kv(key: &str, value: &str) {
    println!(
        "   {} {}",
        style(format!("{}:", key)).fg(colors::MUTED),
        style(value).fg(colors::WHITE)
    );
}

/// Print a list item with style
pub fn list_item(bullet: &str, text: &str) {
    println!(
        "   {} {}",
        style(bullet).fg(colors::PINK),
        style(text).fg(colors::WHITE)
    );
}

/// Print a table of scheduled tweets
pub fn scheduled_tweets_table(tweets: &[(String, String, String, String)]) {
    if tweets.is_empty() {
        println!();
        println!(" {} {}", 
            style("📭").fg(colors::MUTED),
            style("No scheduled tweets").fg(colors::MUTED).dim()
        );
        println!();
        return;
    }

    header("📅 Scheduled Tweets");
    println!();
    
    // Table with nice borders
    let col_id = 8;
    let col_time = 18;
    let col_status = 10;
    let col_content = 35;
    let total_width = col_id + col_time + col_status + col_content + 10;
    
    // Header
    println!(
        " {} {} {} {} {} {} {} {}",
        style("│").fg(colors::BORDER),
        style(format!("{:<col_id$}", "ID")).fg(colors::PURPLE).bold(),
        style("│").fg(colors::BORDER),
        style(format!("{:<col_time$}", "Time")).fg(colors::PURPLE).bold(),
        style("│").fg(colors::BORDER),
        style(format!("{:<col_status$}", "Status")).fg(colors::PURPLE).bold(),
        style("│").fg(colors::BORDER),
        style(format!("{:<col_content$}", "Content")).fg(colors::PURPLE).bold(),
    );
    println!(" {}", style("─".repeat(total_width)).fg(colors::BORDER));

    for (id, time, status, content) in tweets {
        let short_id: String = id.chars().take(col_id).collect();
        let short_content: String = content.chars().take(col_content - 2).collect();
        
        let (status_icon, status_color) = match status.as_str() {
            "Pending" => ("⏳", colors::CYAN),
            "Posted" => ("✓", colors::GREEN),
            "Failed" => ("✗", colors::RED),
            _ => ("○", colors::DIM),
        };
        
        println!(
            " {} {} {} {} {} {} {} {}",
            style("│").fg(colors::BORDER),
            style(format!("{:<col_id$}", short_id)).fg(colors::MUTED),
            style("│").fg(colors::BORDER),
            style(format!("{:<col_time$}", time)).fg(colors::WHITE),
            style("│").fg(colors::BORDER),
            style(format!("{} {:<w$}", status_icon, status, w = col_status - 2)).fg(status_color),
            style("│").fg(colors::BORDER),
            style(format!("{:<col_content$}", short_content)).fg(colors::WHITE),
        );
    }
    println!();
}

/// Print queue statistics in a nice box
pub fn queue_stats(pending: usize, posted: usize, failed: usize, cancelled: usize) {
    header("📊 Queue Statistics");
    println!();
    
    let total = pending + posted + failed + cancelled;
    
    // Stats in a row with visual bars
    let bar_width = 20;
    
    fn stat_bar(label: &str, icon: &str, count: usize, total: usize, color: Color, bar_width: usize) {
        let pct = if total > 0 { (count as f32 / total as f32 * bar_width as f32) as usize } else { 0 };
        let filled = "█".repeat(pct);
        let empty = "░".repeat(bar_width - pct);
        
        println!(
            "   {} {} {} {}{}",
            style(icon).fg(color),
            style(format!("{:<12}", label)).fg(colors::MUTED),
            style(format!("{:>3}", count)).fg(color).bold(),
            style(&filled).fg(color),
            style(&empty).fg(colors::BORDER)
        );
    }
    
    stat_bar("Pending", "◐", pending, total, colors::CYAN, bar_width);
    stat_bar("Posted", "●", posted, total, colors::GREEN, bar_width);
    stat_bar("Failed", "○", failed, total, colors::RED, bar_width);
    stat_bar("Cancelled", "◌", cancelled, total, colors::MUTED, bar_width);
    
    println!();
    println!(
        "   {} {}",
        style("Total:").fg(colors::MUTED),
        style(total.to_string()).fg(colors::WHITE).bold()
    );
    println!();
}

/// Print a prompt for user confirmation
pub fn confirm_prompt(msg: &str) -> bool {
    print!(
        " {} {} ",
        style("?").fg(colors::PURPLE).bold(),
        style(msg).fg(colors::WHITE)
    );
    print!("{}", style("[y/N] ").fg(colors::MUTED));
    stdout().flush().ok();

    let mut input = String::new();
    std::io::stdin().read_line(&mut input).ok();
    input.trim().eq_ignore_ascii_case("y")
}

/// Show a colorful spinner while doing work (using scoria::Spinner)
pub fn with_spinner<F, T>(title: &str, f: F) -> T
where
    F: FnOnce() -> T,
{
    let running = Arc::new(AtomicBool::new(true));
    let running_clone = running.clone();
    let title_owned = title.to_string();

    // Use scoria's Spinner with dots style
    let spinner_thread = thread::spawn(move || {
        let mut spinner = Spinner::new(SpinnerStyle::Dots)
            .title(&title_owned)
            .color(GlyphsColor::Rgb { r: 212, g: 92, b: 235 }); // PURPLE
        let mut stdout = stdout();

        while running_clone.load(Ordering::Relaxed) {
            spinner.tick();
            print!("\r {}", spinner.view());
            stdout.flush().ok();
            thread::sleep(Duration::from_millis(80));
        }

        // Clear spinner line
        print!("\r{}\r", " ".repeat(title_owned.len() + 10));
        stdout.flush().ok();
    });

    // Run the actual work
    let result = f();

    // Stop spinner
    running.store(false, Ordering::Relaxed);
    spinner_thread.join().ok();

    result
}

/// Show a colorful spinner for async work (using scoria::Spinner)
pub async fn with_spinner_async<F, T>(title: &str, f: F) -> T
where
    F: std::future::Future<Output = T>,
{
    let running = Arc::new(AtomicBool::new(true));
    let running_clone = running.clone();
    let title_owned = title.to_string();

    // Use scoria's Spinner
    let spinner_thread = thread::spawn(move || {
        let mut spinner = Spinner::new(SpinnerStyle::Dots)
            .title(&title_owned)
            .color(GlyphsColor::Rgb { r: 212, g: 92, b: 235 }); // PURPLE
        let mut stdout = stdout();

        while running_clone.load(Ordering::Relaxed) {
            spinner.tick();
            print!("\r {}", spinner.view());
            stdout.flush().ok();
            thread::sleep(Duration::from_millis(80));
        }

        // Clear spinner line
        print!("\r{}\r", " ".repeat(title_owned.len() + 10));
        stdout.flush().ok();
    });

    // Run the actual work
    let result = f.await;

    // Stop spinner
    running.store(false, Ordering::Relaxed);
    spinner_thread.join().ok();

    result
}

/// Show a progress bar (using scoria::Progress)
pub fn progress_bar(current: usize, total: usize, label: &str) {
    let pct = if total > 0 { current as f64 / total as f64 } else { 0.0 };
    let progress = Progress::new()
        .progress(pct)
        .style(ProgressStyle::BLOCK.filled_color(GlyphsColor::Rgb { r: 212, g: 92, b: 235 }))
        .width(40);
    
    println!(
        " {} {} {}",
        style(label).fg(colors::MUTED),
        progress.view(),
        style(format!("{}/{}", current, total)).fg(colors::DIM)
    );
}

/// Print a generated tweet with formatting
pub fn generated_tweet(content: &str, chars: usize, event_type: Option<&str>) {
    if let Some(evt) = event_type {
        println!();
        println!(
            "   {} {}",
            style("Event:").fg(colors::MUTED),
            style(evt).fg(colors::PURPLE).bold()
        );
    }
    
    tweet_preview(content, chars);
}

/// Print template options with nice formatting
pub fn template_help() {
    header("🎨 Available Templates");
    println!();
    
    let templates = [
        ("📦", "crate-release", "<name> <version> <tagline>", "Announce a new crate version"),
        ("🌟", "open-source", "<name> <description> <url>", "Share an open source project"),
        ("✨", "feature", "<name> <feature> <benefit>", "Highlight a new feature"),
        ("🎉", "milestone", "<name> <metric> <value>", "Celebrate a milestone"),
    ];
    
    for (icon, name, args, desc) in templates {
        println!(
            "   {} {} {}",
            style(icon).fg(colors::WHITE),
            style(name).fg(colors::PINK).bold(),
            style(args).fg(colors::MUTED)
        );
        println!(
            "      {}",
            style(desc).fg(colors::MUTED).dim()
        );
        println!();
    }
    
    println!(
        " {} {}",
        style("💡").fg(colors::YELLOW),
        style("Tip: Pipe to pbcopy (macOS) or xclip (Linux) to copy").fg(colors::MUTED)
    );
}

/// Print config initialization success
pub fn config_created(path: &str) {
    println!();
    println!(
        " {} {}",
        style("🎉").fg(colors::GREEN),
        gradient("Configuration created!", colors::GREEN, colors::CYAN)
    );
    println!();
    
    // Show location in a box
    let width = path.len() + 4;
    println!(" {}", style(format!("╭{}╮", "─".repeat(width))).fg(colors::BORDER));
    println!(" {} {} {}", 
        style("│").fg(colors::BORDER),
        style(format!(" {} ", path)).fg(colors::WHITE),
        style("│").fg(colors::BORDER)
    );
    println!(" {}", style(format!("╰{}╯", "─".repeat(width))).fg(colors::BORDER));
    println!();
    
    subheader("Next Steps");
    println!();
    step(1, "Add your Twitter API credentials");
    step(2, "Add your LLM API key (Anthropic/OpenAI)");
    step(3, "Configure projects to monitor");
    println!();
    
    println!(
        "   {} {} {}",
        style("Run").fg(colors::MUTED),
        style("herald i").fg(colors::PINK).bold(),
        style("to get started interactively!").fg(colors::MUTED)
    );
    println!();
}

/// Print posted tweet success
pub fn tweet_posted(url: &str) {
    println!();
    println!(
        " {} {}",
        style("🎉").fg(colors::GREEN),
        gradient("Tweet posted!", colors::GREEN, colors::CYAN)
    );
    println!();
    println!(
        "   {} {}",
        style("🔗").fg(colors::CYAN),
        style(url).fg(colors::CYAN).underline()
    );
    println!();
}

/// Print thread posted success
pub fn thread_posted(urls: &[String]) {
    println!();
    println!(
        " {} {}",
        style("🎉").fg(colors::GREEN),
        gradient(&format!("Thread posted! ({} tweets)", urls.len()), colors::GREEN, colors::CYAN)
    );
    println!();
    for (i, url) in urls.iter().enumerate() {
        println!(
            "   {} {}",
            style(format!("{}.", i + 1)).fg(colors::MUTED),
            style(url).fg(colors::CYAN).underline()
        );
    }
    println!();
}

/// Print a divider line
pub fn divider() {
    println!(" {}", style("─".repeat(50)).fg(colors::BORDER));
}

/// Print a welcome message for interactive mode
pub fn welcome() {
    banner();
    println!(
        " {}",
        style("Welcome! What would you like to do?").fg(colors::MUTED)
    );
    println!();
}

/// Render markdown content beautifully (using aglow)
pub fn render_markdown(content: &str) {
    let rendered = aglow::render(content);
    for line in rendered.lines() {
        println!(" {}", line);
    }
}

/// Show a demo of all Molten TUI libraries
pub fn demo() {
    banner();
    
    header("🔥 Molten TUI Stack Demo");
    
    // glyphs - styling
    println!();
    subheader("glyphs - ANSI Styling");
    println!("   {}", style("Bold text").bold());
    println!("   {}", style("Italic text").italic());
    println!("   {}", style("Underlined").underline());
    println!("   {}", gradient("Gradient text from pink to purple!", colors::PINK, colors::PURPLE));
    
    // scoria - components
    println!();
    subheader("scoria - TUI Components");
    let spinner = Spinner::new(SpinnerStyle::Dots).title("Loading...");
    println!("   Spinner: {}", spinner.view());
    let progress = Progress::new()
        .progress(0.75)
        .style(ProgressStyle::BLOCK.filled_color(GlyphsColor::Rgb { r: 212, g: 92, b: 235 }))
        .width(30);
    println!("   Progress: {} 75%", progress.view());
    
    // aglow - markdown
    println!();
    subheader("aglow - Markdown Rendering");
    let md = "**Bold**, *italic*, and `code`";
    println!("   {}", aglow::render(md).trim());
    
    // molten_brand - colors
    println!();
    subheader("molten_brand - Brand Colors");
    println!(
        "   {} {} {}",
        style("■ Molten").fg(colors::MOLTEN),
        style("■ Goblin").fg(colors::GOBLIN),
        style("■ Iron").fg(colors::IRON)
    );
    
    println!();
    success("All Molten libraries working!");
    println!();
}

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

    #[test]
    fn test_colors_defined() {
        let _ = colors::ORANGE;
        let _ = colors::CYAN;
        let _ = colors::GREEN;
    }

    #[test]
    fn test_spinner_frames() {
        assert!(!SPINNER_FRAMES.is_empty());
    }
    
    #[test]
    fn test_word_wrap() {
        let lines = word_wrap("hello world this is a test", 10);
        assert!(!lines.is_empty());
    }
}