taskfinder/

lib.rs

#![forbid(unsafe_code)]

use std::cmp::Reverse;
use std::fmt::{self, Display, Formatter};
use std::io;
use std::path::{Path, PathBuf};
use std::process::{Command, ExitStatus};
use std::str::FromStr;
use std::sync::LazyLock;
use std::time::SystemTime;
use std::{env, fs};

use chrono::{Local, NaiveDate};
use ratatui::layout::{Constraint, Layout, Rect};
use ratatui::widgets::TableState;
use regex::Regex;
use thiserror::Error;

pub mod config;
pub mod count;
pub mod dialog;
pub mod modes;

use config::{Config, ConfigError};
use count::TaskCount;
use dialog::Dialog;
use modes::{
    Mode,
    config_mode::{ConfigMode, ConfigSetting},
    evergreen_mode::EvergreenMode,
    files_mode::{self, DueFilter, FilesMode},
    help_mode::{HelpMode, USAGE},
    log_mode::{LogMode, LogSubMode},
    tasks_mode::{self, RecurringStatus, TasksMode},
};

pub const SIDEBAR_SIZE: u16 = 38;
pub const TASK_IDENTIFIERS: &[&str] = &[
    "[ ]", "- [ ]", "[]", "- []", "[x]", "- [x]", "[X]", "- [X]", "[/]", "- [/]", "[\\]", "- [\\]",
];

// Configure regex for finding due dates.
pub static DUE_DATE_RE: LazyLock<Regex> =
    LazyLock::new(|| Regex::new(r"(?:due:[0-9]{4}-[0-9]{2}-[0-9]{2})").unwrap());
pub static COMPLETED_DATE_RE: LazyLock<Regex> =
    LazyLock::new(|| Regex::new(r"(?:completed:[0-9]{4}-[0-9]{2}-[0-9]{2})").unwrap());

// regex for finding tags.
pub static TAG_RE: LazyLock<Regex> =
    LazyLock::new(|| Regex::new(r"(?<tag>#[\w&&[^\s]&&[^#]+]+)").unwrap());

// regex for order.
pub static ORDER_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?:::[0-9]*)").unwrap());

