package main

import (
	"bufio"
	"errors"
	"fmt"
	"local/mytinytodoclient/mytinytodo"
	"local/mytinytodoclient/mytinytodo/remote"
	"log"
	"os"
	"strings"
)

var ErrQuit = errors.New("received quit")

func main() {
	conf, err := remote.NewConfig()
	if err != nil {
		panic(err)
	}
	buffer, err := mytinytodo.NewBuffer(&mytinytodo.Config{Config: conf})
	if err != nil {
		panic(err)
	}
	log.Printf("config: %v", *conf)
	for {
		line := readLine()
		first := strings.Split(line, " ")[0]
		if err := doLine(buffer, first, line); err == ErrQuit {
			break
		} else if err != nil {
			log.Printf("err doing %s: %v", first, err)
		}
	}
}

func readLine() string {
	reader := bufio.NewReader(os.Stdin)
	text, _ := reader.ReadString('\n')
	return strings.TrimSpace(text)
}

func doLine(buffer *mytinytodo.Buffer, key, line string) error {
	segments := strings.Split(line, " ")
	defer func() {
		if err := recover(); err != nil {
			log.Printf("err on %s: %v", key, err)
		}
	}()
	err := fmt.Errorf("unknown command %q", key)
	switch key {
	case "refresh":
		buffer.RefreshLocal()
		err = nil
	case "lists":
		var lists remote.Lists
		lists, err = buffer.Lists()
		if err == nil {
			log.Printf("%s: %v", key, lists)
		}
	case "tasks":
		var tasks remote.Tasks
		id := segments[1]
		tasks, err = buffer.Tasks(remote.List{ID: id})
		if err == nil {
			log.Printf("%s: %v", key, tasks)
		}
	case "enqueue":
		action := segments[1]
		err = fmt.Errorf("unknown enqueue op %v", action)
		op := remote.OpFromString(action)
		var listID, taskTitle, taskID string
		var taskTags []string
		switch op {
		case remote.NEW:
			op = remote.NEW
			listID = segments[2]
			taskTitle = strings.Join(segments[3:], " ")
			taskTagsStr := segments[len(segments)-1]
			if strings.HasPrefix(taskTagsStr, "/") && strings.HasSuffix(taskTagsStr, "/") {
				taskTitle = strings.TrimSuffix(taskTitle, taskTagsStr)
				taskTags = strings.Split(taskTagsStr[1:len(taskTagsStr)-1], ",")
			}
		case remote.CLOSE:
			fallthrough
		case remote.OPEN:
			taskID = segments[2]
		}
		err = buffer.Enqueue(op, remote.List{ID: listID}, remote.Task{Title: taskTitle, ID: taskID}, taskTags...)
	case "dequeue":
		buffer.Dequeue()
		err = nil
	case "help":
		fallthrough
	case "h":
		log.Printf("refresh")
		log.Printf("lists")
		log.Printf("tasks <list#>")
		log.Printf("enqueue new <list#> <taskName> /tag1,tag2,tag3/")
		log.Printf("enqueue <close,open> <task#>")
		log.Printf("dequeue")
		log.Printf("help")
		log.Printf("quit")
		err = nil
	case "quit":
		fallthrough
	case "exit":
		fallthrough
	case "q":
		err = ErrQuit
	}
	return err
}

func oldMain() {
	conf, err := remote.NewConfig()
	if err != nil {
		panic(err)
	}
	remote, err := remote.NewClient(conf)
	if err != nil {
		panic(err)
	}
	if err := remote.ParseArgs(); err != nil {
		panic(err)
	}
}