app.go

package todolist

import (
	"fmt"
	"os"
	"regexp"
	"sort"
	"strconv"
	"strings"
)

type App struct {
	TodoStore Store
	Printer   Printer
	TodoList  *TodoList
}

func NewApp() *App {
	var printer Printer
	if os.Getenv("TODO_FORMAT") != "" {
		printer = NewFormatPrinter(os.Getenv("TODO_FORMAT"), os.Stdout)
	} else {
		printer = NewScreenPrinter()
	}
	app := &App{
		TodoList:  &TodoList{},
		Printer:   printer,
		TodoStore: NewFileStore(),
	}
	return app
}

// Removes the extraneous first part of the input
func shift(input string, regex string) string {
	r, _ := regexp.Compile(regex)
	return r.ReplaceAllString(input, "")
}

func (a *App) InitializeRepo() {
	a.TodoStore.Initialize()
}

func (a *App) AddTodo(input string) {
	a.Load()

	input = shift(input, `^(add|a)(\s*|)`)
	if input == "" {
		return
	}

	parser := &Parser{}
	todo := parser.ParseNewTodo(input)
	if todo == nil {
		fmt.Println("I need more information. Try something like 'todo a chat with @bob due tom'")
		return
	}

	id := a.TodoList.NextId()
	a.TodoList.Add(todo)
	a.Save()
	fmt.Printf("Todo %d added.\n", id)
}

func (a *App) AddPromise(input string) {
	a.Load()

	input = shift(input, `^(promise)(\s*|)`)
	if input == "" {
		return
	}

	parser := &Parser{}
	todo := parser.ParseNewTodo(input)
	if todo == nil {
		fmt.Println("I need more information. Try something like 'todo a chat with @bob due tom'")
		return
	}

	if todo.CalculateDueTime().Year() == 1900 {
		fmt.Println("Promises must have a due date ")
		return
	}

	if todo.Contexts == nil || len(todo.Contexts) == 0 {
		fmt.Println("Promises must be made to someone")
		return
	}

	todo.Type = PromiseType

	id := a.TodoList.NextId()
	a.TodoList.Add(todo)
	a.Save()
	fmt.Printf("Promise %d added.\n", id)
}

// AddDoneTodo Adds a todo and immediately completed it.
func (a *App) AddJournal(input string) {
	a.Load()

	input = shift(input, `^(j|journal)(\s*|)`)
	if input == "" {
		return
	}

	parser := &Parser{}
	todo := parser.ParseNewTodo(input)
	if todo == nil {
		fmt.Println("I need more information. Try something like 'todo done chating with @bob'")
		return
	}

	if todo.CalculateDueTime().Year() != 1900 {
		fmt.Println("Journal entries can not have a due date")
		return
	}

	todo.Type = JournalType

	id := a.TodoList.NextId()
	a.TodoList.Add(todo)
	a.TodoList.Complete(id)
	a.Save()
	fmt.Printf("Journal %d added.\n", id)
}

// AddDoneTodo Adds a todo and immediately completed it.
func (a *App) AddDoneTodo(input string) {
	a.Load()

	input = shift(input, `^(done)(\s*|)`)
	if input == "" {
		return
	}

	parser := &Parser{}
	todo := parser.ParseNewTodo(input)
	if todo == nil {
		fmt.Println("I need more information. Try something like 'todo done chating with @bob'")
		return
	}

	id := a.TodoList.NextId()
	a.TodoList.Add(todo)
	a.TodoList.Complete(id)
	a.Save()
	fmt.Printf("Completed Todo %d added.\n", id)
}

func (a *App) DeleteTodo(input string) {
	a.Load()

	input = shift(input, `^(d|delete)(\s*|)`)
	if input == "" {
		return
	}

	ids := a.getIds(input)
	if len(ids) == 0 {
		return
	}
	a.TodoList.Delete(ids...)
	a.Save()
	fmt.Printf("%s deleted.\n", pluralize(len(ids), "Todo", "Todos"))
}

func (a *App) CompleteTodo(input string) {
	a.Load()

	input = shift(input, `^(c|complete)(\s*|)`)
	if input == "" {
		return
	}

	ids := a.getIds(input)
	if len(ids) == 0 {
		return
	}
	a.TodoList.Complete(ids...)
	a.Save()
	fmt.Println("Todo completed.")
}

func (a *App) UncompleteTodo(input string) {
	a.Load()

	input = shift(input, `^(uc|uncomplete)(\s*|)`)
	if input == "" {
		return
	}

	ids := a.getIds(input)
	if len(ids) == 0 {
		return
	}
	a.TodoList.Uncomplete(ids...)
	a.Save()
	fmt.Println("Todo uncompleted.")
}