/// The errors that can occur.
#[derive(Error, Debug)]
pub enum TfError {
    #[error("IoError: {0}")]
    Io(#[from] io::Error),
    #[error("System time error")]
    SystemTime(#[from] std::time::SystemTimeError),
    #[error("Parsing error")]
    ParseInt(#[from] std::num::ParseIntError),
    #[error("No matching priority.")]
    NoMatchingPriority,
    #[error("Path does not exist.")]
    NoSuchPath,
    #[error("{0}")]
    ConfigError(#[from] config::ConfigError),
}

/// The data and state of the app.
pub struct App {
    pub mode: Mode,
    pub config: Config,
    pub filemode: FilesMode,
    pub logmode: LogMode,
    pub configmode: ConfigMode,
    pub helpmode: HelpMode,
    pub evergreenmode: EvergreenMode,
    pub taskmode: TasksMode,
    pub current_date: NaiveDate,
    pub exit: bool,
}

impl App {
    pub fn new(config: &Config, task_counts: Vec<TaskCount>) -> Self {
        Self {
            mode: config.start_mode.clone(),
            config: config.clone(),
            filemode: FilesMode {
                current_file: 0,
                files: vec![],
                completed: config.include_completed,
                due: DueFilter::Any,
                file_status: FileStatus::Active,
                priority: None,
                tag_dialog: Dialog::default(),
                search_dialog: Dialog::default(),
                line_offset: 0,
            },
            logmode: LogMode {
                submode: LogSubMode::Table,
                data: task_counts,
                table: TableState::default().with_selected(0),
            },
            configmode: ConfigMode {
                table: TableState::default().with_selected(0),
                setting: None,
                dialog: Dialog::default(),
                message_to_user: None,
            },
            helpmode: HelpMode {
                line_offset: 0,
                help_text: USAGE.to_string(),
            },
            evergreenmode: EvergreenMode { line_offset: 0 },
            taskmode: TasksMode {
                data: vec![],
                table: TableState::default().with_selected(0),
                file_status: FileStatus::Active,
                completion_status: CompletionStatus::Incomplete,
                recurring_status: RecurringStatus::All,
                tag_dialog: Dialog::default(),
                search_dialog: Dialog::default(),
                dates: tasks_mode::Dates::default(),
            },
            current_date: Local::now().date_naive(),
            exit: false,
        }
    }

    /// Initialize current mode of the app.
    pub fn mode_init(&mut self, mode: Mode) -> Result<(), TfError> {
        self.mode = mode;

        match self.mode {
            Mode::Files => {
                files_mode::refine_files(self)?;
                self.filemode.line_offset = 0;
            }
            Mode::Tasks => {
                // Need to first collect files, since tasks come from them.
                self.filemode.files = FileWithTasks::collect(&self.config)?;

                // Collect the tasks.
                self.taskmode.data = RichTask::collect(self)?;

                // Set the dates.
                self.taskmode.dates = tasks_mode::Dates::default();

                // Keep position in table (roughly at least), but protect against
                // out-of-bounds error
                if self.taskmode.data.is_empty() {
                    self.taskmode.table.select(None);
                } else if self.taskmode.table.selected() == Some(self.taskmode.data.len()) {
                    self.taskmode
                        .table
                        .select(Some(self.taskmode.data.len() - 1));
                }
            }
            Mode::Log => {
                // Set back to table, the default submode.
                self.logmode.submode = LogSubMode::Table;

                // Recalculate latest log data - this is an expensive operation;
                // only do it when log is opened, not during navigation of log.
                if let Some(v) = self.logmode.data.first_mut() {
                    let active_count =
                        TaskCount::extract(&FileWithTasks::collect(&self.config)?, &self.mode);
                    *v = active_count;
                }
            }
            Mode::Help => {
                self.helpmode.line_offset = 0;
            }
            Mode::Evergreen => {
                if self.config.evergreen_file != Path::new("").to_path_buf() {
                    self.evergreenmode.line_offset = 0;
                }
            }
            Mode::Config => {
                self.configmode.table.select(Some(0));
                self.configmode.setting = ConfigSetting::get(0);
                self.filemode.line_offset = 0;
            }
        };
        Ok(())
    }
}

/// Priority of a file, task set, or task, from lowest to highest.
#[derive(Clone, Copy, PartialEq, PartialOrd, Ord, Hash, Eq, Debug)]
pub enum Priority {
    NoPriority, // Explicitly set.
    Five,
    Four,
    Three,
    Two,
    One,
}

impl Priority {
    /// Extract the highest priority from some amount text.
    pub fn extract(haystack: &str) -> Option<Priority> {
        let priorities = vec![
            Priority::NoPriority,
            Priority::One,
            Priority::Two,
            Priority::Three,
            Priority::Four,
            Priority::Five,
        ];
        let mut priority = None;

        for each in priorities {
            if haystack.contains(&format!("{each}")) {
                priority = Some(each);
                break; // return early, to return highest priority found
            }
        }
        priority
    }
}

impl Display for Priority {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        let priority_markers = Config::priority_markers();
        let priority_str = match self {
            Priority::One => priority_markers[0].to_string(),
            Priority::Two => priority_markers[1].to_string(),
            Priority::Three => priority_markers[2].to_string(),
            Priority::Four => priority_markers[3].to_string(),
            Priority::Five => priority_markers[4].to_string(),
            Priority::NoPriority => "pri@0".to_string(),
        };
        write!(f, "{priority_str}")
    }
}

impl FromStr for Priority {
    type Err = TfError;
    fn from_str(s: &str) -> Result<Priority, TfError> {
        let priority_markers = Config::priority_markers();
        match s {
            "pri@0" => Ok(Priority::NoPriority),
            s if s == priority_markers[0] => Ok(Priority::One),
            s if s == priority_markers[1] => Ok(Priority::Two),
            s if s == priority_markers[2] => Ok(Priority::Three),
            s if s == priority_markers[3] => Ok(Priority::Four),
            s if s == priority_markers[4] => Ok(Priority::Five),
            _ => Err(TfError::NoMatchingPriority),
        }
    }
}

/// How a file can be categorized.
#[derive(PartialEq, Clone, Debug)]
pub enum FileStatus {
    Active,
    Archived,
    Stale,
}

impl Display for FileStatus {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            FileStatus::Active => write!(f, "active"),
            FileStatus::Archived => write!(f, "archived"),
            FileStatus::Stale => write!(f, "stale"),
        }
    }
}

/// Status of a task.
pub enum CompletionStatus {
    Incomplete,
    Completed,
}

impl Display for CompletionStatus {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            CompletionStatus::Incomplete => write!(f, "incomplete"),
            CompletionStatus::Completed => write!(f, "completed"),
        }
    }
}

