Ok(file_path.to_string_lossy().to_string())
}
fn default_zsh_histfile_path() -> Result<String, Error> {
    let base_dirs = directories::BaseDirs::new().ok_or(Error::BaseDirectory)?;

    let home = base_dirs.home_dir();
    let file_path = home.join(".histfile");

struct Import {

enum Import {
    /// Import entries from existing histdb sqlite file
    Histdb(ImportHistdb),
    /// Import entries from existing zsh histfile
    Histfile(ImportHistfile),
}
#[derive(StructOpt, Debug)]
struct ImportHistdb {

    import_file: PathBuf,
}
#[derive(StructOpt, Debug)]
struct ImportHistfile {
    #[structopt(flatten)]
    data_dir: DataDir,
    /// Path to the existing zsh histfile file
    #[structopt(short, long, default_value = into_str!(get_default_or_fail(default_zsh_histfile_path)))]

                SubCommand::Import(o) => run::import(&o.import_file, o.data_dir.data_dir),

                SubCommand::Import(s) => match s {
                    Import::Histdb(o) => run::import_histdb(&o.import_file, o.data_dir.data_dir),
                    Import::Histfile(o) => {
                        run::import_histfile(&o.import_file, o.data_dir.data_dir)
                    }
                },

    io::BufRead,

    #[error("can not open histfile: {0}")]
    OpenHistfile(std::io::Error),
    #[error("can not read line from histfile: {0}")]
    ReadHistfileLine(std::io::Error),

pub fn import(import_file: &PathBuf, data_dir: PathBuf) -> Result<(), Error> {

pub fn import_histdb(import_file: &PathBuf, data_dir: PathBuf) -> Result<(), Error> {

pub fn import_histfile(import_file: &PathBuf, data_dir: PathBuf) -> Result<(), Error> {
    #[derive(Debug)]
    struct HistfileEntry {
        time_finished: DateTime<Utc>,
        result: usize,
        command: String,
    }
    let histfile = std::fs::File::open(import_file).map_err(Error::OpenHistfile)?;
    let reader = std::io::BufReader::new(histfile);
    todo!()
}