func (a *App) ArchiveTodo(input string) {
	a.Load()

	input = shift(input, `^(ar|archive)(\s*|)`)
	if input == "" {
		return
	}

	ids := a.getIds(input)
	if len(ids) == 0 {
		return
	}
	a.TodoList.Archive(ids...)
	a.Save()
	fmt.Println("Todo archived.")
}

func (a *App) UnarchiveTodo(input string) {
	a.Load()

	input = shift(input, `^(uar|unarchive)(\s*|)`)
	if input == "" {
		return
	}

	ids := a.getIds(input)
	if len(ids) == 0 {
		return
	}
	a.TodoList.Unarchive(ids...)
	a.Save()
	fmt.Println("Todo unarchived.")
}

func (a *App) EditTodo(input string) {
	a.Load()
	id := a.getId(input)
	if id == -1 {
		return
	}
	todo := a.TodoList.FindById(id)
	if todo == nil {
		fmt.Println("No such id.")
		return
	}
	parser := &Parser{}

	if parser.ParseEditTodo(todo, input) {
		a.Save()
		fmt.Println("Todo updated.")
	}
}

func (a *App) ExpandTodo(input string) {
	a.Load()
	id := a.getId(input)
	parser := &Parser{}
	if id == -1 {
		return
	}

	commonProject := parser.ExpandProject(input)
	todos := strings.LastIndex(input, ":")
	if commonProject == "" || len(input) <= todos+1 || todos == -1 {
		fmt.Println("I'm expecting a format like \"todolist ex <project>: <todo1>, <todo2>, ...\"")
		return
	}

	newTodos := strings.Split(input[todos+1:], ",")

	for _, todo := range newTodos {
		args := []string{"add ", commonProject, " ", todo}
		a.AddTodo(strings.Join(args, ""))
	}

	a.TodoList.Delete(id)
	a.Save()
	fmt.Println("Todo expanded.")
}

func (a *App) HandleNotes(input string) {
	a.Load()
	id := a.getId(input)
	if id == -1 {
		return
	}
	todo := a.TodoList.FindById(id)
	if todo == nil {
		fmt.Println("No such id.")
		return
	}
	parser := &Parser{}

	if parser.ParseAddNote(todo, input) {
		fmt.Println("Note added.")
	} else if parser.ParseDeleteNote(todo, input) {
		fmt.Println("Note deleted.")
	} else if parser.ParseEditNote(todo, input) {
		fmt.Println("Note edited.")
	} else if parser.ParseLinkNote(todo, input) {
		fmt.Println("Note linked.")
	} else if parser.ParseShowNote(todo, input) {
		groups := map[string][]*Todo{}
		groups[""] = append(groups[""], todo)
		a.Printer.Print(&GroupedTodos{Groups: groups}, true)
		return
	}
	a.Save()
}

func (a *App) ArchiveCompleted() {
	a.Load()
	count := 0
	for _, todo := range a.TodoList.Todos() {
		if todo.Completed && todo.Type != JournalType {
			todo.Archive()
			count = count + 1
		}
	}
	a.Save()
	fmt.Printf("%d completed todos have been archived.\n", count)
}

func (a *App) ExpireCountDown() {
	a.Load()
	count := 0
	for _, todo := range a.TodoList.Todos() {
		todo.ExpireCountDown()
		if todo.Expired() && !todo.Archived {
			todo.Archive()
			count++
		}
	}
	a.Save()
	fmt.Printf("%d todos have expired and archived.\n", count)
}

type CreateDateSorter struct {
	Todos []*Todo
}

// Len is the number of elements in the collection.
func (j *CreateDateSorter) Len() int {
	return len(j.Todos)
}

// Less reports whether the element with
// index a should sort before the element with index b.
func (j *CreateDateSorter) Less(a int, b int) bool {
	return j.Todos[a].CalculateCreateDate().Before(j.Todos[b].CalculateCreateDate())
}

// Swap swaps the elements with indexes a and b.
func (j *CreateDateSorter) Swap(a int, b int) {
	j.Todos[a], j.Todos[b] = j.Todos[b], j.Todos[a]
}

type DueDateSorter struct {
	Todos []*Todo
}

// Len is the number of elements in the collection.
func (j *DueDateSorter) Len() int {
	return len(j.Todos)
}

// Less reports whether the element with
// index a should sort before the element with index b.
func (j *DueDateSorter) Less(a int, b int) bool {
	return j.Todos[a].CalculateDueTime().Before(j.Todos[b].CalculateDueTime())
}

// Swap swaps the elements with indexes a and b.
func (j *DueDateSorter) Swap(a int, b int) {
	j.Todos[a], j.Todos[b] = j.Todos[b], j.Todos[a]
}

