package main

import (
	"fmt"
	"os"
	"sort"
	"strings"
	"time"

	"git.bullercodeworks.com/brian/gime-lib"
	userConfig "github.com/br0xen/user-config"
)

const (
	AppName       = "gime"
	AppVersion    = 1
	DefDBName     = "gime.db"
	DefArchDBName = "gimearch.db"
)

var validOperations map[string][]string
var opFuncs map[string]func([]string) int
var timeEntries *gime.TimeEntryCollection
var gdb *gime.GimeDB
var cfg *userConfig.Config

var fuzzyFormats []string

func main() {
	var ret int
	initialize()
	var parms []string

	if len(os.Args) > 1 {
		parms = os.Args[1:]
		parms[0] = matchParameter(parms[0])
	} else {
		// If no parameters were passed, just print the status
		parms = append(parms, "status")
	}

	if fn, ok := opFuncs[parms[0]]; ok {
		ret = fn(parms[1:])
	} else {
		fmt.Println("Unknown command")
		ret = 1
	}
	os.Exit(ret)
}

func loadActiveTimeEntries() {
	timeEntries = gdb.LoadTimeEntryCollection(gime.TypeCurrent)
}

func loadActiveAndRecentTimeEntries() {
	timeEntries = gdb.LoadTimeEntryCollection(gime.TypeNoArchive)
}

func getMostRecentTimeEntry() (*gime.TimeEntry, error) {
	return gdb.GetLatestTimeEntry()
}

func cmdDoArchive(args []string) int {
	if len(args) == 0 {
		fmt.Println("Nothing to do")
		return 1
	}
	bef, err := parseFuzzyTime(args[0])
	if err != nil {
		fmt.Println("Error parsing time")
		return 1
	}
	ret := 0
	fmt.Print("Archive all timers before ", bef)
	loadActiveAndRecentTimeEntries()
	for i := 0; i < timeEntries.Length(); i++ {
		tst := timeEntries.Get(i)
		if tst.GetEnd().Before(bef) {
			fmt.Print(".")
			if err = gdb.ArchiveTimeEntry(tst.GetUUID()); err != nil {
				fmt.Print("Error archiving entry (", tst.GetUUID(), ")", err.Error())
				ret = 1
			}
		}
	}
	fmt.Println("Done")
	return ret
}

func cmdDoConfig(args []string) int {
	if len(args) == 0 {
		fmt.Println("Invalid configuration options passed")
		return 1
	}

	for _, opt := range args {
		if !strings.Contains(opt, "=") {
			// Single word triggers
			switch opt {
			case "reset":
				fmt.Println("Resetting Configuration...")
				cfg.Set("dbdir", cfg.GetConfigPath()+"/")
				cfg.Set("dbname", DefDBName)
				cfg.Set("dbarchname", DefArchDBName)
			case "list":
				fmt.Println("Current " + AppName + " config")
				for _, v := range cfg.GetKeyList() {
					fmt.Println("  " + v + ": " + cfg.Get(v))
				}
			case "dbpath":
				fmt.Println(cfg.Get("dbdir") + cfg.Get("dbname"))
			}
		} else {
			// Key=Value options
			pts := strings.Split(opt, "=")
			if len(pts) == 2 {
				switch pts[0] {
				case "dbdir":
					val := pts[1]
					if val[len(val)-1] != '/' {
						val = val + "/"
					}
					cfg.Set("dbdir", val)
				case "dbname":
					cfg.Set("dbname", pts[1])
				case "dbarchname":
					cfg.Set("dbarchname", pts[1])
				}
			}
		}
	}
	return 0
}

func cmdPrintDetail(args []string) int {
	fmt.Println("Not implemented yet.")
	return 1
}

func cmdPrintHelp(args []string) int {
	if len(args) == 0 {
		fmt.Println("gime - A simple timekeeping application\n")
		fmt.Println("Usage: gime [@timerID] [operation] [tags...]")
		for _, v := range validOperations {
			for vi := range v {
				fmt.Println("  ", v[vi])
			}
			fmt.Println("")
		}
	} else {
		switch args[0] {
		case "formats":
			fmt.Println("Supported date/time formats:")
			for i := range fuzzyFormats {
				fmt.Println(" ", fuzzyFormats[i])
			}
		}
		fmt.Println("")
	}
	return 0
}

