package main

import (
	"bufio"
	"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"
	DefRoundTo    = "1m0s"
)

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 roundTo time.Duration

var fuzzyFormats []string

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

	if len(os.Args) > 1 {
		parms = os.Args[1:]
	} 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 loadArchiveTimeEntries() {
	timeEntries = gdb.LoadTimeEntryCollection(gime.TypeArchive)
}

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

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("Are you sure you want to reset your configuration? (Y/[N])")
				reader := bufio.NewReader(os.Stdin)
				conf, _ := reader.ReadString('\n')
				conf = strings.TrimSpace(conf)
				if conf == "Y" {
					fmt.Println("Resetting Configuration...")
					cfg.Set("dbdir", cfg.GetConfigPath()+"/")
					cfg.Set("dbname", DefDBName)
					cfg.Set("dbarchname", DefArchDBName)
					cfg.Set("roundto", DefRoundTo)
				} else {
					fmt.Println("Done.")
				}
				return 0

			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])
				case "roundto":
					// Make sure that we can parse it
					durStr := pts[1]
					_, err := time.ParseDuration(durStr)
					if err != nil {
						fmt.Println("Unable to parse duration:", durStr)
						durStr = DefRoundTo
					}
					cfg.Set("roundto", durStr)
					fmt.Println("Rounding set to", durStr)
				}
			}
		}
	}
	return 0
}

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 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["add"] = cmdAddTimer
	validOperations["add"] = []string{
		"add [duration] [+tags]  - Add a timer for the given duration",
		"                          with the given tags",
	}

	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",
		"                            Or other date values, we'll try to parse it.",
		"                          To list entries by tag, preceed the tags with a +",
	}

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

	opFuncs["modify"] = cmdModifyTimer
	validOperations["modify"] = []string{
		"modify [+tags]          - Modify a timer",
	}

	opFuncs["mod"] = cmdModifyTimer
	validOperations["mod"] = []string{
		"mod [+tags]             - Modify a timer",
	}

	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)
	}
	if _, err := time.ParseDuration(cfg.Get("roundto")); err != nil {
		cfg.Set("roundto", DefRoundTo)
	}

	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]
}