//! Support for accessing the timelog logic from a tool
//!
//! # Examples
//!
//! ```rust,no_run
//! use structopt::StructOpt;
//!
//! use timelog::Cli;
//!
//! # fn main() {
//! let cli = Cli::from_args();
//! let _ = cli.run();
//! #  }
//! ```
//!
//! # Description
//!
//! The [`Cli`] struct handling the command line processing for the main program.
use std::iter::once;
use std::path::PathBuf;

use crate::config::{Config, DEFAULT_BROWSER, DEFAULT_CONF, DEFAULT_DIR, DEFAULT_EDITOR};
#[doc(inline)]
use crate::error::Error;
#[doc(inline)]
use crate::error::PathError;
use crate::Result;

use lazy_static::lazy_static;
use regex::Regex;
use structopt::StructOpt;
use terminal_size::{terminal_size, Width};

pub mod args;
pub mod cmd;

pub type PosIntArg = args::PosIntArg;
pub type FilterArgs = args::FilterArgs;
pub type DateRangeArgs = args::DateRangeArgs;

/// Name of the program binary.
const BIN_NAME: &str = "rtimelog";

lazy_static! {
    /// Regular expression for matching the alias template match
    static ref SUBST_RE: Regex = Regex::new(r#"\{\}"#).unwrap();
}

// Utility type for a vector of strings
#[derive(Debug, Default, PartialEq, StructOpt)]
struct VecString {
    args: Vec<String>,
}

// Utility type for an optional string
#[derive(Debug, Default, PartialEq, StructOpt)]
struct OptString {
    arg: Option<String>,
}

// Enumeration for determining whether to expand aliases.
enum ExpandAlias {
    Yes,
    No,
}

// Help message explaining a task description
const TASK_DESC: &str = "The command takes a 'task description' consisting of an optional project \
formatted with a leading '+', an optional task name formatted with a leading '@', and potentially \
more text adding details to the task. If no task name starting with '@' is supplied, any extra text \
is treated as the task.";

// Help message explaining the format of an event description.
const DATE_DESC: &str = "The 'date description' consists of a date of the form 'YYYY-MM-DD', or one \
of a set of relative date strings including: today, yesterday, sunday, monday, tuesday, wednesday, \
thursday, friday, or saturday. The first two are obvious. The others refer to the previous instance \
of that day.";

lazy_static! {
    static ref FULL_DESC: String = format!("{}\n\n{}", TASK_DESC, DATE_DESC);
}

/// Specify the stack subcommands supported by the program.
#[derive(Debug, PartialEq, StructOpt)]
enum StackCommands {
    /// Clear all of the items from the stack.
    Clear,

    /// Drop items from stack.
    #[structopt(
        usage = "drop [{num}]",
        after_help = r"
    - If an positive integer is supplied, that number of items is dropped from the top of the stack.
    - If no argument is supplied, drop only the top item."
    )]
    Drop(OptString),

    /// Remove all except the top number of items from the stack.
    #[structopt(
        usage = "keep [{num}]",
        after_help = r"
    - If an positive integer is supplied, that number of items are kept on the top of stack, discarding the rest
    - If no argument is supplied, drop all but the top 10 items"
    )]
    Keep(OptString),

    /// Display items on the stack.
    Ls,
}

/// Specify the stack subcommands supported by the program.
#[derive(Debug, PartialEq, StructOpt)]
enum TaskCommands {
    /// Discard the most recent entry.
    Discard,

    /// Reset the time of the most recent entry to now.
    Now,

    /// Return to the previous task, setting the current entry as ignored.
    Ignore,

    /// Rewrite the most recent entry.
    #[structopt(usage = "task rewrite {event description}", after_help = TASK_DESC)]
    Rewrite(VecString),
}