func cmdPrintList(args []string) int {
	loadActiveAndRecentTimeEntries()

	useDefaultFilter := true

	var beg, end time.Time
	searchTags := []string{}

	for _, opt := range args {
		var tmpBeg, tmpEnd time.Time

		// Do our best to figure out what timers the user wants to list
		var err error
		if strings.Contains(opt, "@ids") {
			// Print timer ids
		} else if strings.Contains(opt, "-") {
			useDefaultFilter = false
			pts := strings.Split(opt, "-")
			if len(pts[0]) > 0 {
				// This should be the starting date
				tmpBeg, err = parseFuzzyTime(pts[0])
				if err != nil {
					// We couldn't parse it as a time,
					// Probably this is just a tag
					searchTags = append(searchTags, opt)
					continue
				}
			}
			if len(pts[1]) > 0 {
				// This should be the ending date
				tmpEnd, err = parseFuzzyTime(pts[1])
				if err != nil {
					searchTags = append(searchTags, opt)
					continue
				}
			}
		} else {
			// Tag filters
			searchTags = append(searchTags, opt)
		}
		if !tmpBeg.IsZero() || !tmpEnd.IsZero() {
			beg, end = tmpBeg, tmpEnd
		}
	}
	if end.IsZero() {
		end = time.Now()
	}

	// By default, list all entries ending today or still running
	defaultFilter := func(t *gime.TimeEntry) bool {
		return t.EndsToday() || t.IsRunning()
	}

	timeSpanFilter := func(t *gime.TimeEntry) bool {
		return t.GetStart().After(beg) && t.GetEnd().Before(end)
	}
	tagFilter := func(t *gime.TimeEntry) bool {
		for i := range searchTags {
			if !t.HasTag(searchTags[i]) {
				return false
			}
		}
		return true
	}

	compoundFilter := func(t *gime.TimeEntry) bool {
		// If we didn't get any other filter specifications, just use the default
		if useDefaultFilter {
			return defaultFilter(t)
		}
		// Otherwise we want to filter timespan and tags
		return timeSpanFilter(t) && tagFilter(t)
	}

	fmt.Println(time.Now().Format("2006/01/02"))
	str := TimerCollectionToString(filterTimerCollection(timeEntries, compoundFilter))
	str = "  " + strings.Replace(str, "\n", "\n  ", -1)
	fmt.Println(str)
	return 0
}

func cmdListTags(args []string) int {
	loadActiveAndRecentTimeEntries()
	var allTags []string
	for i := 0; i < timeEntries.Length(); i++ {
		tc := timeEntries.Get(i).GetTags()
		for j := 0; j < tc.Length(); j++ {
			tg := tc.Get(j)
			var found bool
			for tst := range allTags {
				if allTags[tst] == tg {
					found = true
					break
				}
			}
			if !found {
				allTags = append(allTags, tg)
			}
		}
	}

	sort.Sort(sort.StringSlice(allTags))
	for i := range allTags {
		fmt.Println(allTags[i])
	}
	return 0
}

func cmdPrintStatus(args []string) int {
	loadActiveTimeEntries()
	curr := time.Now()
	fmt.Println("Current Time:", curr.Format(time.Stamp))
	if timeEntries.Length() == 0 {
		fmt.Println("No timer running")
	} else {
		fmt.Print("Active Timers (", timeEntries.Length(), ")\n")
		// Find the longest start time & longest duration
		short := true
		for i := 0; i < timeEntries.Length(); i++ {
			v := timeEntries.Get(i)
			if v.GetStart().Day() != curr.Day() {
				short = false
				break
			}
		}

		for i := 0; i < timeEntries.Length(); i++ {
			v := timeEntries.Get(i)
			if short {
				fmt.Printf("  @%d %s\n", i, TimerDetailToString(v))
			} else {
				fmt.Printf("  @%d %s\n", i, TimerDetailToLongString(v))
			}
		}
	}
	return 0
}

func cmdDoFuzzyParse(args []string) int {
	if len(args) == 0 {
		return 1
	}
	var t time.Time
	var err error
	if t, err = parseFuzzyTime(args[0]); err != nil {
		fmt.Println(err.Error())
		return 1
	}
	fmt.Println(t.Format(time.RFC3339))
	return 0
}

