git_same/

banner.rs

//! ASCII banner for gisa — shared across CLI and TUI.

use console::style;

/// Banner lines 1-4 (shared between CLI and TUI).
const LINES: [&str; 4] = [
    " ██████╗ ██╗████████╗   ███████╗ █████╗ ███╗   ███╗███████╗",
    "██╔════╝ ██║╚══██╔══╝   ██╔════╝██╔══██╗████╗ ████║██╔════╝",
    "██║  ███╗██║   ██║█████╗███████╗███████║██╔████╔██║█████╗  ",
    "██║   ██║██║   ██║╚════╝╚════██║██╔══██║██║╚██╔╝██║██╔══╝  ",
];

/// Line 5 prefix (before version badge).
const LINE5_PREFIX: &str = "╚██████╔╝██║   ██║      ███████║██║  ██║██║ ╚═╝ ██║█";

/// Line 5 suffix (after version badge).
const LINE5_SUFFIX: &str = "╗";

/// Line 6.
const LAST_LINE: &str = " ╚═════╝ ╚═╝   ╚═╝      ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚══════╝";

/// Visual width of the ASCII logo (in monospace columns).
const ART_WIDTH: usize = 62;

/// Static gradient color stops: Blue → Cyan → Green.
const GRADIENT_STOPS: [(u8, u8, u8); 3] = [
    (59, 130, 246), // Blue
    (6, 182, 212),  // Cyan
    (34, 197, 94),  // Green
];

/// Animated gradient color stops: Blue → Cyan → Green → Indigo → Purple.
const ANIMATED_GRADIENT_STOPS: [(u8, u8, u8); 5] = [
    (59, 130, 246), // Blue
    (6, 182, 212),  // Cyan
    (34, 197, 94),  // Green
    (99, 102, 241), // Indigo
    (147, 51, 234), // Purple
];

/// Canonical subheadline used by CLI + Dashboard.
pub fn subheadline() -> &'static str {
    env!("CARGO_PKG_DESCRIPTION")
}

/// Prints the gisa ASCII art banner to stdout (CLI mode).
pub fn print_banner() {
    let version = env!("CARGO_PKG_VERSION");
    let version_display = format!("{:^6}", version);

    println!();
    for text in &LINES {
        println!("{}", cli_gradient_line(text, &GRADIENT_STOPS));
    }
    println!("{}", cli_line5(&version_display, &GRADIENT_STOPS));
    println!("{}", cli_gradient_line(LAST_LINE, &GRADIENT_STOPS));

    let subtitle = subheadline();
    let visible_len = subtitle.chars().count();
    let pad = if visible_len < ART_WIDTH {
        (ART_WIDTH - visible_len) / 2
    } else {
        0
    };
    println!(
        "{}{}\n",
        " ".repeat(pad.saturating_sub(1)),
        style(subtitle).dim()
    );
}

fn styled_gradient_chunk(text: &str, r: u8, g: u8, b: u8, force_styling: bool) -> String {
    let styled = style(text).true_color(r, g, b).bold();
    if force_styling {
        format!("{}", styled.force_styling(true))
    } else {
        format!("{}", styled)
    }
}

fn styled_version_badge(text: &str, r: u8, g: u8, b: u8, force_styling: bool) -> String {
    let styled = style(text).black().on_true_color(r, g, b).bold();
    if force_styling {
        format!("{}", styled.force_styling(true))
    } else {
        format!("{}", styled)
    }
}

fn cli_gradient_line(text: &str, stops: &[(u8, u8, u8)]) -> String {
    cli_gradient_line_with_force(text, stops, false)
}

fn cli_gradient_line_with_force(text: &str, stops: &[(u8, u8, u8)], force_styling: bool) -> String {
    let chars: Vec<char> = text.chars().collect();
    let len = chars.len().max(1);

    chars
        .into_iter()
        .enumerate()
        .map(|(i, ch)| {
            let t = i as f64 / (len - 1).max(1) as f64;
            let (r, g, b) = interpolate_stops(stops, t);
            styled_gradient_chunk(&ch.to_string(), r, g, b, force_styling)
        })
        .collect()
}

fn cli_line5(version_display: &str, stops: &[(u8, u8, u8)]) -> String {
    cli_line5_with_force(version_display, stops, false)
}

