quoth

name: quoth
about: "Add a new quote\nOr use a subcommand to find a quote"
before_help: "Record, retrieve, search, and categorize quotes from books"
args:

- delete:
    help: Delete quote at <INDEX>
    short: d
    long: delete
    value_name: INDEX
    takes_value: true

- change:
    help: Changes quote at <INDEX>
    short: c
    long: change
    value_name: INDEX
    takes_value: true

subcommands:
- search:
    about: Finds quotes matching a pattern
    display-order: 1
    args:
    - pattern:
	short: p
	required: true
	index: 1
	value_name: PATTERN
	help: Lists quotes matching <PATTERN>
    - from:
	long: from
	value_name: DATE
	help: Quotes from <DATE>
    - to:
	long: to
	value_name: DATE
	help: Quotes till <DATE>
    - on:
	long: on
	value_name: DATE
	help: Quotes on <DATE>
    - author:
	short: a
	long: author
	value_name: AUTHOR
	takes_value: true
	help: Quotes by <AUTHOR>
	conflicts_with:
	- book
    - book:
	long: book
	short: b
	value_name: BOOK
	takes_value: true
	help: Quotes from <BOOK>
    groups:
    - date-range:
	args:
	- from
	- to
	multiple: true
	conflicts_with:
	- on

#[macro_use]
extern crate clap;
use clap::App;

fn main() {
    let yaml = load_yaml!("quoth.yml");
    let matches = App::from_yaml(yaml).get_matches();
    if matches.is_present("delete") {
	delete_quote_function()
    } else if matches.is_present("change") {
	change_quote_function()
    } else {
	match matches.subcommand() {
	    ("list", Some(sub_matches)) => list_function(sub_matches),
	    ("search", Some(sub_matches)) => search_function(sub_matches),
	    ("random", Some(sub_matches)) => random_function(sub_matches),
	    ("config", Some(sub_matches)) => config_function(sub_matches),
	    ("parse", Some(sub_matches)) => parse_function(sub_matches),
	    _ => add_quote_function(),
	}
    }
}

use clap::{App, ArgMatches, Shell};
use failure::Error;
use std::io;
use crate::errors:QuothError;

fn completions(matches: &ArgMatches<'a>) -> Result<(), Error> {
    let shell = utils::get_argument_value("completions", matches)?.ok_or(
	QuothError::OutOfCheeseError {
	    message: "Argument shell not used".into(),
	},
    )?;
    let yaml = load_yaml!("../quoth.yml");
    let mut app = App::from_yaml(yaml);
    app.gen_completions_to("quoth", shell.parse::<Shell>().unwrap(), &mut io::stdout());
    Ok(())
}

pub fn get_argument_value<'a>(
    name: &str,
    matches: &'a ArgMatches<'a>,
) -> Result<Option<&'a str>, Error> {
    match matches.value_of(name) {
	Some(value) => {
	    if value.trim().is_empty() {
		Err(QuothError::NoInputError.into())
	    } else {
		Ok(Some(value.trim()))
	    }
	}
	None => Ok(None),
    }
}

quoth config --completions zsh > ~/.oh_my_zsh/completions/_quoth
exec zsh

use dialoguer::{Editor, Input, theme};

/// Takes user input from terminal, optionally has a default and optionally displays it.
pub fn user_input(
    message: &str,
    default: Option<&str>,
    show_default: bool,
) -> Result<String, Error> {
    match default {
	Some(default) => Ok(Input::with_theme(theme::ColorfulTheme::default())
	    .with_prompt(message)
	    .default(default.to_owned())
	    .show_default(show_default)
	    .interact()?
	    .trim()
	    .to_owned()),
	None => Ok(Input::<String>::with_theme(theme::ColorfulTheme::default())
	    .with_prompt(message)
	    .interact()?
	    .trim()
	    .to_owned()),
    }
}

/// Gets input from external editor, optionally displays default text in editor
pub fn external_editor_input(default: Option<&str>) -> Result<String, Error> {
    match Editor::new().edit(default.unwrap_or(""))? {
	Some(input) => Ok(input),
	None => Err(QuothError::EditorError.into()),
    }
}

use chrono::{Date, Utc}
use chrono_english::{parse_date_string, Dialect}

/// Obtain a date from a (user-inputted) string such as "last Friday"
pub fn parse_date(date_string: &str) -> Result<Date<Utc>, Error> {
    Ok(parse_date_string(date_string, Utc::now(), Dialect::Uk)?.date())
}