/// A file that contains tasks.
#[derive(Debug, Clone)]
pub struct FileWithTasks {
    pub file: PathBuf,
    pub last_modified: SystemTime,
    pub priority: Option<Priority>,
    pub status: FileStatus,
    pub has_due_date: bool,
    pub head: Vec<String>,
    pub tags: Vec<String>,
    pub task_sets: Vec<TaskSet>,
}

impl FileWithTasks {
    /// Get all files from configured directory that contain tasks.
    pub fn collect(config: &Config) -> Result<Vec<FileWithTasks>, TfError> {
        // Gather all possible files to examine.
        let paths = collect_file_paths(&config.path, &config.file_extensions, vec![])?;

        // Extract the tasks.
        let mut files_with_tasks: Vec<FileWithTasks> = vec![];
        for path in &paths {
            if let Ok(Some(v)) = Self::extract(path, config.days_to_stale) {
                files_with_tasks.push(v);
            }
        }
        // Sort tasks sets within files.
        for file in files_with_tasks.iter_mut() {
            file.task_sets
                .sort_unstable_by_key(|task_set| Reverse(task_set.priority))
        }

        Ok(files_with_tasks)
    }

    /// Extract data from a file.
    pub fn extract(path: &Path, days_to_stale: u64) -> Result<Option<FileWithTasks>, TfError> {
        let contents = match fs::read_to_string(path) {
            Ok(v) => v,
            Err(_) => return Ok(None),
        };

        if !contents.contains("TODO") {
            return Ok(None);
        }

        let last_modified = fs::metadata(path)?.modified()?;

        // Set file status.
        let stale_threshold = std::time::Duration::from_secs(60 * 60 * 24 * days_to_stale);
        let status = if contents.contains("@archived") {
            FileStatus::Archived
        } else if last_modified.elapsed()? > stale_threshold {
            FileStatus::Stale
        } else {
            FileStatus::Active
        };

        // The first two lines of the file - the title and tags - are the head.
        let head: Vec<String> = contents.lines().take(2).map(String::from).collect();

        // File-level tags.
        let file_tags: Vec<String> = TAG_RE
            .find_iter(&head.join(""))
            .map(|m| m.as_str().strip_prefix("#").unwrap().to_string())
            .collect();

        // file-level priority
        let file_priority = Priority::extract(&head.join("\n"));

        // Create the FileWithTasks.
        let mut file_with_tasks = FileWithTasks {
            file: path.to_path_buf(),
            last_modified,
            priority: file_priority,
            status,
            has_due_date: false,
            head,
            tags: file_tags.clone(),
            task_sets: vec![],
        };

        let mut task_set: Option<TaskSet> = None;
        for (i, line) in contents.lines().enumerate() {
            // Don't do anything with a line until there's a taskset.
            if task_set.is_none() && !line.trim().contains("TODO") {
                continue;
            }

            // Create TaskSet if we come to a TODO section
            if line.trim().contains("TODO") {
                // If there was an existing TaskSet, we've come to a new one,
                // so save the existing one by appending it to Vec we're returning.
                if let Some(v) = task_set {
                    file_with_tasks.task_sets.push(v);
                }

                // Start new TaskSet.
                let mut task_set_priority = Priority::extract(line);
                let mut task_set_due_date = None;
                let mut task_set_completed_date = None;

                // If the task set has no  priority, it inherits the priority of its file, if any.
                // (Unless it has the explicit no priority marker.)
                if task_set_priority.is_none()
                    && !matches!(file_priority, Some(Priority::NoPriority))
                {
                    task_set_priority = file_priority;
                }

                if let Some(dd) = DUE_DATE_RE.find(line.trim()) {
                    task_set_due_date = Some(make_date(dd.as_str(), DateKind::Due));
                }

                if let Some(cd) = COMPLETED_DATE_RE.find(line.trim()) {
                    task_set_completed_date = Some(make_date(cd.as_str(), DateKind::Completed));
                }

                // Taskset-level tags, which inherit/include the file-level tags.
                let mut ts_tags: Vec<String> = TAG_RE
                    .find_iter(line.trim())
                    .map(|m| m.as_str().strip_prefix("#").unwrap().to_string())
                    .collect();
                ts_tags.append(&mut file_tags.clone());

                // Get the name of the task set only.
                let mut ts_text = line.to_string();

                if !ts_tags.is_empty() {
                    for tag in &ts_tags {
                        ts_text = ts_text.replace(&format!("#{tag}"), "");
                    }
                }
                if let Some(dd) = task_set_due_date {
                    ts_text = ts_text.replace(&format!("due:{dd}"), "");
                }
                if let Some(cd) = task_set_completed_date {
                    ts_text = ts_text.replace(&format!("completed:{cd}"), "");
                }
                if let Some(v) = task_set_priority {
                    ts_text = ts_text.replace(&format!("{v}"), "");
                }
                ts_text = ts_text.trim_end().to_string();

                task_set = Some(TaskSet::new(
                    ts_text,
                    task_set_priority,
                    task_set_due_date,
                    task_set_completed_date,
                    ts_tags,
                ));
                continue;
            }

            // Extract tasks if we're in a task set.
            if let Some(ts) = &mut task_set {
                for ider in TASK_IDENTIFIERS {
                    if line.trim_start().starts_with(ider) {
                        // Set priority at the task level, inheriting if necessary.
                        let mut task_priority = Priority::extract(line);
                        if task_priority.is_none() {
                            if ts.priority.is_some() {
                                task_priority = ts.priority;
                            } else if file_priority.is_some() {
                                task_priority = file_priority;
                            }
                        }

                        // Set due date at the task level, inheriting if necessary.
                        let due_date = if let Some(dd) = DUE_DATE_RE.find(line) {
                            Some(make_date(dd.as_str(), DateKind::Due))
                        } else {
                            ts.due_date
                        };

                        // Set completed date at the task level, inheriting if necessary.
                        let completed_date = if let Some(cd) = COMPLETED_DATE_RE.find(line) {
                            Some(make_date(cd.as_str(), DateKind::Completed))
                        } else {
                            ts.completed_date
                        };

                        let completed = line.trim().to_lowercase().starts_with("[x]")
                            || line.trim().to_lowercase().starts_with("- [x]");

                        // Task-level tags, which inherit taskset-level tags (which in turn
                        // inherited file-level tags).
                        let mut task_tags: Vec<String> = TAG_RE
                            .find_iter(line.trim())
                            .map(|m| m.as_str().strip_prefix("#").unwrap().to_string())
                            .collect();
                        task_tags.append(&mut ts.tags.clone());

                        // Set order, if any
                        let order = if let Some(o) = ORDER_RE.find(line) {
                            o.as_str().strip_prefix("::").unwrap().parse().ok()
                        } else {
                            None
                        };

                        // Get task name only.
                        let mut task_text = line.to_string();
                        if let Some(dd) = due_date {
                            task_text = task_text.replace(&format!("due:{dd}"), "");
                        }
                        if let Some(cd) = completed_date {
                            task_text = task_text.replace(&format!("completed:{cd}"), "");
                        }
                        if !task_tags.is_empty() {
                            for tag in &task_tags {
                                task_text = task_text.replace(&format!("#{tag}"), "");
                            }
                        }
                        if let Some(o) = order {
                            task_text = task_text.replace(&format!("::{o}"), "");
                        }
                        if let Some(v) = task_priority {
                            task_text = task_text.replace(&format!("{v}"), "");
                        }
                        task_text = task_text.trim_end().to_string();

                        let task = Task {
                            text: task_text,
                            completed,
                            completed_date,
                            due_date,
                            priority: task_priority,
                            tags: task_tags,
                            line: i + 1,
                            order,
                        };

                        // Indicate if the file has a task with a due date, to ease work elsewhere.
                        if task.due_date.is_some() {
                            file_with_tasks.has_due_date = true;
                        }
                        ts.tasks.push(task);
                        break;
                    }
                }
            }
        }
        // Add last/only TaskSet to the FileWithTasks
        if let Some(v) = task_set {
            file_with_tasks.task_sets.push(v);
        }

        // If any task set contains tasks, return it. Otherwise (if all tasks sets are empty),
        // it falls through to returning None.
        for task_set in &file_with_tasks.task_sets {
            if !task_set.tasks.is_empty() {
                return Ok(Some(file_with_tasks));
            }
        }
        Ok(None)
    }
}