func initialize() {
	var err error
	validOperations = make(map[string][]string)
	opFuncs = make(map[string]func([]string) int)

	opFuncs["cont"] = cmdContinueTimer
	validOperations["cont"] = []string{
		"cont [time]             - Continue the last stopped timer",
	}

	opFuncs["config"] = cmdDoConfig
	validOperations["config"] = []string{
		"config [command]        - Perform configuration",
		"       list             - List current configuration",
		"       reset            - Reset current configuration",
		"       Configuration Options:",
		"         dbdir=[database directory]",
		"         dbname=[database filename]",
		"         dbarchname=[archive database filename]",
	}

	opFuncs["detail"] = cmdPrintDetail
	validOperations["detail"] = []string{
		"detail @id              - Print details about a timer",
	}

	opFuncs["delete"] = cmdDeleteTimer
	validOperations["delete"] = []string{
		"delete @id              - Delete a timer",
	}

	opFuncs["end"] = cmdStopTimer
	validOperations["end"] = []string{
		"end                     - The same as stop",
	}

	opFuncs["help"] = cmdPrintHelp
	validOperations["help"] = []string{
		"help                    - Print this",
	}

	opFuncs["list"] = cmdPrintList
	validOperations["list"] = []string{
		"list [duration] [+tags] - List time entries",
		"                          valid values of [duration] include:",
		"                            day   - List all entries for the current day",
		"                            week  - List all entries for the current week",
		"                            month - List all entries for the current month",
		"                            year  - List all entries for the current year",
		"                          To list entries by tag, preceed the tags with a +",
	}

	opFuncs["ls"] = cmdPrintList
	validOperations["ls"] = []string{
		"ls [duration] [+tags]   - The same as list",
	}

	opFuncs["remove"] = cmdDeleteTimer
	validOperations["remove"] = []string{
		"remove @id              - See 'delete'",
	}

	opFuncs["status"] = cmdPrintStatus
	validOperations["status"] = []string{
		"status                  - Print the status of all active timers",
	}

	opFuncs["start"] = cmdStartTimer
	validOperations["start"] = []string{
		"start [time] [tags ...] - Start a timer with the given tags (space separated)",
		"                          If the first sub-argument given looks like a time,",
		"                          the timer will be started then (past or future).",
		"                          If a timer is already running it'll be stopped",
	}

	opFuncs["stop"] = cmdStopTimer
	validOperations["stop"] = []string{
		"stop [time]             - Stops the current timer",
		"                          If the first sub-argument given looks like a time,",
		"                          the timer will be stopped then (past or future).",
	}

	opFuncs["switch"] = cmdSwitchTimer
	validOperations["switch"] = []string{
		"switch [tags ...]       - Stop all currently running timers and start a new",
		"                          one with the given tags",
	}

	opFuncs["archive"] = cmdDoArchive
	validOperations["archive"] = []string{
		"archive [date]          - Archive all entries older than the given date",
	}

	opFuncs["fuzzyparse"] = cmdDoFuzzyParse
	validOperations["fuzzyparse"] = []string{
		"fuzzyparse              - Parse the next argument as a date/time and print",
		"                          the RFC3339 result. (Basically for testing)",
	}

	opFuncs["tags"] = cmdListTags
	validOperations["tags"] = []string{
		"tags                    - List all tags that have been used in non-archived",
		"                          time entries",
	}

	// Load the Config
	cfg, err = userConfig.NewConfig(AppName)
	if err != nil {
		fmt.Println(err.Error())
		fmt.Println("Creating new config")
		cfg.Save()
	}
	// If dbdir isn't set, set it to the config directory
	if cfg.Get("dbdir") == "" {
		cfg.Set("dbdir", cfg.GetConfigPath()+"/")
	}
	// If dbname isn't set, set it to the default database filename
	if cfg.Get("dbname") == "" {
		cfg.Set("dbname", DefDBName)
	}
	// If dbarchivename isn't set, set it to the default archive database filename
	if cfg.Get("dbarchname") == "" {
		cfg.Set("dbarchname", DefArchDBName)
	}
	if gdb, err = gime.LoadDatabase(cfg.Get("dbdir"), cfg.Get("dbname"), cfg.Get("dbarchname")); err != nil {
		fmt.Println("Error loading the database")
		os.Exit(1)
	}

	fuzzyFormats = []string{
		"1504",
		"15:04", // Kitchen, 24hr
		time.Kitchen,
		time.RFC3339,
		"2006-01-02T15:04:05", // RFC3339 without timezone
		"2006-01-02T15:04",    // RFC3339 without seconds or timezone
		time.Stamp,
		"02 Jan 06 15:04:05", // RFC822 with second
		time.RFC822,
		"01/02/2006 15:04",    // U.S. Format
		"01/02/2006 15:04:05", // U.S. Format with seconds
		"01/02/06 15:04",      // U.S. Format, short year
		"01/02/06 15:04:05",   // U.S. Format, short year, with seconds
		"2006-01-02",
		"2006-01-02 15:04",
		"2006-01-02 15:04:05",
		"20060102",
		"20060102 15:04",
		"20060102 15:04:05",
		"20060102 1504",
		"20060102 150405",
		"20060102T15:04",
		"20060102T15:04:05",
		"20060102T1504",
		"20060102T150405",
	}
}

func matchParameter(in string) string {
	var chkParms []string
	for k := range validOperations {
		chkParms = append(chkParms, k)
	}
	var nextParms []string
	for i := range in {
		for _, p := range chkParms {
			if p[i] == in[i] {
				nextParms = append(nextParms, p)
			}
		}
		// If we get here and there is only one parameter left, return it
		chkParms = nextParms
		if len(nextParms) == 1 {
			break
		}
		// Otherwise, loop
		nextParms = []string{}
	}
	if len(chkParms) == 0 {
		return ""
	}
	return chkParms[0]
}