func sortAndTruncateJournals(todos []*Todo) []*Todo {
	maxJournalEntriesToShow := 6
	ret := make([]*Todo, 0, maxJournalEntriesToShow)
	sorter := &CreateDateSorter{todos}
	sort.Sort(sorter)
	start := len(todos) - maxJournalEntriesToShow
	if start < 0 {
		start = 0
	}
	for i := start; i < len(todos); i++ {
		ret = append(ret, todos[i])
	}
	return ret
}

func (a *App) ListTodos(input string) {
	a.Load()
	filteredTodos := NewFilter(a.TodoList.Todos(), TodoTypes).Filter(input)
	grouped := a.getGroups(input, filteredTodos)

	noJournal := os.Getenv("TODOLIST_NO_JOURNAL")
	if noJournal == "" {
		filteredJournals := NewFilter(a.TodoList.Todos(), JournalType).Filter("")
		if len(filteredJournals) > 0 {
			grouped.Groups["{journal}"] = sortAndTruncateJournals(filteredJournals)
		}
	}

	// Show only incomplete promises by default
	filteredPromises := NewFilter(a.TodoList.Todos(), PromiseType).FilterPromise(input)
	if len(filteredPromises) > 0 {
		grouped.Groups["{promises}"] = filteredPromises
	}

	grouped.Precedence = []string{"{promises}", "{journal}"}

	a.Printer.Print(grouped, false)
}

func (a *App) PrioritizeTodo(input string) {
	a.Load()

	input = shift(input, `^(p|prioritize)(\s*|)`)
	if input == "" {
		return
	}

	ids := a.getIds(input)
	if len(ids) == 0 {
		return
	}
	a.TodoList.Prioritize(ids...)
	a.Save()
	fmt.Println("Todo prioritized.")
}

func (a *App) UnprioritizeTodo(input string) {
	a.Load()

	input = shift(input, `^(up|unprioritize)(\s*|)`)
	if input == "" {
		return
	}

	ids := a.getIds(input)
	if len(ids) == 0 {
		return
	}
	a.TodoList.Unprioritize(ids...)
	a.Save()
	fmt.Println("Todo un-prioritized.")
}

func (a *App) getId(input string) int {
	re, _ := regexp.Compile("\\d+")
	if re.MatchString(input) {
		id, _ := strconv.Atoi(re.FindString(input))
		return id
	}

	fmt.Println("Invalid id.")
	return -1
}

func (a *App) getIds(input string) (ids []int) {

	// NOTE: this used to be split on commas but I'm not a fan
	// It's a command line program, each one should be an argument
	idGroups := strings.Split(input, " ")
	for _, idGroup := range idGroups {
		if rangedIds, err := a.parseRangedIds(idGroup); len(rangedIds) > 0 || err != nil {
			if err != nil {
				fmt.Printf("Invalid id group: %s.\n", input)
				continue
			}
			ids = append(ids, rangedIds...)
		} else if id := a.getId(idGroup); id != -1 {
			ids = append(ids, id)
		} else {
			fmt.Printf("Invalid id: %s.\n", idGroup)
		}
	}
	return ids
}

func (a *App) parseRangedIds(input string) (ids []int, err error) {
	rangeNumberRE, _ := regexp.Compile("(\\d+)-(\\d+)")
	if matches := rangeNumberRE.FindStringSubmatch(input); len(matches) > 0 {
		lowerID, _ := strconv.Atoi(matches[1])
		upperID, _ := strconv.Atoi(matches[2])
		if lowerID >= upperID {
			return ids, fmt.Errorf("Invalid id group: %s.\n", input)
		}
		for id := lowerID; id <= upperID; id++ {
			ids = append(ids, id)
		}
	}
	return ids, err
}

func (a *App) getGroups(input string, todos []*Todo) *GroupedTodos {
	grouper := &Grouper{}
	contextRegex, _ := regexp.Compile(`by c.*$`)
	projectRegex, _ := regexp.Compile(`by p.*$`)

	var grouped *GroupedTodos

	if contextRegex.MatchString(input) {
		grouped = grouper.GroupByContext(todos)
	} else if projectRegex.MatchString(input) {
		grouped = grouper.GroupByProject(todos)
	} else {
		grouped = grouper.GroupByNothing(todos)
	}
	return grouped
}

func (a *App) GarbageCollect() {
	a.Load()
	a.TodoList.GarbageCollect()
	a.Save()
	fmt.Println("Garbage collection complete.")
}

func (a *App) Load() error {
	todos, err := a.TodoStore.Load()
	if err != nil {
		return err
	}
	a.TodoList.Load(todos)
	return nil
}

func (a *App) Save() {
	a.TodoStore.Save(a.TodoList.Data)
}