pcal/

formatter.rs

//! Plain-text calendar formatting without ANSI colors.
//!
//! Used for generating uncolored output and in unit tests. Produces fixed-width
//! text suitable for side-by-side month layouts.

use std::fmt::Write as _;

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

/// Width of a single month block in characters
const MONTH_WIDTH: usize = 20; // 7 * 3 - 1 = 20
const MONTH_WIDTH_JULIAN: usize = 27; // 7 * 4 - 1 = 27
const MONTHS_PER_ROW: usize = 3;
const GAP: &str = "  ";

/// Render a single month as lines of text.
/// Each line is exactly `MONTH_WIDTH` characters wide.
#[must_use]
pub fn format_month(grid: &MonthGrid, 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 mut lines = Vec::new();

    // Title: "month_name year" centered
    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}");
    lines.push(center_persian(&title, width));

    // Weekday header
    let header: String = weekday_names
        .iter()
        .enumerate()
        .map(|(i, name)| {
            if i == 0 {
                format!("{:>width$}", name, width = cell_width - 1)
            } else {
                format!("{name:>cell_width$}")
            }
        })
        .collect::<String>();
    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 cell = match grid.grid[r][c] {
                Some(day) => {
                    let num = if julian { grid.day_of_year(day) } else { day };
                    let s = num.to_string();
                    if persian {
                        persian::to_persian_digits(&s)
                    } else {
                        s
                    }
                }
                None => String::new(),
            };
            if c == 0 {
                write!(row_str, "{:>width$}", cell, width = cell_width - 1).unwrap();
            } else {
                write!(row_str, "{cell:>cell_width$}").unwrap();
            }
        }
        lines.push(row_str);
    }

    // Pad remaining rows so all months have the same height (6 data rows)
    while lines.len() < 8 {
        // 1 title + 1 header + 6 data rows
        lines.push(String::new());
    }

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

    lines
}

/// Render multiple months side-by-side, 3 per row.
#[must_use]
pub fn format_months(grids: &[MonthGrid], julian: bool, persian: bool) -> Vec<String> {
    let mut output = Vec::new();

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

        let max_lines = formatted.iter().map(|f| f.len()).max().unwrap_or(0);

        let width = if julian {
            MONTH_WIDTH_JULIAN
        } else {
            MONTH_WIDTH
        };

        for line_idx in 0..max_lines {
            let mut combined = String::new();
            for (i, month_lines) in formatted.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));
                }
            }
            output.push(combined.trim_end().to_string());
        }

        // Blank line between rows of months
        output.push(String::new());
    }

    // Remove trailing blank line
    if output.last().is_some_and(|l| l.is_empty()) {
        output.pop();
    }

    output
}

/// Render all 12 months of a year as lines of text (4 rows × 3 columns).
#[must_use]
pub fn format_year(year: i32, julian: bool, persian: bool) -> Vec<String> {
    let width = if julian {
        MONTH_WIDTH_JULIAN
    } else {
        MONTH_WIDTH
    };
    let total_width = width * MONTHS_PER_ROW + GAP.len() * (MONTHS_PER_ROW - 1);

    let mut output = Vec::new();

    // Year title centered
    let year_str = if persian {
        persian::to_persian_digits(&year.to_string())
    } else {
        year.to_string()
    };
    output.push(center_str(&year_str, total_width));
    output.push(String::new());

    let grids: Vec<MonthGrid> = (1..=12).map(|m| MonthGrid::new(year, m)).collect();

    output.extend(format_months(&grids, julian, persian));
    output
}

/// 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(),
    }
}

/// Center an ASCII string within a given width.
fn center_str(s: &str, width: usize) -> String {
    let len = s.len();
    if len >= width {
        return s.to_string();
    }
    let padding = (width - len) / 2;
    format!("{}{}", " ".repeat(padding), s)
}

/// Center a string that may contain Persian/Unicode characters,
/// using visible width for padding calculation.
fn center_persian(s: &str, width: usize) -> String {
    let dw = display_width(s);
    if dw >= width {
        return s.to_string();
    }
    let padding = (width - dw) / 2;
    format!("{}{}", " ".repeat(padding), s)
}

/// 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}'))
        .map(|_| 1)
        .sum()
}

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

    #[test]
    fn test_format_month_default() {
        let grid = MonthGrid::new(2584, 1);
        let lines = format_month(&grid, false, false);
        assert_eq!(lines.len(), 8);
        // Default uses English: "Farvardin 2584"
        assert!(lines[0].contains("Farvardin"));
        assert!(lines[0].contains("2584"));
        // Header should have English weekday names
        assert!(lines[1].contains("Sa"));
    }

    #[test]
    fn test_format_month_persian() {
        let grid = MonthGrid::new(2584, 1);
        let lines = format_month(&grid, false, true);
        assert!(lines[0].contains("فروردین"));
        assert!(lines[0].contains("۲۵۸۴"));
    }

    #[test]
    fn test_format_year() {
        let lines = format_year(2584, false, false);
        assert!(lines[0].contains("2584"));
        // Should have all 12 month names in English
        for name in MONTH_NAMES_ROMANIZED {
            assert!(lines.iter().any(|l| l.to_lowercase().contains(name)));
        }
    }
}