/// A group of tasks.
#[derive(Debug, Clone)]
pub struct TaskSet {
    pub name: String,
    pub priority: Option<Priority>,
    pub due_date: Option<NaiveDate>,
    pub completed_date: Option<NaiveDate>,
    pub tasks: Vec<Task>,
    pub tags: Vec<String>,
}

impl TaskSet {
    fn new(
        name: String,
        priority: Option<Priority>,
        due_date: Option<NaiveDate>,
        completed_date: Option<NaiveDate>,
        tags: Vec<String>,
    ) -> Self {
        Self {
            name,
            priority,
            due_date,
            completed_date,
            tasks: vec![],
            tags,
        }
    }
}

/// An individual task.
#[derive(Debug, Clone)]
pub struct Task {
    pub text: String,
    pub completed: bool,
    pub due_date: Option<NaiveDate>,
    pub completed_date: Option<NaiveDate>,
    pub priority: Option<Priority>,
    pub tags: Vec<String>,
    pub line: usize,
    pub order: Option<usize>,
}

/// A task that includes the task set and file it belongs to.
#[derive(Debug, Clone)]
pub struct RichTask {
    pub task: Task,
    pub task_set: String,
    pub file_name: String,
    pub file_path: PathBuf,
    pub file_status: FileStatus,
}

