package main

import (
	"fmt"
	"strconv"
	"time"

	timertxt "git.bullercodeworks.com/brian/go-timertxt"
)

func (a *AppState) opStatus(args []string) int {
	fmt.Println("Current Time: " + time.Now().Format(time.Stamp))
	if len(*a.TimerList.GetActiveTimers()) == 0 {
		fmt.Println("No timers running")
		return 0
	}
	for _, v := range *a.TimerList.GetActiveTimers() {
		fmt.Println(timerToFriendlyString(&v))
	}
	return 0
}

func (a *AppState) opListTimers(args []string) int {
	// By default only list today
	// Format:
	// 2019/02/20 (9.25)
	//   start - end [ contexts ] [ projects ]
	// ...
	dayTotals := make(map[string]time.Duration)
	for _, v := range *a.TimerList {
		dur := v.FinishDate.Sub(v.StartDate)
		if v.FinishDate.IsZero() {
			dur = time.Now().Sub(v.StartDate)
		}
		dayTotals[v.StartDate.Format("2006/01/02")] += dur
	}
	var oldDayStr, dayStr string
	for _, v := range *a.TimerList {
		oldDayStr = dayStr
		dayStr = v.StartDate.Format("2006/01/02")
		if dayStr != oldDayStr {
			wrkDur := dayTotals[dayStr].Round(GetRoundToDuration())
			fmtStr := dayStr + " ( %.2f )\n"
			fmt.Printf(fmtStr, DurationToDecimal(wrkDur))
		}

		fmt.Println("  " + timerToFriendlyString(&v))
	}
	return 0
}

func (a *AppState) opStartTimer(args []string) int {
	var contexts, projects []string
	t := timertxt.NewTimer()
	contexts, args = getContextsFromSlice(args)
	projects, args = getProjectsFromSlice(args)
	if len(args) > 0 {
		if start, err := parseFuzzyTime(args[0]); err == nil {
			t.StartDate = start
			args = args[1:]
		}
	}
	t.Contexts = contexts
	t.Projects = projects

	a.TimerList.AddTimer(t)
	if err := a.WriteList(); err != nil {
		fmt.Println(err.Error())
		return 1
	}
	return 0
}

func (a *AppState) opStopTimer(args []string) int {
	var err error
	var wrk time.Time
	end := time.Now()
	id := -1

	if len(args) > 0 {
		if wrk, err = parseFuzzyTime(args[0]); err != nil {
			id, err = strconv.Atoi(args[0])
		} else {
			end = wrk
			args = args[1:]
		}
	}
	fmt.Println("Stopping at : " + end.Format(time.RFC3339))
	var timerIds []int
	if id == -1 {
		for _, v := range *a.TimerList.GetActiveTimers() {
			timerIds = append(timerIds, v.Id)
		}
	} else {
		timerIds = append(timerIds, id)
	}
	for _, v := range timerIds {
		var stopped *timertxt.Timer
		if stopped, err = a.TimerList.GetTimer(v); err != nil {
			fmt.Println(err.Error())
		}
		if err = a.SetTimerFinished(v, end); err != nil {
			fmt.Println(err.Error())
			continue
		}
		fmt.Println("Stopped Timer:", timerToFriendlyString(stopped))
	}
	if err = a.WriteList(); err != nil {
		fmt.Println(err.Error())
		return 1
	}
	return 0
}

func (a *AppState) opState(args []string) int {
	return 0
}

func (a *AppState) opFuzzyParse(args []string) int {
	if len(args) > 0 {
		if start, err := parseFuzzyTime(args[0]); err == nil {
			fmt.Println(start.Format(time.RFC3339))
		} else {
			fmt.Println(err.Error())
		}
	}
	return 0
}

func (a *AppState) opPrintUsage(args []string) int {
	for _, v := range a.ValidOperations {
		for _, vv := range v {
			fmt.Println("  " + vv)
			fmt.Println("")
		}
	}
	return 0
}