#[allow(clippy::missing_const_for_fn)]

#![warn(clippy::nursery)]

#![warn(rust_2018_idioms, unused_lifetimes)]

#![warn(rust_2018_idioms, unused_lifetimes, missing_debug_implementations)]
#![forbid(unsafe_code)]

use crate::run;

use crate::{
    run,
    run::{
        Display,
        TableDisplay,
    },
    store::Filter,
};

    /// Print host column
    #[structopt(long)]
    host: bool,

    /// Disable fancy formatting
    #[structopt(long)]
    disable_formatting: bool,

    /// Print host column
    #[structopt(long)]
    show_host: bool,

    status: bool,

    show_status: bool,

    #[structopt(long)]
    duration: bool,
    /// Disable fancy formatting

    no_format: bool,

    show_duration: bool,

    /// Disable printing of header
    #[structopt(long)]
    hide_header: bool,

        let no_format = self.default_args.no_format;
        let host = self.default_args.host;
        let duration = self.default_args.duration;
        let status = self.default_args.status;
        let show_pwd = self.default_args.show_pwd;
        let show_session = self.default_args.show_session;

        let format = !self.default_args.disable_formatting;
        let duration = Display::should_show(self.default_args.show_duration);
        let header = Display::should_hide(self.default_args.hide_header);
        let host = Display::should_show(self.default_args.show_host);
        let pwd = Display::should_show(self.default_args.show_pwd);
        let session = Display::should_show(self.default_args.show_session);
        let status = Display::should_show(self.default_args.show_status);

                run::default(
                    in_current,
                    folder,
                    all_hosts,
                    hostname,
                    data_dir,
                    entries_count,
                    &command,
                    no_subdirs,
                    &command_text,
                    no_format,

                let filter = Filter::default()
                    .directory(folder, in_current, no_subdirs)?
                    .hostname(hostname, all_hosts)?
                    .count(entries_count)
                    .command(command, command_text);
                let display = TableDisplay {
                    format,
                    duration,
                    header,

                    duration,

                    pwd,
                    session,

                    show_pwd,
                    show_session,
                )

                };
                run::default(&filter, &display, data_dir)

    entry::Entry,

    store::{
        filter,
        Filter,
    },