/// Specify the stack subcommands supported by the program.
#[derive(Debug, PartialEq, StructOpt)]
enum ReportCommands {
    /// Display a report for the specified days and projects.
    #[structopt(usage = "report detail [date_desc [end_date_desc]] [project_regex]...", after_help = DATE_DESC)]
    Detail(VecString),

    /// Display a summary of the appropriate days' projects.
    #[structopt(usage = "report summary [date_desc [end_date_desc]] [project_regex]...", after_help = DATE_DESC)]
    Summary(VecString),

    /// Display the hours worked for each of the appropriate days and projects.
    #[structopt(usage = "report hours [date_desc [end_date_desc]] [project_regex]...", after_help = DATE_DESC)]
    Hours(VecString),

    /// Display the zero duration events for each of the appropriate days and projects.
    #[structopt(usage = "report events [date_desc [end_date_desc]]", after_help = DATE_DESC)]
    Events(VecString),

    /// Display a chart of the hours worked for each of the appropriate days and projects.
    #[structopt(usage = "report chart [date_desc [end_date_desc]]", after_help = DATE_DESC)]
    Chart(VecString),
}

/// Specify the subcommands supported by the program.
#[derive(Debug, PartialEq, StructOpt)]
enum Subcommands {
    /// Create the timelog directory and configuration.
    ///
    /// Use the supplied directory, or default to `~/timelog` if not supplied.
    #[structopt(usage = "init [dir]")]
    Init(OptString),

    /// Start timing a new task.
    ///
    /// Stop timing the current task (if any) and start timing a new task.
    #[structopt(usage = "start {task description}", after_help = TASK_DESC)]
    Start(VecString),

    /// Stop timing the current task.
    Stop,

    /// Add a comment line.
    Comment(VecString),

    /// Add a zero duration event
    Event(VecString),

    /// Save the current task and start timing a new task.
    ///
    /// This command works the same as the `start` command, except that the
    /// current task description is saved on the top of the stack. This makes
    /// resuming the previous task easier.
    #[structopt(usage = "push {task description}", after_help = TASK_DESC)]
    Push(VecString),

    /// Stop last task and restart top task on stack.
    Resume,

    /// Save the current task and stop timing.
    Pause,

    /// Pop the top task description on the stack and push the current task.
    Swap,

    /// List entries for the specified day. Default to today.
    #[structopt(usage = "ls {date_desc}", after_help = DATE_DESC)]
    Ls(OptString),

    /// List known projects.
    Lsproj,

    /// Open the timelog file in the current editor.
    Edit,

    /// Display the current task.
    Curr,

    /// Check the logfile for problems.
    Check,

    /// Archive the first year from the timelog file, as long as it isn't the current year.
    Archive,

    /// List the aliases from the config file.
    Aliases,

    /// Reporting commands
    Report(ReportCommands),

    /// Stack specific commands
    Stack(StackCommands),

    /// Task specific commands
    Task(TaskCommands),

    // `external_subcommand` tells structopt to put
    // all the extra arguments into this Vec
    #[structopt(external_subcommand)]
    Other(Vec<String>),
}

/// Specify all of the command line parameters supported by the program.
#[derive(StructOpt, Debug)]
#[structopt(about, after_help = FULL_DESC.as_str())]
pub struct Cli {
    /// Specify a directory for logging the task events and stack.
    #[structopt(long, parse(from_os_str), default_value = &DEFAULT_DIR)]
    dir: PathBuf,

    /// Specify the editor to use for modifying events.
    #[structopt(long, parse(from_os_str), default_value = &DEFAULT_EDITOR)]
    editor: PathBuf,

    /// Specify the path to the configuration file.
    #[structopt(long, parse(from_os_str), default_value = &DEFAULT_CONF)]
    conf: PathBuf,

    /// Specify the command to execute the browser.
    #[structopt(long, default_value = &DEFAULT_BROWSER)]
    browser: String,

    /// Sub-commands which determine what actions to take
    #[structopt(subcommand)]
    cmd: Option<Subcommands>,
}

