8 files changed, 289 insertions, 108 deletions

diff --git a/src/app/impl_self.rs b/src/app/impl_self.rs
index 744f906..5cd9616 100644
--- a/src/app/impl_self.rs
+++ b/src/app/impl_self.rs
@@ -13,8 +13,7 @@ use notify::{watcher, RecursiveMode, Watcher};
 
 use crate::command::{Command, CommandLineError};
 use crate::habit::{Bit, Count, HabitWrapper, TrackEvent, ViewMode};
-use crate::utils;
-use crate::CONFIGURATION;
+use crate::utils::{self, GRID_WIDTH, VIEW_HEIGHT, VIEW_WIDTH};
 
 use crate::app::{App, MessageKind, StatusLine};
 
@@ -37,6 +36,10 @@ impl App {
         self.habits.push(h);
     }
 
+    pub fn list_habits(&self) -> Vec<String> {
+        self.habits.iter().map(|x| x.name()).collect::<Vec<_>>()
+    }
+
     pub fn delete_by_name(&mut self, name: &str) {
         let old_len = self.habits.len();
         self.habits.retain(|h| h.name() != name);
@@ -83,7 +86,6 @@ impl App {
     }
 
     pub fn set_focus(&mut self, d: Absolute) {
-        let grid_width = CONFIGURATION.grid_width;
         match d {
             Absolute::Right => {
                 if self.focus != self.habits.len() - 1 {
@@ -96,15 +98,15 @@ impl App {
                 }
             }
             Absolute::Down => {
-                if self.focus + grid_width < self.habits.len() - 1 {
-                    self.focus += grid_width;
+                if self.focus + GRID_WIDTH < self.habits.len() - 1 {
+                    self.focus += GRID_WIDTH;
                 } else {
                     self.focus = self.habits.len() - 1;
                 }
             }
             Absolute::Up => {
-                if self.focus as isize - grid_width as isize >= 0 {
-                    self.focus -= grid_width;
+                if self.focus as isize - GRID_WIDTH as isize >= 0 {
+                    self.focus -= GRID_WIDTH;
                 } else {
                     self.focus = 0;
                 }
@@ -118,13 +120,13 @@ impl App {
     }
 
     pub fn status(&self) -> StatusLine {
-        let today = chrono::Local::now().naive_utc().date();
+        let today = chrono::Local::now().naive_local().date();
         let remaining = self.habits.iter().map(|h| h.remaining(today)).sum::<u32>();
         let total = self.habits.iter().map(|h| h.goal()).sum::<u32>();
         let completed = total - remaining;
 
         let timestamp = if self.view_month_offset == 0 {
-            format!("{}", Local::now().date().format("%d/%b/%y"),)
+            format!("{}", Local::now().naive_local().date().format("%d/%b/%y"),)
         } else {
             let months = self.view_month_offset;
             format!("{}", format!("{} months ago", months),)
@@ -142,12 +144,10 @@ impl App {
     }
 
     pub fn max_size(&self) -> Vec2 {
-        let grid_width = CONFIGURATION.grid_width;
-        let width = grid_width * CONFIGURATION.view_width;
+        let width = GRID_WIDTH * VIEW_WIDTH;
         let height = {
             if !self.habits.is_empty() {
-                (CONFIGURATION.view_height as f64
-                    * (self.habits.len() as f64 / grid_width as f64).ceil())
+                (VIEW_HEIGHT as f64 * (self.habits.len() as f64 / GRID_WIDTH as f64).ceil())
                     as usize
             } else {
                 0
@@ -207,12 +207,18 @@ impl App {
                 .iter_mut()
                 .find(|x| x.name() == name && x.is_auto());
             if let Some(h) = target_habit {
-                h.modify(Local::now().naive_utc().date(), event);
+                h.modify(Local::now().naive_local().date(), event);
             }
         };
         match result {
             Ok(c) => match c {
                 Command::Add(name, goal, auto) => {
+                    if let Some(_) = self.habits.iter().find(|x| x.name() == name) {
+                        self.message.set_kind(MessageKind::Error);
+                        self.message
+                            .set_message(format!("Habit `{}` already exist", &name));
+                        return;
+                    }
                     let kind = if goal == Some(1) { "bit" } else { "count" };
                     if kind == "count" {
                         self.add_habit(Box::new(Count::new(name, goal.unwrap_or(0), auto)));
@@ -230,7 +236,31 @@ impl App {
                 Command::TrackDown(name) => {
                     _track(&name, TrackEvent::Decrement);
                 }
-                Command::Quit => self.save_state(),
+                Command::Help(input) => {
+                    if let Some(topic) = input.as_ref().map(String::as_ref) {
+                        self.message.set_message(
+                            match topic {
+                                "a"     | "add" => "add <habit-name> [goal]     (alias: a)",
+                                "aa"    | "add-auto" => "add-auto <habit-name> [goal]     (alias: aa)",
+                                "d"     | "delete" => "delete <habit-name>     (alias: d)",
+                                "mprev" | "month-prev" => "month-prev     (alias: mprev)",
+                                "mnext" | "month-next" => "month-next     (alias: mnext)",
+                                "tup"   | "track-up" => "track-up <auto-habit-name>     (alias: tup)",
+                                "tdown" | "track-down" => "track-down <auto-habit-name>     (alias: tdown)",
+                                "q"     | "quit" => "quit dijo",
+                                "w"     | "write" => "write current state to disk   (alias: w)",
+                                "h"|"?" | "help" => "help [<command>|commands|keys]     (aliases: h, ?)",
+                                "cmds"  | "commands" => "add, add-auto, delete, month-{prev,next}, track-{up,down}, help, quit",
+                                "keys" => "TODO", // TODO (view?)
+                                _ => "unknown command or help topic.",
+                            }
+                        )
+                    } else {
+                        // TODO (view?)
+                        self.message.set_message("help <command>|commands|keys")
+                    }
+                }
+                Command::Quit | Command::Write => self.save_state(),
                 Command::MonthNext => self.sift_forward(),
                 Command::MonthPrev => self.sift_backward(),
                 Command::Blank => {}
diff --git a/src/app/impl_view.rs b/src/app/impl_view.rs
index 892b00c..395cac4 100644
--- a/src/app/impl_view.rs
+++ b/src/app/impl_view.rs
@@ -12,21 +12,17 @@ use notify::DebouncedEvent;
 
 use crate::app::{App, MessageKind};
 use crate::habit::{HabitWrapper, ViewMode};
-use crate::utils;
-use crate::CONFIGURATION;
+use crate::utils::{self, GRID_WIDTH, VIEW_HEIGHT, VIEW_WIDTH};
 
 impl View for App {
     fn draw(&self, printer: &Printer) {
-        let grid_width = CONFIGURATION.grid_width;
-        let view_width = CONFIGURATION.view_width;
-        let view_height = CONFIGURATION.view_height;
         let mut offset = Vec2::zero();
         for (idx, habit) in self.habits.iter().enumerate() {
-            if idx >= grid_width && idx % grid_width == 0 {
-                offset = offset.map_y(|y| y + view_height).map_x(|_| 0);
+            if idx >= GRID_WIDTH && idx % GRID_WIDTH == 0 {
+                offset = offset.map_y(|y| y + VIEW_HEIGHT).map_x(|_| 0);
             }
             habit.draw(&printer.offset(offset).focused(self.focus == idx));
-            offset = offset.map_x(|x| x + view_width + 2);
+            offset = offset.map_x(|x| x + VIEW_WIDTH + 2);
         }
 
         offset = offset.map_x(|_| 0).map_y(|_| self.max_size().y - 2);
@@ -45,13 +41,10 @@ impl View for App {
     }
 
     fn required_size(&mut self, _: Vec2) -> Vec2 {
-        let grid_width = CONFIGURATION.grid_width;
-        let view_width = CONFIGURATION.view_width;
-        let view_height = CONFIGURATION.view_height;
-        let width = grid_width * (view_width + 2);
+        let width = GRID_WIDTH * (VIEW_WIDTH + 2);
         let height = {
             if self.habits.len() > 0 {
-                (view_height as f64 * (self.habits.len() as f64 / grid_width as f64).ceil())
+                (VIEW_HEIGHT as f64 * (self.habits.len() as f64 / GRID_WIDTH as f64).ceil())
                     as usize
             } else {
                 0
@@ -102,25 +95,6 @@ impl View for App {
                 self.set_focus(Absolute::Down);
                 return EventResult::Consumed(None);
             }
-            Event::Char('d') => {
-                if self.habits.is_empty() {
-                    return EventResult::Consumed(None);
-                }
-                self.habits.remove(self.focus);
-                self.focus = self.focus.checked_sub(1).unwrap_or(0);
-                return EventResult::Consumed(None);
-            }
-            Event::Char('w') => {
-                // helper bind to test write to file
-                let j = serde_json::to_string_pretty(&self.habits).unwrap();
-                let mut file = File::create("foo.txt").unwrap();
-                file.write_all(j.as_bytes()).unwrap();
-                return EventResult::Consumed(None);
-            }
-            Event::Char('q') => {
-                self.save_state();
-                return EventResult::with_cb(|s| s.quit());
-            }
             Event::Char('v') => {
                 if self.habits.is_empty() {
                     return EventResult::Consumed(None);
diff --git a/src/command.rs b/src/command.rs
index f856b00..4f3e491 100644
--- a/src/command.rs
+++ b/src/command.rs
@@ -1,21 +1,73 @@
 use std::fmt;
 
+use cursive::event::{Event, EventResult, Key};
 use cursive::theme::{BaseColor, Color, ColorStyle};
 use cursive::view::Resizable;
-use cursive::views::{EditView, LinearLayout, TextView};
+use cursive::views::{EditView, LinearLayout, OnEventView, TextView};
 use cursive::Cursive;
 
-use crate::{app::App, CONFIGURATION};
+use crate::app::App;
+use crate::utils::{GRID_WIDTH, VIEW_WIDTH};
+
+static COMMANDS: &'static [&'static str] = &[
+    "add",
+    "add-auto",
+    "delete",
+    "track-up",
+    "track-down",
+    "month-prev",
+    "month-next",
+    "quit",
+    "write",
+    "help",
+];
+
+fn get_command_completion(prefix: &str) -> Option<String> {
+    let first_match = COMMANDS.iter().filter(|&x| x.starts_with(prefix)).next();
+    return first_match.map(|&x| x.into());
+}
+
+fn get_habit_completion(prefix: &str, habit_names: &[String]) -> Option<String> {
+    let first_match = habit_names.iter().filter(|&x| x.starts_with(prefix)).next();
+    return first_match.map(|x| x.into());
+}
 
 pub fn open_command_window(s: &mut Cursive) {
-    let command_window = EditView::new()
-        .filler(" ")
-        .on_submit(call_on_app)
-        .style(ColorStyle::new(
-            Color::Dark(BaseColor::Black),
-            Color::Dark(BaseColor::White),
-        ))
-        .fixed_width(CONFIGURATION.view_width * CONFIGURATION.grid_width);
+    let habit_list: Vec<String> = s
+        .call_on_name("Main", |view: &mut App| {
+            return view.list_habits();
+        })
+        .unwrap();
+    let style = ColorStyle::new(Color::Dark(BaseColor::Black), Color::Dark(BaseColor::White));
+    let command_window = OnEventView::new(
+        EditView::new()
+            .filler(" ")
+            .on_submit(call_on_app)
+            .style(style),
+    )
+    .on_event_inner(
+        Event::Key(Key::Tab),
+        move |view: &mut EditView, _: &Event| {
+            let contents = view.get_content();
+            if !contents.contains(" ") {
+                let completion = get_command_completion(&*contents);
+                if let Some(c) = completion {
+                    let cb = view.set_content(c);
+                    return Some(EventResult::Consumed(Some(cb)));
+                };
+                return None;
+            } else {
+                let word = contents.split(' ').last().unwrap();
+                let completion = get_habit_completion(word, &habit_list);
+                if let Some(c) = completion {
+                    let cb = view.set_content(format!("{}", contents) + &c[word.len()..]);
+                    return Some(EventResult::Consumed(Some(cb)));
+                };
+                return None;
+            }
+        },
+    )
+    .fixed_width(VIEW_WIDTH * GRID_WIDTH);
     s.call_on_name("Frame", |view: &mut LinearLayout| {
         let mut commandline = LinearLayout::horizontal()
             .child(TextView::new(":"))
@@ -59,15 +111,17 @@ pub enum Command {
     Delete(String),
     TrackUp(String),
     TrackDown(String),
+    Help(Option<String>),
+    Write,
     Quit,
     Blank,
 }
 
 #[derive(Debug)]
 pub enum CommandLineError {
-    InvalidCommand(String),
-    InvalidArg(u32), // position
-    NotEnoughArgs(String, u32),
+    InvalidCommand(String),     // command name
+    InvalidArg(u32),            // position
+    NotEnoughArgs(String, u32), // command name, required no. of args
 }
 
 impl std::error::Error for CommandLineError {}
@@ -134,9 +188,16 @@ impl Command {
                 }
                 return Ok(Command::TrackDown(args[0].to_string()));
             }
+            "h" | "?" | "help" => {
+                if args.is_empty() {
+                    return Ok(Command::Help(None));
+                }
+                return Ok(Command::Help(Some(args[0].to_string())));
+            }
             "mprev" | "month-prev" => return Ok(Command::MonthPrev),
             "mnext" | "month-next" => return Ok(Command::MonthNext),
             "q" | "quit" => return Ok(Command::Quit),
+            "w" | "write" => return Ok(Command::Write),
             "" => return Ok(Command::Blank),
             s => return Err(CommandLineError::InvalidCommand(s.into())),
         }
diff --git a/src/habit/bit.rs b/src/habit/bit.rs
index 8fa14c2..2bbb0ac 100644
--- a/src/habit/bit.rs
+++ b/src/habit/bit.rs
@@ -18,9 +18,9 @@ impl fmt::Display for CustomBool {
             f,
             "{:^3}",
             if self.0 {
-                CONFIGURATION.true_chr
+                CONFIGURATION.look.true_chr
             } else {
-                CONFIGURATION.false_chr
+                CONFIGURATION.look.false_chr
             }
         )
     }
diff --git a/src/main.rs b/src/main.rs
index 14ddf03..5280b35 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,7 +12,13 @@ use crate::command::{open_command_window, Command};
 use crate::utils::{load_configuration_file, AppConfig};
 
 use clap::{App as ClapApp, Arg};
+
+#[cfg(any(feature = "termion-backend", feature = "default"))]
 use cursive::termion;
+
+#[cfg(feature = "crossterm-backend")]
+use cursive::crossterm;
+
 use cursive::views::{LinearLayout, NamedView};
 use lazy_static::lazy_static;
 
@@ -33,6 +39,14 @@ fn main() {
                 .value_name("CMD")
                 .help("run a dijo command"),
         )
+        .arg(
+            Arg::with_name("list")
+                .short("l")
+                .long("list")
+                .takes_value(false)
+                .help("list dijo habits")
+                .conflicts_with("command"),
+        )
         .get_matches();
     if let Some(c) = matches.value_of("command") {
         let command = Command::from_string(c);
@@ -49,8 +63,17 @@ fn main() {
                 "Commands other than `track-up` and `track-down` are currently not supported!"
             ),
         }
+    } else if matches.is_present("list") {
+        for h in App::load_state().list_habits() {
+            println!("{}", h);
+        }
     } else {
+        #[cfg(any(feature = "termion-backend", feature = "default"))]
         let mut s = termion().unwrap();
+
+        #[cfg(feature = "crossterm-backend")]
+        let mut s = crossterm().unwrap();
+
         let app = App::load_state();
         let layout = NamedView::new(
             "Frame",
diff --git a/src/theme.rs b/src/theme.rs
index 4194777..1d2cc36 100644
--- a/src/theme.rs
+++ b/src/theme.rs
@@ -1,18 +1,18 @@
 use cursive::theme::Color::*;
 use cursive::theme::PaletteColor::*;
-use cursive::theme::{BaseColor, BorderStyle, Palette, Theme};
+use cursive::theme::{BorderStyle, Palette, Theme};
 
 pub fn pallete_gen() -> Palette {
     let mut p = Palette::default();
-    p[Background] = Dark(BaseColor::Black);
-    p[Shadow] = Light(BaseColor::Black);
-    p[View] = Dark(BaseColor::Black);
-    p[Primary] = Dark(BaseColor::White);
-    p[Secondary] = Dark(BaseColor::Black);
-    p[Tertiary] = Dark(BaseColor::Green);
-    p[TitlePrimary] = Light(BaseColor::White);
-    p[Highlight] = Dark(BaseColor::Red);
-    p[HighlightInactive] = Dark(BaseColor::Black);
+    p[Background] = TerminalDefault;
+    p[Shadow] = TerminalDefault;
+    p[View] = TerminalDefault;
+    p[Primary] = TerminalDefault;
+    p[Secondary] = TerminalDefault;
+    p[Tertiary] = TerminalDefault;
+    p[TitlePrimary] = TerminalDefault;
+    p[Highlight] = TerminalDefault;
+    p[HighlightInactive] = TerminalDefault;
 
     return p;
 }
diff --git a/src/utils.rs b/src/utils.rs
index e6ec6ac..2453aa6 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,37 +1,117 @@
 use cursive::theme::{BaseColor, Color};
 use directories::ProjectDirs;
-use std::fs;
+use serde::{Deserialize, Serialize};
+
+use std;
+use std::default::Default;
+use std::fs::{self, File, OpenOptions};
+use std::io::{Read, Write};
 use std::path::PathBuf;
 
-pub struct AppConfig {
+pub const VIEW_WIDTH: usize = 25;
+pub const VIEW_HEIGHT: usize = 8;
+pub const GRID_WIDTH: usize = 3;
+
+#[derive(Serialize, Deserialize)]
+pub struct Characters {
+    #[serde(default = "base_char")]
     pub true_chr: char,
+    #[serde(default = "base_char")]
     pub false_chr: char,
+    #[serde(default = "base_char")]
     pub future_chr: char,
+}
 
-    // view dimensions
-    pub view_width: usize,
-    pub view_height: usize,
+fn base_char() -> char {
+    '·'
+}
 
-    // app dimensions
-    pub grid_width: usize,
+impl Default for Characters {
+    fn default() -> Self {
+        Characters {
+            true_chr: '·',
+            false_chr: '·',
+            future_chr: '·',
+        }
+    }
+}
 
-    pub reached_color: Color,
-    pub todo_color: Color,
-    pub future_color: Color,
+#[derive(Serialize, Deserialize)]
+pub struct Colors {
+    #[serde(default = "cyan")]
+    pub reached: String,
+    #[serde(default = "magenta")]
+    pub todo: String,
+    #[serde(default = "light_black")]
+    pub inactive: String,
+}
+
+fn cyan() -> String {
+    "cyan".into()
+}
+fn magenta() -> String {
+    "magenta".into()
+}
+fn light_black() -> String {
+    "light black".into()
+}
+
+impl Default for Colors {
+    fn default() -> Self {
+        Colors {
+            reached: cyan(),
+            todo: magenta(),
+            inactive: light_black(),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct AppConfig {
+    #[serde(default)]
+    pub look: Characters,
+
+    #[serde(default)]
+    pub colors: Colors,
+}
+
+impl Default for AppConfig {
+    fn default() -> Self {
+        AppConfig {
+            look: Default::default(),
+            colors: Default::default(),
+        }
+    }
+}
+
+impl AppConfig {
+    // TODO: implement string parsing from config.json
+    pub fn reached_color(&self) -> Color {
+        return Color::parse(&self.colors.reached).unwrap_or(Color::Dark(BaseColor::Cyan));
+    }
+    pub fn todo_color(&self) -> Color {
+        return Color::parse(&self.colors.todo).unwrap_or(Color::Dark(BaseColor::Magenta));
+    }
+    pub fn inactive_color(&self) -> Color {
+        return Color::parse(&self.colors.inactive).unwrap_or(Color::Light(BaseColor::Black));
+    }
 }
 
 pub fn load_configuration_file() -> AppConfig {
-    return AppConfig {
-        true_chr: '·',
-        false_chr: '·',
-        future_chr: '·',
-        view_width: 25,
-        view_height: 8,
-        grid_width: 3,
-        reached_color: Color::Dark(BaseColor::Cyan),
-        todo_color: Color::Dark(BaseColor::Magenta),
-        future_color: Color::Light(BaseColor::Black),
-    };
+    let cf = config_file();
+    if let Ok(ref mut f) = File::open(&cf) {
+        let mut j = String::new();
+        f.read_to_string(&mut j);
+        return toml::from_str(&j).unwrap();
+    } else {
+        if let Ok(dc) = toml::to_string(&AppConfig::default()) {
+            match OpenOptions::new().create(true).write(true).open(&cf) {
+                Ok(ref mut file) => file.write(dc.as_bytes()).unwrap(),
+                Err(_) => 0,
+            };
+        }
+        return Default::default();
+    }
 }
 
 fn project_dirs() -> ProjectDirs {
@@ -39,6 +119,14 @@ fn project_dirs() -> ProjectDirs {
         .unwrap_or_else(|| panic!("Invalid home directory!"))
 }
 
+pub fn config_file() -> PathBuf {
+    let proj_dirs = project_dirs();
+    let mut data_file = PathBuf::from(proj_dirs.config_dir());
+    fs::create_dir_all(&data_file);
+    data_file.push("config.toml");
+    return data_file;
+}
+
 pub fn habit_file() -> PathBuf {
     let proj_dirs = project_dirs();
     let mut data_file = PathBuf::from(proj_dirs.data_dir());
diff --git a/src/views.rs b/src/views.rs
index 24c8a4d..efd1391 100644
--- a/src/views.rs
+++ b/src/views.rs
@@ -8,6 +8,7 @@ use chrono::prelude::*;
 use chrono::{Duration, Local, NaiveDate};
 
 use crate::habit::{Bit, Count, Habit, TrackEvent, ViewMode};
+use crate::utils::VIEW_WIDTH;
 
 use crate::CONFIGURATION;
 
@@ -36,14 +37,14 @@ where
         let year = now.year();
         let month = now.month();
 
-        let goal_reached_style = Style::from(CONFIGURATION.reached_color);
-        let todo_style = Style::from(CONFIGURATION.todo_color);
-        let future_style = Style::from(CONFIGURATION.future_color);
+        let goal_reached_style = Style::from(CONFIGURATION.reached_color());
+        let todo_style = Style::from(CONFIGURATION.todo_color());
+        let future_style = Style::from(CONFIGURATION.inactive_color());
 
         let strikethrough = Style::from(Effect::Strikethrough);
 
         let goal_status =
-            self.view_month_offset() == 0 && self.reached_goal(Local::now().naive_utc().date());
+            self.view_month_offset() == 0 && self.reached_goal(Local::now().naive_local().date());
 
         printer.with_style(
             Style::merge(&[
@@ -61,11 +62,7 @@ where
             |p| {
                 p.print(
                     (0, 0),
-                    &format!(
-                        " {:.width$} ",
-                        self.name(),
-                        width = CONFIGURATION.view_width - 6
-                    ),
+                    &format!(" {:.width$} ", self.name(), width = VIEW_WIDTH - 6),
                 );
             },
         );
@@ -77,12 +74,20 @@ where
                 .collect::<Vec<_>>();
             for (week, line_nr) in days.chunks(7).zip(2..) {
                 let weekly_goal = self.goal() * week.len() as u32;
-                let is_this_week = week.contains(&Local::now().naive_utc().date());
+                let is_this_week = week.contains(&Local::now().naive_local().date());
                 let remaining = week.iter().map(|&i| self.remaining(i)).sum::<u32>();
                 let completions = weekly_goal - remaining;
-                let full = CONFIGURATION.view_width - 8;
-                let bars_to_fill = if weekly_goal > 0 {(completions * full as u32) / weekly_goal} else {0};
-                let percentage = if weekly_goal > 0 {(completions as f64 * 100.) / weekly_goal as f64} else {0.0};
+                let full = VIEW_WIDTH - 8;
+                let bars_to_fill = if weekly_goal > 0 {
+                    (completions * full as u32) / weekly_goal
+                } else {
+                    0
+                };
+                let percentage = if weekly_goal > 0 {
+                    (completions as f64 * 100.) / weekly_goal as f64
+                } else {
+                    0.0
+                };
                 printer.with_style(future_style, |p| {
                     p.print((4, line_nr), &"─".repeat(full));
                 });
@@ -118,7 +123,7 @@ where
                     });
                 } else {
                     printer.with_style(future_style, |p| {
-                        p.print(coords, &format!("{:^3}", CONFIGURATION.future_chr));
+                        p.print(coords, &format!("{:^3}", CONFIGURATION.look.future_chr));
                     });
                 }
                 i += 1;
@@ -141,7 +146,7 @@ where
     }
 
     fn on_event(&mut self, e: Event) -> EventResult {
-        let now = Local::now().naive_utc().date();
+        let now = Local::now().naive_local().date();
         if self.is_auto() {
             return EventResult::Ignored;
         }