commands

var (
	VersionMajor    = 0
	VersionMinor    = 5
	VersionRevision = 0
)

var DeleteBookCmd = &cobra.Command{
	Use:   "book <book name>",
	Short: "Delete a Book and all of it's Notes",
	Run:   deleteBookCmdRun,
}

var DeleteCmd = &cobra.Command{
	Use:     "delete",
	Aliases: []string{"del", "remove", "rm"},
	Short:   "Delete Note or Notebook",
}

var DeleteNoteCmd = &cobra.Command{
	Use:   "note <note id...>",
	Short: "Delete Note from Book",
	Run:   deleteNoteCmdRun,
}

var EditBookCmd = &cobra.Command{
	Use:   "book <new book_name>",
	Short: "Edit working Book's name",
	Long:  `Edit the working Book's name. This requires re-index the Book`,
	Run:   editBookCmdRun,
}

var EditCmd = &cobra.Command{
	Use:     "edit",
	Aliases: []string{"update"},
	Short:   "Edit Note or Notebook",
}

var EditNoteCmd = &cobra.Command{
	Use:   "note <note id>",
	Short: "Edit note",
	Long:  `Opens an editor (default vim) to allow you to edit a Note`,
	Run:   editNoteCmdRun,
}

var ExportCmd = &cobra.Command{
	Use:   "export [flags]",
	Short: "Export all Notes, Books, and Tags",
	Long: `Export all Notes, Books, and Tags using the QNOT file format.

See the documentation in github.com/anmil/quicknote/cmd/shard/encoding/binary.go
for the specifications of the format. This command is useful for backing up all
of your notes or transferring them to another system.

See the help docs for the "import" command for how importing is done and conflicts
are dealt with.

The output is written to stdout by default, use the '-o' flag to write to a file.

Qnote can also compress the output with gzip by specifying the '-c' flag.`,
	Run: exportCmdRun,
}

var GetBookCmd = &cobra.Command{
	Use:     "book",
	Aliases: []string{"books"},
	Short:   "List all books",
	Run:     getBookCmdRun,
}

var GetCmd = &cobra.Command{
	Use:              "get",
	Aliases:          []string{"list", "ls"},
	Short:            "Get/List Notes, Notebook, Tags",
	PersistentPreRun: preseistentPreGetRoot,
}

var GetNoteAllCmd = &cobra.Command{
	Use:   "all",
	Short: "List all Notes for all Books",
	Long: `List all notes in all Books

This is the same as 'gnote ls notes' except it returns all Notes in all Books`,
	Run: getNoteAllCmdRun,
}

var GetNoteCmd = &cobra.Command{
	Use:     "note [flags] [note id...]",
	Aliases: []string{"notes"},
	Short:   "List all notes in the working Book, or all notes for the given [note id...]",
	Long: `List all Notes for the Book, or Notes for the given IDs.

Prints Notes in the format given by '-f', see '-f' docs for all available
options.`,
	Run: getNoteCmdRun,
}

var GetTagCmd = &cobra.Command{
	Use:     "tag",
	Aliases: []string{"tags"},
	Short:   "lists all tags for the working Book",
	Run:     getTagCmdRun,
}

var ImportCmd = &cobra.Command{
	Use:   "import [flags] [<input-file>]",
	Short: "Imports Notes, Books, and Tags from a QNOT file",
	Long: `Imports Notes, Books, and Tags from a QNOT file

Imports notes from a QNOT file that is read from stdin or a file passed
as an argument.

If the QNOT file contains a book that is already in the database it is not
recreated and the existing book is used. The same goes for Tags.

By default the importer checks if a Note already exists. A Note is considered
to be equal if the Book, Type, Title, and Body are the same. If a duplicate
is found the Note is skipped. The duplicate check can be disabled with the
"--skip-dup-check" flag in which case all Notes are saved as new Notes.

Skipping the check is a good idea if you know there are no duplicates -- the
importer will run faster since it does not have to search the database for
existing Notes.

A Note's ID is not preserved
Created dates are preserved
Modified dates are set to the current time (set --preserve-modified to disable this)

Be sure to set the "-c" flag if the QNOT file is compressed with gzip. If you
pass the file name in as an argument and it ends with ".gz" Qnote will automatically
treat it as compressed.`,
	Run: importCmdRun,
}

var MergeBooksCmd = &cobra.Command{
	Use:   "merge [flags] <book_name 1> <book_name 2>",
	Short: "Merge all notes from <book_name 1> into <book_name 2>",
	Long: `Merge all of the notes from <book_name 1> into <book_name 2>. Than <book_name 1>
is deleted and <book_name 2> is re-indexed.`,
	Run: mergeBooksCmdRun,
}

var MoveNotesIDsCmd = &cobra.Command{
	Use:   "move [flags] <book_name> <note_id...>",
	Short: SplitBookIDsCmd.Short,
	Long:  SplitBookIDsCmd.Long,
	Run:   SplitBookIDsCmd.Run,
}

var NewCmd = &cobra.Command{
	Use:     "new",
	Aliases: []string{"create", "add"},
	Short:   "Create new Note or Notebook",
}