/// Check if a quote was recorded within a date range
pub fn in_date_range(quote: &Quote, from_date: Date<Utc>, to_date: Date<Utc>) -> bool {
    from_date.and_hms(0, 0, 0) <= quote.date && quote.date < to_date.and_hms(23, 59, 59)
}

#[macro_use]
extern crate serde_derive;
use serde_json;

#[derive(Serialize, Deserialize, Debug)]
pub struct Quote {
    pub index: usize,
    pub book: String,
    pub author: String,
    pub tags: Vec<String>,
    pub date: DateTime<Utc>,
    pub quote: String,
}

impl Quote {
    fn write(&self, quoth_dir: &PathDir) -> Result<(), Error> {
	let quote_json = serde_json::to_string(self)?;
	let quote_file = PathFile::create(quoth_dir.join(config::QUOTE_PATH))?;
	quote_file.append_str(&quote_json)?;
	Ok(())
    }
    /// Read quotes from a JSON file and return consumable iterator
    fn read_from_file(
	json_file: &PathFile,
    ) -> Result<impl Iterator<Item = serde_json::Result<Self>>, Error> {
	Ok(serde_json::Deserializer::from_reader(FileRead::open(json_file)?).into_iter::<Self>())
    }
}

use csv;

fn import(quote_index: usize, filename: &PathFile) -> Vec<Quote> {
    let mut reader = csv::ReaderBuilder::new()
		    .delimiter(b'\t')
		    .from_path(&tsv_file)?;
    let quoth_headers: HashMap<&str, i32> = [
	("TITLE", 0),
	("AUTHOR", 1),
	("TAGS", 2),
	("DATE", 3),
	("QUOTE", 4),
    ].iter().cloned().collect();
    let header_indices: Vec<_> = reader
	.headers()?
	.into_iter()
	.map(|h| quoth_headers.get(h.to_ascii_uppercase().as_str()))
	.collect();
    let mut quotes = Vec::new();
    let mut quote_index = quote_index;
    if [0, 1, 4].iter().all(|x| header_indices.contains(&Some(x))) {
	for record in reader.records() {
	    let mut quote_data = ("", "", "", Utc::now(), String::new());
	    let record = record?;
	    for (entry, index) in record.into_iter().zip(header_indices.iter()) {
		if let Some(i) = index {
		    match i {
			0 => quote_data.0 = entry,
			1 => quote_data.1 = entry,
			2 => quote_data.2 = entry,
			3 => quote_data.3 = utils::parse_date(entry)?.and_hms(0, 0, 0),
			4 => quote_data.4 = entry.into(),
			_ => {
			    return Err(QuothError::OutOfCheeseError {
				message: "Please Reinstall Universe And Reboot".into(),
			    }
			    .into())
			}
		    }
		}
	    }
	    quotes.push(Quote::new(
		quote_index,
		quote_data.0,
		quote_data.1,
		quote_data.2,
		quote_data.3,
		quote_data.4,
	    ));
	    quote_index += 1;
	}
    }
    Ok(quotes)
}

fn export(quotes: &[Quote], filename: &PathFile) {
    let mut writer = csv::WriterBuilder::new()
	.delimiter(b'\t')
	.from_path(PathFile::create(filename)?)?;
    for quote in quotes {
	writer.serialize(TSVQuote::from(quote))?;
    }
    writer.flush()?;
    Ok(())
}

extern crate sled;
use sled;

/// If key exists, add value to existing values - join with a semicolon
fn merge_index(_key: &[u8], old_indices: Option<&[u8]>, new_index: &[u8]) -> Option<Vec<u8>> {
    let mut ret = old_indices
	.map(|old| old.to_vec())
	.unwrap_or_else(|| vec![]);
    ret.extend_from_slice(&[config::SEMICOLON]);
    ret.extend_from_slice(new_index);
    Some(ret)
}

/// Retrieve a `sled` tree from a given path
fn get_tree(path: &PathDir) -> Result<sled::Tree, Error> {
    let config = sled::ConfigBuilder::new()
	.path(path)
	.merge_operator(merge_index)
	.build();
    let tree = sled::Tree::start(config)?;
    Ok(tree)
}

