package main

import (
	"fmt"
	"os"

	userConfig "github.com/br0xen/user-config"
)

const AppName = "mark"
const DefDBName = AppName + ".db"

var mdb *MarkDB
var cfg *userConfig.Config

// Valid command line options
var validFlags []cliFlag

const (
	OpSearch = iota
	OpAdd
	OpUpdate
	OpDelete
	OpError
)

var performOp = OpSearch

func main() {
	err := initialize()
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	parms := os.Args
	if len(parms) > 1 {
		parms = parms[1:]
		for _, v := range parms {
			switch v {
			case "-h":
				printUsage()
				os.Exit(0)
			case "-a":
				// Adding a new bookmark
				setOperation(OpAdd)
			case "-u":
				// Updating an existing bookmark
				setOperation(OpUpdate)
			case "-d":
				// Delete an existing bookmark
				setOperation(OpDelete)
			}
		}
	} else {
		// Enter cui mode
		fmt.Println("Entering CUI Mode")
	}
}

func setOperation(which int) {
	if performOp != OpSearch || which >= OpError {
		// We've already tried to set the operation
		fmt.Println("Error parsing command. For help use '-h'.")
		os.Exit(1)
	}
	performOp = which
}

// initialize sets up the application for general use
func initialize() error {
	var err error
	// Build the list of valid command line options
	addValidFlag("-h", "help", []string{"Print the usage (this message)"})
	addValidFlag("-a", "add", []string{"Add a new bookmark"})
	addValidFlag("-u", "update", []string{"Update an existing bookmark"})
	addValidFlag("-d", "delete", []string{"Delete an existing bookmark"})
	addValidFlag("-s", "search", []string{"Search for a bookmark"})
	addValidFlag("-n", "name (optional)", []string{
		"When adding/updating, specify the name you wish to give a bookmark.",
		"When searching, specifiy the name of the bookmark(s) you're searching for.",
	})
	addValidFlag("-t", "tag", []string{
		"Comma delimited tags",
		"When adding/updating, specify the tags you wish to give a bookmark.",
		"When searching, specifiy the name of the tags you're searching for.",
	})

	// 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 db name
	if cfg.Get("dbname") == "" {
		cfg.Set("dbname", DefDBName)
	}
	// Get a reference to the database
	if mdb, err = NewDatabase(cfg.Get("dbdir"), cfg.Get("dbname")); err != nil {
		fmt.Println("Error loading the database")
		os.Exit(1)
	}
	return nil
}

// Adds an option to the "validFlags" slice
func addValidFlag(flag, name string, desc []string) {
	validFlags = append(validFlags, cliFlag{
		Flag:        flag,
		Name:        name,
		Description: desc,
	})
}

func printUsage() {
	help := []string{
		"mark is a tool for keeping your bookmarks organized",
		"",
		"Usage: ",
		"\tmark [operation] [optional flags]",
		"",
		"If no arguments are given, we enter gui mode",
		"If no 'operation' arguments are given (-a, -u, -d, -s) search is assumed",
		"",
		"Valid arguments are:",
		"",
	}
	for _, ln := range help {
		fmt.Println(ln)
	}
	for _, v := range validFlags {
		fmt.Println("\t", v.Flag, "\t", v.Name)
		for _, hv := range v.Description {
			fmt.Println("\t\t\t", hv)
		}
	}
}