var NewNoteCmd = &cobra.Command{
	Use:   "note",
	Short: "Create a new basic Note",
	Long: `Create a new note to store and index

Opens an editor (default vim) to allow you to enter a new Note. The Note text
is parsed using the first line as the Note's title. All other lines are used
as the Note's body. Any word starting with '#' character is parsed as a Tag.
Tags can be in either the title or the body.`,
	Run: newNoteCmdRun,
}

var NewNoteFromJSONCmd = &cobra.Command{
	Use:   "json [<json>]",
	Short: "Create new notes from JSON",
	Long: fmt.Sprintf(`Create new notes from JSON

JSON must be in the format

[
	...
	{
		"title": "<title>",
		"type": "<type>",
		"tags": ["<tag1>", "<tag2>", ...],
		"body": "<body>",
		"book": "<book>"
	},
	...
]

"type" must be one of the following: %s
If the book does not exists, it will be created

If <json> is note given, qnote will read from stdin
`, strings.Join(note.NoteTypes, ", ")),
	Run: newNoteFromJSONCmdRun,
}

var NewURLNoteCmd = &cobra.Command{
	Use:   "url <url>",
	Short: "Create a new url note",
	Long: `Creates a new note with URL type

DO NOT USE THIS IF YOU DO NOT WANT A REQUEST SENT TO THE URL

This is the same as calling 'qnote note new -t url <url>

This command preforms a GET request on the given URL. If a valid response
is given, it will parse the HTML for the 'title', keywords', and 'description'
meta tags and pre-fills the editor with this information.
`,
	Run: newURLNoteCmdRun,
}

var NewbookCmd = &cobra.Command{
	Use:   "book <book_name...>",
	Short: "Create a new Book",
	Long: `Create a new Book

Books allow you to organize collections of notes. Every Note must belong to a
Book. All commends (unless stated otherwise) operates only on one book. Such as,
if you call 'qnote ls notes', it only list the notes for the working Book. The
working Book can be changed with the '-n' flag, or you can changed the default
Book in the config file. In most cases, it is not advised to create to many
books, but they are useful to keeping work notes separated from personal.`,
	Run: newbookCmdRun,
}

var RootCmd = &cobra.Command{
	Use:   "qnote",
	Short: "Create and search tens of thousands of notes",
	Long: `Qnote allows you to quickly create and search tens of thousands of short notes.

Create Books to organize collections of notes.
Add tags to notes for more accurate searching.
Export your notes in text, csv, and json.

Notes are stored in an SQLite database (support for more databases is coming).
Searching is provided by Bleve by default, or Elasticsearch with some extra setup.
`,
	PersistentPreRun:  PreseistentPreRunRoot,
	PersistentPostRun: PreseistentPostRunRoot,
}

var SearchCmd = &cobra.Command{
	Use:   "search <query>",
	Short: "Search notes",
	Long: `Search all notes in the working Book (see '-n').

Query syntax depends on the index provider that is configured. This command
(when '-q' is not given) uses a Phrase Prefix query. Results match on all
given words in the query string with the last word used as a prefix. For
better documentation on how this works. See the index providers docs

Bleve (default): http://www.blevesearch.com/docs/Query/
ElasticSearch: https://www.elastic.co/guide/en/elasticsearch/guide/current/_query_time_search_as_you_type.html

To use the QueryStringQuery syntax set the '-q' flag
	Example (ElasticSearch): title:term1 AND tags:term2 NOT (body:term3 OR body:term4)
`,
	Run: searchCmdRun,
}

var SearchReindexCmd = &cobra.Command{
	Use:   "reindex",
	Short: "Re-indexes all Notes in all Books",
	Long: `Use this command to re-index all of your Notes from all Books

If you change the index provider, copy or replace the qnote.db. You need to
call this in order to use the search command.

Re-indexing can take several minutes depending on the number of notes and
the index provider used.`,
	Run: searchReindexCmdRun,
}

var SplitBookIDsCmd = &cobra.Command{
	Use:   "ids [flags] <book_name> <note_id...>",
	Short: "Moves the given <note_id...> to a new or existing Book <book_name>",
	Long:  `Moves the Notes for the given <note_id...> into a new or existing Book.`,
	Run:   splitBooksIDsCmdRun,
}

var SplitBookQueryCmd = &cobra.Command{
	Use:   "query [flags] <book_name> <query_string_query>",
	Short: "splits the working Book into two Books using QueryStringQuery",
	Long: `Splits the working Book into two Books. All notes matching the query will be
moved into the Book <book_name>. If <book_name> already exists, the Notes
matching the query are merged into the exciting Book. For docs on the syntax for
QueryStringQuery see the docs for 'qnote search'.`,
	Run: splitBooksQueryCmdRun,
}

var SplitCmd = &cobra.Command{
	Use:   "split",
	Short: "Split Book",
}

var VersionCmd = &cobra.Command{
	Use:   "version",
	Short: "Print the version of qnote",
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Printf("Quick Note %d.%d.%d\n",
			VersionMajor, VersionMinor, VersionRevision)
	},
}