use regex::Regex;

    #[error("can not get hostname: {0}")]
    GetHostname(std::io::Error),

    #[error("{0}")]
    Filter(#[from] filter::Error),

    #[error("can not get current directory: {0}")]
    GetCurrentDir(std::io::Error),

#[allow(clippy::fn_params_excessive_bools)]
#[allow(clippy::too_many_arguments)]
#[allow(clippy::too_many_lines)]
#[allow(clippy::cognitive_complexity)]
pub fn default(
    in_current: bool,
    folder: Option<PathBuf>,
    all_hosts: bool,
    hostname: Option<String>,
    data_dir: PathBuf,
    entries_count: usize,
    command: &Option<String>,
    no_subdirs: bool,
    command_text: &Option<Regex>,
    no_format: bool,
    host: bool,
    duration: bool,
    status: bool,
    show_pwd: bool,
    show_session: bool,
) -> Result<(), Error> {
    let dir_filter = if in_current {
        Some(std::env::current_dir().map_err(Error::GetCurrentDir)?)
    } else {
        folder
    };

#[derive(Debug)]
pub struct TableDisplay {
    pub format: bool,

    let current_hostname = hostname::get()
        .map_err(Error::GetHostname)?
        .to_string_lossy()
        .to_string();

    pub duration: Display,
    pub header: Display,
    pub host: Display,
    pub pwd: Display,
    pub session: Display,
    pub status: Display,
}

    let hostname_filter = if all_hosts {
        None
    } else {
        Some(hostname.unwrap_or(current_hostname))
    };

impl Default for TableDisplay {
    fn default() -> Self {
        Self {
            format: true,

    let entries = store::new(data_dir).get_entries(
        hostname_filter,
        entries_count,
        command,
        &dir_filter,
        no_subdirs,
        command_text,
    )?;

            duration: Display::Hide,
            header: Display::Show,
            host: Display::Hide,
            pwd: Display::Hide,
            session: Display::Hide,
            status: Display::Hide,
        }
    }
}

    if no_format {
        let mut header = vec!["tmn"];

#[derive(Debug)]
pub enum Display {
    Hide,
    Show,
}

        if host {
            header.push("host")
        };

impl Default for Display {
    fn default() -> Self {
        Self::Hide
    }
}

        if duration {
            header.push("duration")
        };

impl Display {
    const fn is_show(&self) -> bool {
        match self {
            Self::Hide => false,
            Self::Show => true,
        }
    }

        if status {
            header.push("res")
        };

    pub const fn should_hide(b: bool) -> Self {
        if b {
            Self::Hide
        } else {
            Self::Show
        }
    }

        if show_session {
            header.push("ses");

    pub const fn should_show(b: bool) -> Self {
        if b {
            Self::Show
        } else {
            Self::Hide

    }
}
pub fn default(filter: &Filter, display: &TableDisplay, data_dir: PathBuf) -> Result<(), Error> {
    let entries = store::new(data_dir).get_entries(filter)?;
    dbg!(display);
    if display.format {
        default_format(display, entries)
    } else {
        default_no_format(display, entries)
    }
}

        if show_pwd {
            header.push("pwd");
        }

pub fn default_no_format(display: &TableDisplay, entries: Vec<Entry>) -> Result<(), Error> {
    let mut header = vec!["tmn"];
    if display.host.is_show() {
        header.push("host")
    };
    if display.duration.is_show() {
        header.push("duration")
    };
    if display.status.is_show() {
        header.push("res")
    };
    if display.session.is_show() {
        header.push("ses");
    }
    if display.pwd.is_show() {
        header.push("pwd");
    }

        header.push("cmd");

    header.push("cmd");

        let stdout = std::io::stdout();
        let mut handle = stdout.lock();

    let stdout = std::io::stdout();
    let mut handle = stdout.lock();

    if display.header.is_show() {

    }

        for entry in entries {
            let mut row = vec![format_timestamp(entry.time_finished)];

    for entry in entries {
        let mut row = vec![format_timestamp(entry.time_finished)];

            if host {
                row.push(entry.hostname)
            }

        if display.host.is_show() {
            row.push(entry.hostname)
        }

            if duration {
                row.push(format_duration(entry.time_start, entry.time_finished)?)
            }

        if display.duration.is_show() {
            row.push(format_duration(entry.time_start, entry.time_finished)?)
        }

            if status {
                row.push(format!("{}", entry.result))
            }

        if display.status.is_show() {
            row.push(format!("{}", entry.result))
        }

            if show_session {
                row.push(format_uuid(entry.session_id));
            }
            if show_pwd {
                row.push(format_pwd(&entry.pwd)?);
            }

        if display.session.is_show() {
            row.push(format_uuid(entry.session_id));
        }
        if display.pwd.is_show() {
            row.push(format_pwd(&entry.pwd)?);
        }

            row.push(format_command(&entry.command, no_format));

        row.push(format_command(&entry.command, display.format));

            handle
                .write_all(row.join("\t").as_bytes())
                .map_err(Error::WriteStdout)?;
            handle.write_all(b"\n").map_err(Error::WriteStdout)?;
        }
    } else {
        let mut table = Table::new();
        table.load_preset("                   ");
        table.set_content_arrangement(comfy_table::ContentArrangement::Dynamic);

        handle
            .write_all(row.join("\t").as_bytes())
            .map_err(Error::WriteStdout)?;
        handle.write_all(b"\n").map_err(Error::WriteStdout)?;
    }

        let mut header = vec![Cell::new("tmn").add_attribute(Attribute::Bold)];

    Ok(())
}

        if host {
            header.push(Cell::new("host").add_attribute(Attribute::Bold))
        };

pub fn default_format(display: &TableDisplay, entries: Vec<Entry>) -> Result<(), Error> {
    let mut table = Table::new();
    table.load_preset("                   ");
    table.set_content_arrangement(comfy_table::ContentArrangement::Dynamic);

        if duration {
            header.push(Cell::new("duration").add_attribute(Attribute::Bold))
        };

    let mut header = vec![Cell::new("tmn").add_attribute(Attribute::Bold)];

        if status {
            header.push(Cell::new("res").add_attribute(Attribute::Bold))
        };

    if display.host.is_show() {
        header.push(Cell::new("host").add_attribute(Attribute::Bold))
    };

        if show_session {
            header.push(Cell::new("ses").add_attribute(Attribute::Bold));
        }

    if display.duration.is_show() {
        header.push(Cell::new("duration").add_attribute(Attribute::Bold))
    };

        if show_pwd {
            header.push(Cell::new("pwd").add_attribute(Attribute::Bold));
        }

    if display.status.is_show() {
        header.push(Cell::new("res").add_attribute(Attribute::Bold))
    };

        header.push(Cell::new("cmd").add_attribute(Attribute::Bold));

    if display.session.is_show() {
        header.push(Cell::new("ses").add_attribute(Attribute::Bold));
    }

        table.set_header(header);

    if display.pwd.is_show() {
        header.push(Cell::new("pwd").add_attribute(Attribute::Bold));
    }

        for entry in entries {
            let mut row = vec![format_timestamp(entry.time_finished)];

    header.push(Cell::new("cmd").add_attribute(Attribute::Bold));

            if host {
                row.push(entry.hostname)
            }

    if display.header.is_show() {
        table.set_header(header);
    }

            if duration {
                row.push(format_duration(entry.time_start, entry.time_finished)?)
            }

    for entry in entries {
        let mut row = vec![format_timestamp(entry.time_finished)];

            if status {
                row.push(format!("{}", entry.result))
            }

        if display.host.is_show() {
            row.push(entry.hostname)
        }

            if show_session {
                row.push(format_uuid(entry.session_id));
            }
            if show_pwd {
                row.push(format_pwd(&entry.pwd)?);
            }

        if display.duration.is_show() {
            row.push(format_duration(entry.time_start, entry.time_finished)?)
        }

            row.push(format_command(&entry.command, no_format));

        if display.status.is_show() {
            row.push(format!("{}", entry.result))
        }

            table.add_row(row);

        if display.session.is_show() {
            row.push(format_uuid(entry.session_id));
        }
        if display.pwd.is_show() {
            row.push(format_pwd(&entry.pwd)?);

        row.push(format_command(&entry.command, display.format));

        println!("{}", table);

        table.add_row(row);

    println!("{}", table);

fn format_command(command: &str, no_format: bool) -> String {
    if no_format {

fn format_command(command: &str, format: bool) -> String {
    if format {
        command.trim().to_string()
    } else {

    } else {
        command.trim().to_string()

use crate::entry::Entry;
use regex::Regex;
use std::path::PathBuf;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum Error {
    #[error("can not get hostname: {0}")]
    GetHostname(std::io::Error),
    #[error("can not get current directory: {0}")]
    GetCurrentDir(std::io::Error),
}
#[derive(Debug, Default)]
pub struct Filter {
    hostname: Option<String>,
    directory: Option<PathBuf>,
    command: Option<String>,
    no_subdirs: bool,
    command_text: Option<Regex>,
    count: usize,
}
impl Filter {
    pub const fn get_hostname(&self) -> Option<&String> {
        self.hostname.as_ref()
    }
    pub fn hostname(self, hostname: Option<String>, all_hosts: bool) -> Result<Self, Error> {
        let current_hostname = hostname::get()
            .map_err(Error::GetHostname)?
            .to_string_lossy()
            .to_string();
        let hostname = if all_hosts {
            None
        } else {
            Some(hostname.unwrap_or(current_hostname))
        };
        Ok(Self { hostname, ..self })
    }
    pub fn directory(
        self,
        folder: Option<PathBuf>,
        in_current: bool,
        no_subdirs: bool,
    ) -> Result<Self, Error> {
        let directory = if in_current {
            Some(std::env::current_dir().map_err(Error::GetCurrentDir)?)
        } else {
            folder
        };
        Ok(Self {
            directory,
            no_subdirs,
            ..self
        })
    }
    pub fn count(self, count: usize) -> Self {
        Self { count, ..self }
    }
    pub fn command(self, command: Option<String>, command_text: Option<Regex>) -> Self {
        Self {
            command,
            command_text,
            ..self
        }
    }
    pub fn filter_entries(&self, entries: Vec<Entry>) -> Result<Vec<Entry>, Error> {
        let entries = entries
            .into_iter()
            .filter(|entry| {
                self.command
                    .as_ref()
                    .map_or(true, |command| entry.command.starts_with(command))
            })
            .filter(|entry| {
                self.directory.as_ref().map_or(true, |dir| {
                    if self.no_subdirs {
                        entry.pwd == *dir
                    } else {
                        entry.pwd.as_path().starts_with(dir)
                    }
                })
            })
            .filter(|entry| {
                self.command_text
                    .as_ref()
                    .map_or(true, |regex| regex.is_match(&entry.command))
            })
            .collect::<Vec<_>>()
            .into_iter()
            .rev()
            .take(self.count)
            .rev()
            .collect();
        Ok(entries)
    }
}

pub mod filter;

use regex::Regex;

pub use filter::Filter;

    #[error("{0}")]
    Filter(#[from] filter::Error),

    pub fn get_entries(
        &self,
        hostname: Option<String>,
        count: usize,
        command_filter: &Option<String>,
        dir_filter: &Option<PathBuf>,
        no_subdirs: bool,
        command_text: &Option<Regex>,
    ) -> Result<Vec<Entry>, Error> {
        let mut entries: Vec<_> = if let Some(hostname) = hostname {

    pub fn get_entries(&self, filter: &Filter) -> Result<Vec<Entry>, Error> {
        let mut entries: Vec<_> = if let Some(hostname) = filter.get_hostname() {

        let entries = entries
            .into_iter()
            .filter(|entry| {
                command_filter
                    .as_ref()
                    .map_or(true, |command| entry.command.starts_with(command))
            })
            .filter(|entry| {
                dir_filter.as_ref().map_or(true, |dir| {
                    if no_subdirs {
                        entry.pwd == *dir
                    } else {
                        entry.pwd.as_path().starts_with(dir)
                    }
                })
            })
            .filter(|entry| {
                command_text
                    .as_ref()
                    .map_or(true, |regex| regex.is_match(&entry.command))
            })
            .collect::<Vec<_>>()
            .into_iter()
            .rev()
            .take(count)
            .rev()
            .collect();

        let entries = filter.filter_entries(entries)?;