/// Add a book to the trees and change metadata accordingly
fn add_book(
    trees: &mut Trees,
    author_key: &[u8],
    book_key: &[u8],
    index_key: &[u8],
) -> Result<(), Error> {
    trees
	.author_book_tree
	.merge(author_key.to_vec(), book_key.to_vec())?;
    trees
	.book_quote_tree
	.set(book_key.to_vec(), index_key.to_vec())?;
    trees
	.book_author_tree
	.set(book_key.to_vec(), author_key.to_vec())?;
    trees.metadata.increment_books();
    Ok(())
}

/// Retrieve quote indices from a given book
pub fn get_book_quotes(trees: &Trees, book: &str) -> Result<Vec<usize>, Error> {
    utils::split_indices_usize(
	&trees
	    .book_quote_tree
	    .get(&utils::camel_case_phrase(book).as_bytes())?
	    .ok_or(QuothError::BookNotFound {
		book: book.to_owned(),
	    })?,
    )
}

/// Retrieve many quotes given indices
pub fn retrieve_many(indices: &[usize], quoth_dir: &PathDir) -> Result<Vec<Quote>, Error> {
    let mut indices = indices.to_vec().into_iter().peekable();
    let mut quote_stream = Quote::read(quoth_dir)?;
    let mut quotes = Vec::new();
    while let Some(index) = indices.peek() {
	let quote = quote_stream
	    .next()
	    .ok_or(QuothError::QuoteNotFound { index: index })??;
	if quote.index == index {
	    quotes.push(quote);
	    indices.next().unwrap();
	}
    }
    Ok(quotes)
}

extern crate console;
extern crate textwrap;
use console::{pad_str, style, Alignment};
use textwrap::{termwidth, Wrapper};

pub fn pretty_print(quote: &Quote) {
    let width = termwidth() - 4;
    let wrapper = Wrapper::new(width)
	.initial_indent("  ")
	.subsequent_indent("  ");
    let quote_text = format!("\"{}\"", &quote.quote);
    println!("\n{}", wrapper.fill(&quote_text));
    println!(
	"{}",
	style(pad_str(
	    &format!("--#{}--", quote.index),
	    width,
	    Alignment::Center,
	    None
	))
	.dim()
    );
    println!(
	"{}",
	style(pad_str(&quote.author, width, Alignment::Right, None)).magenta()
    );
    println!(
	"{}",
	style(pad_str(&quote.book, width, Alignment::Right, None))
	    .cyan()
	    .italic()
    );
}

extern crate regex;
use regex::Regex;

fn search(quotes: Vec<Quote>, matches: &ArgMatches<'a>) -> Result<(), Error> {
    let pattern = utils::get_argument_value("pattern", matches)?.unwrap();
    /// i - case-insensitive
    /// m - multi-line mode
    /// s - allow . to match \n
    let pattern = Regex::new(&format!(
	r"(?ims){}",
	pattern.split_whitespace().collect::<Vec<_>>().join(".+")
    ))?;
    for quote in &quotes {
	if pattern.is_match(&quote.to_string()) {
	    quote.pretty_print();
	}
    }
    Ok(())
}

#[macro_use]
extern crate failure
use failure::Error;

#[derive(Debug, Fail)]
pub enum QuothError {
    #[fail(display = "I don't know who {} is.", author)]
    AuthorNotFound { author: String },
    #[fail(display = "You haven't written that quote: {}.", index)]
    QuoteNotFound { index: usize },
    #[fail(display = "I haven't read {} yet.", book)]
    BookNotFound { book: String },
    #[fail(display = "You haven't tagged anything as {} yet.", tag)]
    TagNotFound { tag: String },
    /// Thrown when no text is returned from an external editor
    #[fail(display = "Your editor of choice didn't work.")]
    EditorError,
    /// Thrown when explicit Y not received from user for destructive things
    #[fail(display = "{}\nDoing nothing.", message)]
    DoingNothing { message: String },
    /// Catch-all for stuff that should never happen
    #[fail(display = "{}\nRedo from start.", message)]
    OutOfCheeseError { message: String },
}

/// Makes config file (default ~/quoth.txt) with a single line containing the location of the quoth directory (default ~/.quoth)
fn make_quoth_config_file() -> Result<(), Error> {
    match dirs::home_dir() {
	Some(home_dir) => {
	    let config_file = PathFile::create(PathDir::new(&home_dir)?.join(config::CONFIG_PATH))?;
	    config_file.write_str(
		&PathDir::new(home_dir)?
		    .join(config::QUOTH_DIR_DEFAULT)
		    .to_str().unwrap(),
	    )?;
	    Ok(())
	}
	None => Err(QuothError::Homeless.into()),
    }
}