impl Cli {
    /// Execute the action specified on the command line.
    ///
    /// ## Errors
    ///
    /// - Return [`PathError::FilenameMissing`] if no configuration file is known.
    /// - Return [`PathError::InvalidPath`] if the timelog directory is not a valid path.
    /// - Return [`PathError::FilenameMissing`] if no editor has been configured.
    /// - Return other errors specific to the commands.
    pub fn run(&self) -> Result<()> {
        let width = match terminal_size() {
            Some((Width(w), _)) => w as usize,
            _ => 120,
        };
        Self::clap().set_term_width(width);
        let config = self.config()?;
        match &self.cmd {
            Some(cmd) => cmd.run(&config, ExpandAlias::Yes),
            None => Subcommands::default_command(&config).run(&config, ExpandAlias::No),
        }
    }

    // Retrieve the configuration from the file.
    //
    // ## Errors
    //
    // - Return [`PathError::FilenameMissing`] if no configuration file is known.
    // - Return [`PathError::InvalidPath`] if the timelog directory is not a valid path.
    // - Return [`PathError::FilenameMissing`] if no editor has been configured.
    fn config(&self) -> std::result::Result<Config, PathError> {
        let conf_file = self.conf.to_str().ok_or(PathError::FilenameMissing)?;
        match Config::from_file(conf_file) {
            Ok(config) => Ok(config),
            Err(_) => {
                let mut config = Config::default();
                config.set_dir(
                    self.dir
                        .to_str()
                        .ok_or_else(|| PathError::InvalidPath(String::new(), String::new()))?
                );
                config.set_editor(
                    self.editor
                        .to_str()
                        .ok_or(PathError::FilenameMissing)?
                );
                config.set_browser(&self.browser);
                Ok(config)
            }
        }
    }
}

// Recognize deprecated commands, supply user message, and terminate the program.
fn process_deprecated_cmd(cmd: &str, e: Error) -> Result<()> {
    match cmd {
        "pop" => Err(Error::DeprecatedCommand("resume")),
        "drop" => Err(Error::DeprecatedCommand("stack drop' or 'stack clear")),
        "lstk" => Err(Error::DeprecatedCommand("stack ls")),
        "summary" => Err(Error::DeprecatedCommand("report summary")),
        "hours" => Err(Error::DeprecatedCommand("report hours")),
        "chart" => Err(Error::DeprecatedCommand("report chart")),
        _ => Err(e),
    }
}

impl Subcommands {
    /// Execute the action associated with the current variant.
    ///
    /// ## Errors
    ///
    /// - Return [`Error`]s for particular commands failing.
    /// - Return [`Error::InvalidCommand`] if the subcommand is not recognized and no alias
    /// matches.
    pub fn run(&self, config: &Config, expand: ExpandAlias) -> Result<()> {
        use Subcommands::*;

        match &self {
            Init(arg) => Ok(cmd::initialize(config, &arg.arg)?),
            Start(args) => cmd::start_task(config, &args.args),
            Stop => cmd::stop_task(config),
            Comment(args) => cmd::add_comment(config, &args.args),
            Event(args) => cmd::add_event(config, &args.args),
            Push(args) => cmd::push_task(config, &args.args),
            Resume => cmd::resume_task(config),
            Pause => cmd::pause_task(config),
            Swap => cmd::swap_entry(config),
            Ls(arg) => cmd::list_entries(config, &arg.arg),
            Lsproj => cmd::list_projects(config),
            Edit => cmd::edit(config),
            Curr => cmd::current_task(config),
            Check => cmd::check_logfile(config),
            Archive => cmd::archive_year(config),
            Aliases => cmd::list_aliases(config),
            Report(cmd) => cmd.run(config),
            Stack(cmd) => cmd.run(config),
            Task(cmd) => cmd.run(config),
            Other(args) => {
                match expand {
                    ExpandAlias::Yes => self.expand_alias(config, args),
                    ExpandAlias::No => Err(Error::InvalidCommand(args[0].to_owned())),
                }.or_else(|e| process_deprecated_cmd(&args[0], e))
            },
        }
    }