impl RichTask {
    /// Collect all rich tasks.
    pub fn collect(app: &App) -> Result<Vec<Self>, TfError> {
        // Start from files that have already been collected - that's an expensive operation
        // and no need to re-do it here.
        let mut files = app.filemode.files.clone();

        // Filter files by status.
        match app.taskmode.file_status {
            FileStatus::Active => {
                files.retain(|f| f.status == FileStatus::Active);
            }
            FileStatus::Archived => {
                files.retain(|f| f.status == FileStatus::Archived);
            }
            FileStatus::Stale => {
                files.retain(|f| f.status == FileStatus::Stale);
            }
        }

        // Filter tasks/collect as RichTasks.
        let mut tasks = vec![];

        // Instead of having this if/else statement, the check could be done just during the
        // loop through tasks, but it's better for performance to avoid that check if it's not
        // necessary.
        if !app.taskmode.search_dialog.submitted_input.is_empty() {
            for file in files {
                for task_set in file.task_sets {
                    for task in task_set.tasks {
                        // Filter by completion status.
                        match app.taskmode.completion_status {
                            CompletionStatus::Incomplete => {
                                if task.completed {
                                    continue;
                                }
                            }
                            CompletionStatus::Completed => {
                                if !task.completed {
                                    continue;
                                }
                            }
                        }
                        // Filter by task-level tag.
                        if !app.taskmode.tag_dialog.submitted_input.is_empty()
                            && !task.tags.contains(&app.taskmode.tag_dialog.submitted_input)
                        {
                            continue;
                        }

                        // Filter by recurring status.
                        match app.taskmode.recurring_status {
                            RecurringStatus::All => (),
                            RecurringStatus::Recurring => {
                                if !RecurringStatus::check(task.text.clone()) {
                                    continue;
                                }
                            }
                            RecurringStatus::NonRecurring => {
                                if RecurringStatus::check(task.text.clone()) {
                                    continue;
                                }
                            }
                        }
                        // Filter files by search term.
                        if !task
                            .text
                            .to_lowercase()
                            .contains(&app.taskmode.search_dialog.submitted_input)
                        {
                            continue;
                        }
                        tasks.push(RichTask {
                            task,
                            task_set: task_set.name.clone(),
                            file_name: file.head[0].clone(),
                            file_path: file.file.clone(),
                            file_status: file.status.clone(),
                        })
                    }
                }
            }
        } else {
            for file in files {
                for task_set in file.task_sets {
                    for task in task_set.tasks {
                        // Filter by completion status.
                        match app.taskmode.completion_status {
                            CompletionStatus::Incomplete => {
                                if task.completed {
                                    continue;
                                }
                            }
                            CompletionStatus::Completed => {
                                if !task.completed {
                                    continue;
                                }
                            }
                        }
                        // Filter by tag.
                        if !app.taskmode.tag_dialog.submitted_input.is_empty()
                            && !task.tags.contains(&app.taskmode.tag_dialog.submitted_input)
                        {
                            continue;
                        }
                        // Filter by recurring status.
                        match app.taskmode.recurring_status {
                            RecurringStatus::All => (),
                            RecurringStatus::Recurring => {
                                if !RecurringStatus::check(task.text.clone()) {
                                    continue;
                                }
                            }
                            RecurringStatus::NonRecurring => {
                                if RecurringStatus::check(task.text.clone()) {
                                    continue;
                                }
                            }
                        }
                        tasks.push(RichTask {
                            task,
                            task_set: task_set.name.clone(),
                            file_name: file.head[0].clone(),
                            file_path: file.file.clone(),
                            file_status: file.status.clone(),
                        })
                    }
                }
            }
        }

        // Sort, first by priority.
        tasks.sort_by_key(|task| Reverse(task.task.priority));

        // Sort, next by order.
        tasks.sort_by_key(|task| task.task.order.unwrap_or(9999));

        // Sort, next by due or completed due.
        match app.taskmode.completion_status {
            CompletionStatus::Incomplete => {
                // Split vec in two in order to do this - otherwise it will put those without
                // due dates first.
                let mut with_due_dates = tasks.clone();
                // with_due_dates.sort_by_key(|task| task.task.order);
                with_due_dates.retain(|task| task.task.due_date.is_some());
                with_due_dates.sort_by_key(|task| task.task.due_date);

                let mut without_due_dates = tasks;
                without_due_dates.retain(|task| task.task.due_date.is_none());

                with_due_dates.append(&mut without_due_dates);
                tasks = with_due_dates;
            }
            CompletionStatus::Completed => {
                tasks.sort_by_key(|task| Reverse(task.task.completed_date));
            }
        }

        Ok(tasks)
    }
}