fn cli_line5_with_force(
    version_display: &str,
    stops: &[(u8, u8, u8)],
    force_styling: bool,
) -> String {
    let prefix_len = LINE5_PREFIX.chars().count();
    let version_len = version_display.chars().count();
    let full_len = prefix_len + version_len + LINE5_SUFFIX.chars().count();
    let denom = (full_len - 1).max(1) as f64;

    let mut out = String::new();
    for (i, ch) in LINE5_PREFIX.chars().enumerate() {
        let t = i as f64 / denom;
        let (r, g, b) = interpolate_stops(stops, t);
        out.push_str(&styled_gradient_chunk(
            &ch.to_string(),
            r,
            g,
            b,
            force_styling,
        ));
    }

    let ver_t = prefix_len as f64 / denom;
    let (vr, vg, vb) = interpolate_stops(stops, ver_t);
    out.push_str(&styled_version_badge(
        version_display,
        vr,
        vg,
        vb,
        force_styling,
    ));

    let suffix_pos = prefix_len + version_len;
    let suffix_t = suffix_pos as f64 / denom;
    let (r, g, b) = interpolate_stops(stops, suffix_t);
    out.push_str(&styled_gradient_chunk(LINE5_SUFFIX, r, g, b, force_styling));

    out
}

// ---------------------------------------------------------------------------
// TUI rendering (feature-gated)
// ---------------------------------------------------------------------------

#[cfg(feature = "tui")]
use ratatui::{
    layout::Rect,
    style::{Color, Modifier, Style},
    text::{Line, Span},
    widgets::Paragraph,
    Frame,
};

/// Linearly interpolate between RGB color stops.
pub(crate) fn interpolate_stops(stops: &[(u8, u8, u8)], t: f64) -> (u8, u8, u8) {
    let t = t.clamp(0.0, 1.0);
    let segments = stops.len() - 1;
    let scaled = t * segments as f64;
    let idx = (scaled as usize).min(segments - 1);
    let local_t = scaled - idx as f64;
    let (r1, g1, b1) = stops[idx];
    let (r2, g2, b2) = stops[idx + 1];
    let lerp = |a: u8, b: u8, t: f64| -> u8 { (a as f64 + (b as f64 - a as f64) * t) as u8 };
    (
        lerp(r1, r2, local_t),
        lerp(g1, g2, local_t),
        lerp(b1, b2, local_t),
    )
}

/// Apply a static gradient to a line of text.
#[cfg(feature = "tui")]
fn gradient_line<'a>(text: &'a str, stops: &[(u8, u8, u8)]) -> Line<'a> {
    let chars: Vec<&str> = text.split_inclusive(|_: char| true).collect();
    let len = chars.len().max(1);
    let spans: Vec<Span<'a>> = chars
        .into_iter()
        .enumerate()
        .map(|(i, ch)| {
            let t = i as f64 / (len - 1).max(1) as f64;
            let (r, g, b) = interpolate_stops(stops, t);
            Span::styled(
                ch.to_string(),
                Style::default()
                    .fg(Color::Rgb(r, g, b))
                    .add_modifier(Modifier::BOLD),
            )
        })
        .collect();
    Line::from(spans)
}

/// Compute the color for a character at normalized position `base_t`
/// during a left-to-right sweep animation at the given `phase`.
/// Returns the first stop color when the character is outside the wave.
#[cfg(feature = "tui")]
fn sweep_color(stops: &[(u8, u8, u8)], base_t: f64, phase: f64) -> (u8, u8, u8) {
    let wave_start = 2.0 * phase - 1.0;
    let wave_t = base_t - wave_start;
    if !(0.0..1.0).contains(&wave_t) {
        stops[0]
    } else {
        interpolate_stops(stops, wave_t)
    }
}

/// Apply an animated gradient sweep to a line of text (left-to-right wave).
/// `phase` in [0.0, 1.0] drives the sweep: 0.0 and 1.0 = all first-stop color,
/// 0.5 = full gradient visible.
#[cfg(feature = "tui")]
fn animated_gradient_line<'a>(text: &'a str, stops: &[(u8, u8, u8)], phase: f64) -> Line<'a> {
    let chars: Vec<&str> = text.split_inclusive(|_: char| true).collect();
    let len = chars.len().max(1);
    let spans: Vec<Span<'a>> = chars
        .into_iter()
        .enumerate()
        .map(|(i, ch)| {
            let base_t = i as f64 / (len - 1).max(1) as f64;
            let (r, g, b) = sweep_color(stops, base_t, phase);
            Span::styled(
                ch.to_string(),
                Style::default()
                    .fg(Color::Rgb(r, g, b))
                    .add_modifier(Modifier::BOLD),
            )
        })
        .collect();
    Line::from(spans)
}