    fn default_command(config: &Config) -> Self {
        match config.defcmd() {
            "init" => Self::Init(OptString::default()),
            "start" => Self::Start(VecString::default()),
            "stop" => Self::Stop,
            "push" => Self::Push(VecString::default()),
            "resume" => Self::Resume,
            "pause" => Self::Pause,
            "swap" => Self::Swap,
            "ls" => Self::Ls(OptString::default()),
            "lsproj" => Self::Lsproj,
            "edit" => Self::Edit,
            "curr" => Self::Curr,
            "archive" => Self::Archive,
            "aliases" => Self::Aliases,
            _ => Self::Curr,
        }
    }

    // Replace an alias as the first argument with the definition of the alias.
    fn expand_alias(&self, config: &Config, args: &[String]) -> Result<()> {
        let alias = &args[0];
        let mut args_iter = args[1..].iter().map(|s| s.as_str());

        let expand: Vec<String> = config.alias(alias)
            .ok_or_else(|| Error::InvalidCommand(alias.to_owned()))?
            .split(' ')
            .map(|w| {
                if SUBST_RE.is_match(w) {
                    args_iter.next()
                        .map(|val| SUBST_RE.replace(w, val).into_owned())
                        .unwrap_or_else(|| w.to_string())
                }
                else {
                    w.to_string()
                }
            })
            .collect();

        let cmd =
            Subcommands::from_iter(
                once(BIN_NAME)
                    .chain(expand.iter().map(|s| s.as_str()))
                    .chain(args_iter)
            );
        cmd.run(config, ExpandAlias::No)
    }
}

impl StackCommands {
    /// Execute the action associated with the current variant.
    ///
    /// ## Errors
    ///
    /// - Return [`Error`]s for particular commands failing.
    /// - Return [`Error::InvalidCommand`] if the subcommand is not recognized and no alias
    /// matches.
    pub fn run(&self, config: &Config) -> Result<()> {
        use StackCommands::*;
        match &self {
            Clear => cmd::stack_clear(config),
            Drop(arg) => cmd::stack_drop(config, PosIntArg::parse(&arg.arg, 1)?),
            Keep(arg) => cmd::stack_keep(config, PosIntArg::parse(&arg.arg, 10)?),
            Ls => cmd::list_stack(config),
        }
    }
}

impl TaskCommands {
    /// Execute the action associated with the current variant.
    ///
    /// ## Errors
    ///
    /// - Return [`Error`]s for particular commands failing.
    /// - Return [`Error::InvalidCommand`] if the subcommand is not recognized and no alias
    /// matches.
    pub fn run(&self, config: &Config) -> Result<()> {
        use TaskCommands::*;
        match &self {
            Discard => cmd::discard_last_entry(config),
            Now => cmd::reset_last_entry(config),
            Ignore => cmd::ignore_last_entry(config),
            Rewrite(args) => cmd::rewrite_last_entry(config, &args.args),
        }
    }
}

impl ReportCommands {
    /// Execute the action associated with the current variant.
    ///
    /// ## Errors
    ///
    /// - Return [`Error`]s for particular commands failing.
    /// - Return [`Error::InvalidCommand`] if the subcommand is not recognized and no alias
    /// matches.
    pub fn run(&self, config: &Config) -> Result<()> {
        use ReportCommands::*;
        match &self {
            Detail(args) => cmd::report_daily(config, &args.args),
            Summary(args) => cmd::report_summary(config, &args.args),
            Hours(args) => cmd::report_hours(config, &args.args),
            Events(args) => cmd::report_events(config, &args.args),
            Chart(args) => cmd::chart_daily(config, &args.args),
        }
    }
}