/// Collect all paths within configured directory and with specified extensions, ignoring any
/// full paths listed in the ignore file.
fn collect_file_paths(
    dir: &Path,
    extensions: &Vec<String>,
    mut results: Vec<PathBuf>,
) -> Result<Vec<PathBuf>, TfError> {
    // Get ignored directories.
    let mut config_dir = match dirs::config_dir() {
        Some(v) => v,
        None => return Err(ConfigError::LocateConfigDir)?,
    };
    config_dir.push("taskfinder/ignore");
    let ignored_dirs = match fs::read_to_string(config_dir) {
        Ok(v) => v
            .lines()
            .filter(|l| !l.is_empty())
            .map(Path::new)
            .map(|p| p.to_path_buf())
            .collect::<Vec<_>>(),
        Err(_) => vec![],
    };

    // Loop through directories, excluding ignored, and
    if dir.is_dir() {
        'outer: for entry in fs::read_dir(dir)? {
            let entry = entry?;
            let path = entry.path();
            if path.is_dir() {
                if !ignored_dirs.is_empty() {
                    for ignored_dir in &ignored_dirs {
                        if path.starts_with(ignored_dir) {
                            continue 'outer;
                        }
                    }
                }
                results = collect_file_paths(&path, extensions, results)?;
            } else if let Some(v) = path.extension() {
                if extensions.contains(&v.to_str().unwrap().to_owned()) {
                    results.push(path)
                }
            }
        }
    }
    Ok(results)
}

