package main

import (
	"errors"
	"fmt"
	"net/url"
	"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
)

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

	// mk is the Bookmark that we're adding/editing
	var mk *Bookmark

	parms := os.Args
	if len(parms) > 1 {
		// Trim the program name
		parms = parms[1:]
		// Parse all of the parameters
		for i := range parms {
			switch parms[i] {
			case "-h":
				printUsage()
				os.Exit(0)
			case "-a":
				// Adding a new bookmark
				mk, err = doOperation(OpAdd, parms[i+1:])
				assertError(err)
			case "-u":
				// Updating an existing bookmark
				mk, err = doOperation(OpUpdate, parms[i+1:])
				assertError(err)
			case "-d":
				// Delete an existing bookmark
				mk, err = doOperation(OpDelete, parms[i+1:])
				assertError(err)
			}
		}
		_ = mk
	} else {
		// Enter cui mode
		mainCui()
	}
}

// doOperation performs the requested operation
//		which is the constant that specifies the operation we're performing
//		parms is the slice of all remaining parameters passed on the cli
func doOperation(which int, parms []string) (*Bookmark, error) {
	var mk *Bookmark

	var nxt string
	if len(parms) > 0 {
		nxt = parms[0]
	}
	switch which {
	case OpAdd:
		// nxt should be the url, make sure it's valid
		fmt.Println("Adding Bookmark")
		url, err := url.Parse(nxt)
		if err != nil {
			return nil, err
		}
		mk = NewBookmark(url)
		if err = mk.DownloadDetail(); err != nil {
			fmt.Println(err)
		}
		fmt.Println(mk.Desc)
	case OpUpdate:

	case OpDelete:

	case OpSearch:

	default:
		return nil, errors.New("Invalid operation")
	}
	return mk, nil
}

// 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)
		}
	}
}

func assertError(err error) {
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	}
}