/// Render the GIT-SAME banner with a static Blue → Cyan → Green gradient.
#[cfg(feature = "tui")]
pub fn render_banner(frame: &mut Frame, area: Rect) {
    let version = env!("CARGO_PKG_VERSION");
    let version_display = format!("{:^6}", version);
    let stops = &GRADIENT_STOPS;

    let mut banner_lines: Vec<Line> = Vec::new();
    for text in &LINES {
        banner_lines.push(gradient_line(text, stops));
    }

    // Line 5: gradient prefix + inverted version + gradient suffix
    let full_len =
        LINE5_PREFIX.chars().count() + version_display.len() + LINE5_SUFFIX.chars().count();
    let mut line5_spans: Vec<Span> = Vec::new();
    for (i, ch) in LINE5_PREFIX.split_inclusive(|_: char| true).enumerate() {
        let t = i as f64 / (full_len - 1).max(1) as f64;
        let (r, g, b) = interpolate_stops(stops, t);
        line5_spans.push(Span::styled(
            ch.to_string(),
            Style::default()
                .fg(Color::Rgb(r, g, b))
                .add_modifier(Modifier::BOLD),
        ));
    }
    let ver_pos = LINE5_PREFIX.chars().count();
    let ver_t = ver_pos as f64 / (full_len - 1).max(1) as f64;
    let (vr, vg, vb) = interpolate_stops(stops, ver_t);
    line5_spans.push(Span::styled(
        version_display,
        Style::default()
            .fg(Color::Black)
            .bg(Color::Rgb(vr, vg, vb))
            .add_modifier(Modifier::BOLD),
    ));
    let suffix_pos = ver_pos + 6;
    let t = suffix_pos as f64 / (full_len - 1).max(1) as f64;
    let (r, g, b) = interpolate_stops(stops, t);
    line5_spans.push(Span::styled(
        LINE5_SUFFIX.to_string(),
        Style::default()
            .fg(Color::Rgb(r, g, b))
            .add_modifier(Modifier::BOLD),
    ));
    banner_lines.push(Line::from(line5_spans));

    banner_lines.push(gradient_line(LAST_LINE, stops));

    let banner = Paragraph::new(banner_lines).centered();
    frame.render_widget(banner, area);
}

/// Render the GIT-SAME banner with animated gradient sweep (left-to-right wave).
/// `phase` in [0.0, 1.0] drives the sweep: 0.0 and 1.0 = all first-stop color,
/// 0.5 = full gradient visible.
#[cfg(feature = "tui")]
pub fn render_animated_banner(frame: &mut Frame, area: Rect, phase: f64) {
    let version = env!("CARGO_PKG_VERSION");
    let version_display = format!("{:^6}", version);
    let stops: &[(u8, u8, u8)] = &ANIMATED_GRADIENT_STOPS;

    let mut banner_lines: Vec<Line> = Vec::new();
    for text in &LINES {
        banner_lines.push(animated_gradient_line(text, stops, phase));
    }

    // Line 5: sweep prefix + inverted version badge + sweep suffix
    let full_len =
        LINE5_PREFIX.chars().count() + version_display.len() + LINE5_SUFFIX.chars().count();
    let mut line5_spans: Vec<Span> = Vec::new();
    for (i, ch) in LINE5_PREFIX.split_inclusive(|_: char| true).enumerate() {
        let base_t = i as f64 / (full_len - 1).max(1) as f64;
        let (r, g, b) = sweep_color(stops, base_t, phase);
        line5_spans.push(Span::styled(
            ch.to_string(),
            Style::default()
                .fg(Color::Rgb(r, g, b))
                .add_modifier(Modifier::BOLD),
        ));
    }
    let ver_pos = LINE5_PREFIX.chars().count();
    let ver_base_t = ver_pos as f64 / (full_len - 1).max(1) as f64;
    let (vr, vg, vb) = sweep_color(stops, ver_base_t, phase);
    line5_spans.push(Span::styled(
        version_display,
        Style::default()
            .fg(Color::Black)
            .bg(Color::Rgb(vr, vg, vb))
            .add_modifier(Modifier::BOLD),
    ));
    let suffix_pos = ver_pos + 6;
    let suffix_base_t = suffix_pos as f64 / (full_len - 1).max(1) as f64;
    let (r, g, b) = sweep_color(stops, suffix_base_t, phase);
    line5_spans.push(Span::styled(
        LINE5_SUFFIX.to_string(),
        Style::default()
            .fg(Color::Rgb(r, g, b))
            .add_modifier(Modifier::BOLD),
    ));
    banner_lines.push(Line::from(line5_spans));

    banner_lines.push(animated_gradient_line(LAST_LINE, stops, phase));

    let banner = Paragraph::new(banner_lines).centered();
    frame.render_widget(banner, area);
}

#[cfg(test)]
#[path = "banner_tests.rs"]
mod tests;