pcal/

display.rs

//! Colored terminal output for the calendar.
//!
//! Renders month grids with ANSI colors: today is highlighted with reverse
//! video, titles are bold. Respects `--no-color` and the `NO_COLOR` env
//! variable. In Persian mode, lines are wrapped with Unicode LTR embedding
//! characters to prevent BiDi reordering.

use std::fmt::Write as _;

use colored::Colorize;

use crate::calendar::MonthGrid;
use crate::persian::{
    self, MONTH_NAMES, MONTH_NAMES_ROMANIZED, WEEKDAY_NAMES_EN, WEEKDAY_NAMES_FA,
};

/// LTR embedding character — forces entire line to render left-to-right
const LRE: &str = "\u{202a}";
/// Pop directional formatting — ends the LRE scope
const PDF: &str = "\u{202c}";

/// Width of a single month block: 7 columns × 3 chars - 1 = 20.
const MONTH_WIDTH: usize = 20;
/// Width of a single month block in Julian mode: 7 columns × 4 chars - 1 = 27.
const MONTH_WIDTH_JULIAN: usize = 27;
/// Number of months displayed side-by-side in multi-month views.
const MONTHS_PER_ROW: usize = 3;
/// Gap between side-by-side month blocks.
const GAP: &str = "  ";

/// Render a single month with color highlighting for today.
pub fn print_month(grid: &MonthGrid, today: Option<(i32, u32, u32)>, julian: bool, persian: bool) {
    let lines = render_month(grid, today, julian, persian);
    for line in lines {
        println!("{}", line.trim_end());
    }
}

/// Render multiple months side-by-side and print them.
pub fn print_months(
    grids: &[MonthGrid],
    today: Option<(i32, u32, u32)>,
    julian: bool,
    persian: bool,
) {
    let width = if julian {
        MONTH_WIDTH_JULIAN
    } else {
        MONTH_WIDTH
    };

    for chunk in grids.chunks(MONTHS_PER_ROW) {
        let rendered: Vec<Vec<String>> = chunk
            .iter()
            .map(|g| render_month(g, today, julian, persian))
            .collect();

        let max_lines = rendered.iter().map(|r| r.len()).max().unwrap_or(0);

        for line_idx in 0..max_lines {
            let mut combined = String::new();
            for (i, month_lines) in rendered.iter().enumerate() {
                if i > 0 {
                    combined.push_str(GAP);
                }
                if line_idx < month_lines.len() {
                    combined.push_str(&month_lines[line_idx]);
                } else {
                    combined.push_str(&" ".repeat(width));
                }
            }
            println!("{}", combined.trim_end());
        }
        println!();
    }
}

/// Render a full year and print it.
pub fn print_year(year: i32, today: Option<(i32, u32, u32)>, julian: bool, persian: bool) {
    let width = if julian {
        MONTH_WIDTH_JULIAN
    } else {
        MONTH_WIDTH
    };
    let total_width = width * MONTHS_PER_ROW + GAP.len() * (MONTHS_PER_ROW - 1);

    let year_str = if persian {
        persian::to_persian_digits(&year.to_string())
    } else {
        year.to_string()
    };
    let padding = (total_width.saturating_sub(year_str.len())) / 2;
    if persian {
        println!("{}{}{}{}", LRE, " ".repeat(padding), year_str.bold(), PDF);
    } else {
        println!("{}{}", " ".repeat(padding), year_str.bold());
    }
    println!();

    let grids: Vec<MonthGrid> = (1..=12).map(|m| MonthGrid::new(year, m)).collect();
    print_months(&grids, today, julian, persian);
}

/// Render a single month to a vec of strings with ANSI color codes.
fn render_month(
    grid: &MonthGrid,
    today: Option<(i32, u32, u32)>,
    julian: bool,
    persian: bool,
) -> Vec<String> {
    let cell_width = if julian { 4 } else { 3 };
    let width = if julian {
        MONTH_WIDTH_JULIAN
    } else {
        MONTH_WIDTH
    };

    let weekday_names = if persian {
        &WEEKDAY_NAMES_FA
    } else {
        &WEEKDAY_NAMES_EN
    };

    let is_today = |day: u32| -> bool {
        if let Some((ty, tm, td)) = today {
            ty == grid.year && tm == grid.month && td == day
        } else {
            false
        }
    };

    let mut lines = Vec::new();

    // Title: month name + year
    let month_name = if persian {
        MONTH_NAMES[grid.month as usize - 1].to_string()
    } else {
        capitalize(MONTH_NAMES_ROMANIZED[grid.month as usize - 1])
    };
    let year_str = if persian {
        persian::to_persian_digits(&grid.year.to_string())
    } else {
        grid.year.to_string()
    };
    let title = format!("{month_name} {year_str}");
    let dw = display_width(&title);
    let padding = width.saturating_sub(dw) / 2;
    lines.push(format!("{}{}", " ".repeat(padding), title.bold()));

    // Weekday header
    let header: String = weekday_names
        .iter()
        .enumerate()
        .map(|(i, name)| {
            let w: usize = if i == 0 { cell_width - 1 } else { cell_width };
            let vis_len = display_width(name);
            let pad = w.saturating_sub(vis_len);
            format!("{}{}", " ".repeat(pad), name)
        })
        .collect();
    lines.push(header);

    // Day rows
    let rows = grid.row_count();
    for r in 0..rows {
        let mut row_str = String::new();
        for c in 0..7 {
            let w = if c == 0 { cell_width - 1 } else { cell_width };
            match grid.grid[r][c] {
                Some(day) => {
                    let num = if julian { grid.day_of_year(day) } else { day };
                    let s = if persian {
                        persian::to_persian_digits(&num.to_string())
                    } else {
                        num.to_string()
                    };
                    if is_today(day) {
                        let formatted = format!("{s:>w$}");
                        write!(row_str, "{}", formatted.reversed()).unwrap();
                    } else {
                        write!(row_str, "{s:>w$}").unwrap();
                    }
                }
                None => {
                    row_str.push_str(&" ".repeat(w));
                }
            }
        }
        lines.push(row_str);
    }

    // Pad to 8 lines (1 title + 1 header + 6 data rows)
    while lines.len() < 8 {
        lines.push(String::new());
    }

    // Pad lines to width
    for line in &mut lines {
        let current = visible_width(line);
        if current < width {
            line.push_str(&" ".repeat(width - current));
        }
    }

    // Wrap lines in LTR embedding to prevent BiDi reordering
    if persian {
        for line in &mut lines {
            *line = format!("{LRE}{line}{PDF}");
        }
    }

    lines
}

/// Capitalize the first character of a string.
fn capitalize(s: &str) -> String {
    let mut chars = s.chars();
    match chars.next() {
        None => String::new(),
        Some(c) => c.to_uppercase().to_string() + chars.as_str(),
    }
}

/// Get the display width of a string, skipping zero-width Unicode control characters.
fn display_width(s: &str) -> usize {
    s.chars()
        .filter(|c| !matches!(c, '\u{200e}' | '\u{200f}' | '\u{202a}' | '\u{202c}'))
        .count()
}

/// Get the visible width of a string, ignoring both ANSI escape sequences
/// and zero-width Unicode directional formatting characters.
fn visible_width(s: &str) -> usize {
    let mut width = 0;
    let mut in_escape = false;
    for c in s.chars() {
        if in_escape {
            if c == 'm' {
                in_escape = false;
            }
        } else if c == '\x1b' {
            in_escape = true;
        } else if !matches!(c, '\u{200e}' | '\u{200f}' | '\u{202a}' | '\u{202c}') {
            width += 1;
        }
    }
    width
}