8 files changed, 168 insertions, 45 deletions

diff --git a/src/app/impl_self.rs b/src/app/impl_self.rs
index 744f906..a806dc5 100644
--- a/src/app/impl_self.rs
+++ b/src/app/impl_self.rs
@@ -37,6 +37,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);
@@ -118,13 +122,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),)
@@ -207,12 +211,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 +240,30 @@ 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",
+                                "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..0dfd20b 100644
--- a/src/app/impl_view.rs
+++ b/src/app/impl_view.rs
@@ -102,25 +102,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..38d48e9 100644
--- a/src/command.rs
+++ b/src/command.rs
@@ -1,21 +1,75 @@
 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};
 
+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();
+    eprintln!("{:?}| {:?}", prefix, first_match);
+    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);
+                eprintln!("{:?} | {:?}", completion, contents);
+                if let Some(c) = completion {
+                    let cb =
+                        view.set_content(format!("{}", contents) + c.strip_prefix(word).unwrap());
+                    return Some(EventResult::Consumed(Some(cb)));
+                };
+                return None;
+            }
+        },
+    )
+    .fixed_width(CONFIGURATION.view_width * CONFIGURATION.grid_width);
     s.call_on_name("Frame", |view: &mut LinearLayout| {
         let mut commandline = LinearLayout::horizontal()
             .child(TextView::new(":"))
@@ -59,15 +113,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 +190,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 3386182..8fa14c2 100644
--- a/src/habit/bit.rs
+++ b/src/habit/bit.rs
@@ -100,11 +100,22 @@ impl Habit for Bit {
     fn goal(&self) -> u32 {
         return 1;
     }
-    fn modify(&mut self, date: NaiveDate, _: TrackEvent) {
+    fn modify(&mut self, date: NaiveDate, event: TrackEvent) {
         if let Some(val) = self.stats.get_mut(&date) {
-            *val = (val.0 ^ true).into();
+            match event {
+                TrackEvent::Increment => *val = (val.0 ^ true).into(),
+                TrackEvent::Decrement => {
+                    if val.0 {
+                        *val = false.into();
+                    } else {
+                        self.stats.remove(&date);
+                    }
+                }
+            }
         } else {
-            self.insert_entry(date, CustomBool(true));
+            if event == TrackEvent::Increment {
+                self.insert_entry(date, CustomBool(true));
+            }
         }
     }
     fn set_view_month_offset(&mut self, offset: u32) {
diff --git a/src/habit/count.rs b/src/habit/count.rs
index 1bdf920..d351758 100644
--- a/src/habit/count.rs
+++ b/src/habit/count.rs
@@ -84,12 +84,15 @@ impl Habit for Count {
                     if *val > 0 {
                         *val -= 1
                     } else {
-                        *val = 0
+                        self.stats.remove(&date);
                     };
                 }
             }
         } else {
-            self.insert_entry(date, 1);
+            match event {
+                TrackEvent::Increment => self.insert_entry(date, 1),
+                _ => {}
+            };
         }
     }
     fn set_view_month_offset(&mut self, offset: u32) {
diff --git a/src/habit/prelude.rs b/src/habit/prelude.rs
index 19b00a7..8335d6c 100644
--- a/src/habit/prelude.rs
+++ b/src/habit/prelude.rs
@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 use std::default;
 use std::fmt;
 
+#[derive(Debug, PartialEq)]
 pub enum TrackEvent {
     Increment,
     Decrement,
diff --git a/src/main.rs b/src/main.rs
index fb16aaa..dec3156 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(target_os = "linux")]
+use cursive::termion;
+
+#[cfg(target_os = "windows")]
 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(target_os = "windows")]
         let mut s = crossterm().unwrap();
+
+        #[cfg(target_os = "linux")]
+        let mut s = termion().unwrap();
+
         let app = App::load_state();
         let layout = NamedView::new(
             "Frame",
diff --git a/src/views.rs b/src/views.rs
index 24c8a4d..da077ac 100644
--- a/src/views.rs
+++ b/src/views.rs
@@ -43,7 +43,7 @@ where
         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(&[
@@ -77,12 +77,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 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));
                 });
@@ -141,7 +149,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;
         }