task.rs

use chrono::{serde::ts_seconds, DateTime, Local, Utc};
use std::fmt;
use serde::{Deserialize,Serialize};
use std::{fs::OpenOptions, io::ErrorKind, path::PathBuf};
use std::io::{Error,Result,Seek,SeekFrom,};  // Include the error type
use std::fs::File;


#[derive(Debug, Deserialize, Serialize)]
pub struct Tasks {
    pub tasklist: Vec<Task>,
}

impl Tasks {
    pub fn new(tasks:Vec<Task>) -> Tasks {
        Tasks {
            tasklist: tasks
        }
    }
}

#[derive(Debug, Deserialize, Serialize)]
pub struct Task {
    pub text: String,

    #[serde(with = "ts_seconds")]
    pub created_at: DateTime<Utc>,
}

impl Task {
    pub fn new(text: String) -> Task {
        let created_at: DateTime<Utc> = Utc::now();
        Task { text, created_at }
    }
}
pub fn add_task(todo_path: PathBuf, task: Task) -> Result<()> {
    let file = OpenOptions::new()
        .read(true)
        .write(true)
        .create(true)
        .open(todo_path)?;
    let mut tasks = collect_tasks(&file)?.tasklist;
    tasks.push(task);
    serde_json::to_writer(file, &Tasks::new(tasks))?;
    Ok(())
}
pub fn complete_task(todo_path: PathBuf, task_position: usize) -> Result<()> {
    // Open the file.
    let file = OpenOptions::new()
        .read(true)
        .write(true)
        .open(todo_path)?;

    // Consume file's contents as a vector of tasks.
    let mut tasks = collect_tasks(&file)?.tasklist;

    // Try to remove the task.
    if task_position == 0 || task_position > tasks.len() {
        return Err(Error::new(ErrorKind::InvalidInput, "Invalid Task ID"));
    }
    tasks.remove(task_position - 1);

    // Write the modified task list back into the file.
    file.set_len(0)?;
    serde_json::to_writer(file, &Tasks::new(tasks))?;
    Ok(())
}

fn collect_tasks(mut file: &File) -> Result<Tasks> {
    file.seek(SeekFrom::Start(0))?; // Rewind the file before.
    let tasks = match serde_json::from_reader(file) {
        Ok(tasks) => tasks,
        Err(e) if e.is_eof() => Tasks::new(Vec::new()),
        Err(e) => Err(e)?,
    };
    file.seek(SeekFrom::Start(0))?; // Rewind the file after.
    Ok(tasks)
}
pub fn list_tasks(todo_path: PathBuf) -> Result<()> {
    // Open the file.
    let file = OpenOptions::new().read(true).open(todo_path)?;
    // Parse the file and collect the tasks.
    let tasks = collect_tasks(&file)?.tasklist;

    // Enumerate and display tasks, if any.
    if tasks.is_empty() {
        println!("Task list is empty!");
    } else {
        let mut order: u32 = 1;
        for task in tasks {
            println!("{}: {}", order, task);
            order += 1;
        }
    }

    impl fmt::Display for Task {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let created_at = self.created_at.with_timezone(&Local).format("%F %H:%M");
            write!(f, "{:<50} [{}]", self.text, created_at)
        }
    }

    Ok(())
}