/// Open a file for editing.
pub fn edit(file: PathBuf, line: Option<usize>) -> io::Result<ExitStatus> {
    let editor = match env::var("EDITOR") {
        Ok(v) => v,
        Err(_) => String::from("vim"),
    };

    if let Some(v) = line {
        if ["hx", "vi", "vim", "nvim"].contains(&editor.as_str()) {
            Command::new(editor)
                .args([file, format!("+{v}").into()])
                .status()
        } else {
            Command::new(editor).args([file]).status()
        }
    } else {
        Command::new(editor).args([file]).status()
    }
}

/// Create a centered rect, offset by sidebar.
///
/// Modified version of <https://ratatui.rs/how-to/layout/center-a-rect/>.
pub fn centered_rect(x: u16, y: u16, r: Rect, sidebar_size: u16) -> Rect {
    let dialog_layout = Layout::vertical([
        Constraint::Fill(1),
        Constraint::Length(y),
        Constraint::Fill(1),
    ])
    .split(r);

    Layout::horizontal([
        Constraint::Fill(1),
        Constraint::Length(x),
        Constraint::Fill(1),
        Constraint::Length(sidebar_size),
    ])
    .split(dialog_layout[1])[1]
}

/// Whether a date is a due date or a completed date.
enum DateKind {
    Due,
    Completed,
}

/// Create date from text.
///
/// If the date is invalid, this sets it to one long in the past to indicate that to the user.
fn make_date(s: &str, date_kind: DateKind) -> NaiveDate {
    let prefix = match date_kind {
        DateKind::Due => "due:",
        DateKind::Completed => "completed:",
    };

    match NaiveDate::from_str(s.strip_prefix(prefix).unwrap()) {
        Ok(v) => v,
        Err(_) => NaiveDate::from_str("1900-01-01").unwrap(),
    }
}

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

    #[test]
    /// The readme links to the usage doc corresponding to the most recent release, and the tag
    /// should match the format of the version, so make sure it's there.
    fn readme_contains_current_version_tag() {
        let readme = fs::read_to_string(Path::new("README.md")).unwrap();
        assert!(readme.contains(std::env!("CARGO_PKG_VERSION")))
    }
    #[test]
    fn extract_correct_number_of_task_sets() {
        let file = Path::new("test_files/01_basics.txt");
        let file_with_tasks = FileWithTasks::extract(file, 365).unwrap().unwrap();
        assert_eq!(file_with_tasks.task_sets.len(), 2);
    }

    #[test]
    fn extract_correct_number_of_tasks_in_task_set() {
        let file = Path::new("test_files/01_basics.txt");
        let task_sets = FileWithTasks::extract(file, 365)
            .unwrap()
            .unwrap()
            .task_sets
            .clone();
        assert_eq!(task_sets[0].tasks.len(), 2);
        assert_eq!(task_sets[1].tasks.len(), 4);
    }

    #[test]
    fn tasks_ignored_with_no_todo_header() {
        let file = Path::new("test_files/no_tasks.txt");
        let task_sets = FileWithTasks::extract(file, 365).unwrap();
        assert!(task_sets.is_none());
    }

    #[test]
    fn highest_priority_in_file_is_correct() {
        let priority = Priority::extract(
            &fs::read_to_string(Path::new("test_files/04_priorities.txt")).unwrap(),
        );
        assert_eq!(priority, Some(Priority::One));

        let priority =
            Priority::extract(&fs::read_to_string(Path::new("test_files/01_basics.txt")).unwrap());
        assert_eq!(priority, None);
    }

    #[test]
    fn due_date_inheritance_is_correct() {
        let file_with_dates = FileWithTasks::extract(Path::new("test_files/03_dates.txt"), 365)
            .unwrap()
            .unwrap();

        assert_eq!(
            file_with_dates.task_sets[0].due_date,
            Some(NaiveDate::from_str("2025-04-30").unwrap())
        );
        assert!(file_with_dates.task_sets[1].due_date.is_none());
        assert_eq!(
            file_with_dates.task_sets[0].tasks[0].due_date,
            Some(NaiveDate::from_str("2025-04-30").unwrap())
        );
        assert_eq!(
            file_with_dates.task_sets[0].tasks[1].due_date,
            Some(NaiveDate::from_str("2025-04-30").unwrap())
        );
    }
}