#![warn(missing_docs)]
#![forbid(unsafe_code)]
pub mod error;
pub mod storage;

use std::path::PathBuf;
use std::str::FromStr;

pub use crate::error::{Error, Result};
use clap::{Parser, Subcommand};

use crossbeam_channel::Sender;
use derive_more::Display;
pub use storage::{
    XvcLocalStorage, XvcStorage, XvcStorageEvent, XvcStorageGuid, XvcStorageOperations,
};

use xvc_ecs;
use xvc_ecs::XvcStore;

use xvc_core::XvcRoot;
use xvc_logging::XvcOutputLine;

/// Storage (on the cloud) management commands
#[derive(Debug, Parser)]
#[command(name = "storage", about = "")]
pub struct StorageCLI {
    #[command(subcommand)]
    pub subcommand: StorageSubCommand,
}

/// Remote subcommands
#[derive(Debug, Clone, Parser)]
#[command(about = "Manage storages containing tracked file content")]
pub enum StorageSubCommand {
    /// list all remotes
    #[command()]
    List,
    /// Remove a remote
    #[command()]
    Remove {
        /// Name of the remote to be deleted
        #[arg(long)]
        name: String,
    },

    #[command(subcommand)]
    New(StorageNewSubCommand),
}

/// Add new remotes
#[derive(Debug, Clone, Subcommand)]
#[command(about = "add new remotes")]
pub enum StorageNewSubCommand {
    /// add a new local remote
    #[command()]
    Local {
        /// Directory to be set as a remote
        #[arg(long)]
        path: PathBuf,
        #[arg(long, short)]
        name: String,
    },

    /// add a new generic remote
    #[command()]
    Generic {
        /// Name of the remote
        ///
        /// This must be unique among all remotes of the project
        #[arg(long = "name", short = 'n')]
        name: String,
        /// Command to initialize the remote. This command is run once after defining the remote.
        ///
        /// You can use {URL} and {DIR}  as shortcuts.
        #[arg(long = "init", short = 'i')]
        init_command: String,
        /// Command to list the files in remote
        ///
        /// You can use {URL} and {DIR} placeholders and define values for these with --url and --dir options.
        #[arg(long = "list", short = 'l')]
        list_command: String,
        /// Command to download a file from remote.
        ///
        /// You can use {URL} and {DIR} placeholders and define values for these with --url and --dir options.
        #[arg(long = "download", short = 'd')]
        download_command: String,
        /// Command to upload a file to remote.
        ///
        /// You can use {URL} and {DIR} placeholders and define values for these with --url and --dir options.
        #[arg(long = "upload", short = 'u')]
        upload_command: String,
        /// The delete command to remove a file from remote
        /// You can use {URL} and {DIR} placeholders and define values for these with --url and --dir options.
        #[arg(long = "delete", short = 'D')]
        delete_command: String,
        /// Number of maximum processes to run simultaneously
        #[arg(long = "processes", short = 'M', default_value_t = 1)]
        max_processes: usize,
        /// You can set a string to replace {URL} placeholder in commands
        #[arg(long)]
        url: Option<String>,
        /// You can set a string to replace {DIR} placeholder in commands
        #[arg(long)]
        storage_dir: Option<String>,
    },

    /// add a new rsync remote
    #[command()]
    Rsync {
        /// Name of the remote
        ///
        /// This must be unique among all remotes of the project
        #[arg(long = "name", short = 'n')]
        name: String,
        /// Hostname for the connection in the form host.example.com  (without @, : or protocol)
        #[arg(long)]
        host: String,
        /// Port number for the connection in the form 22.
        /// Doesn't add port number to connection string if not given.
        #[arg(long)]
        port: Option<usize>,
        /// User name for the connection, the part before @ in user@example.com (without @,
        /// hostname).
        /// User name isn't included in connection strings if not given.
        #[arg(long)]
        user: Option<String>,
        /// Remote directory in the host to store the files.
        #[arg(long)]
        storage_dir: String,
    },

    #[cfg(feature = "s3")]
    /// Add a new S3 remote
    #[command()]
    S3 {
        /// Name of the remote
        ///
        /// This must be unique among all remotes of the project
        #[arg(long = "name", short = 'n')]
        name: String,
        /// You can set a directory in the bucket with this prefix
        #[arg(long, default_value = "")]
        remote_prefix: String,
        /// S3 bucket name
        #[arg(long)]
        bucket_name: String,
        /// AWS region
        #[arg(long)]
        region: String,
    },

    #[cfg(feature = "minio")]
    /// Add a new Minio remote
    #[command()]
    Minio {
        /// Name of the remote
        ///
        /// This must be unique among all remotes of the project
        #[arg(long = "name", short = 'n')]
        name: String,
        /// Minio server url in the form https://myserver.example.com:9090
        #[arg(long)]
        endpoint: String,
        /// Bucket name
        #[arg(long)]
        bucket_name: String,
        /// Region of the server
        #[arg(long)]
        region: String,
        /// You can set a directory in the bucket with this prefix
        #[arg(long, default_value = "")]
        remote_prefix: String,
    },

    #[cfg(feature = "digital-ocean")]
    /// Add a new Digital Ocean remote
    #[command()]
    DigitalOcean {
        /// Name of the remote
        ///
        /// This must be unique among all remotes of the project
        #[arg(long = "name", short = 'n')]
        name: String,
        /// Bucket name
        #[arg(long)]
        bucket_name: String,
        /// Region of the server
        #[arg(long)]
        region: String,
        /// You can set a directory in the bucket with this prefix
        #[arg(long, default_value = "")]
        remote_prefix: String,
    },

    #[cfg(feature = "r2")]
    /// Add a new R2 remote
    #[command()]
    R2 {
        /// Name of the remote
        ///
        /// This must be unique among all remotes of the project
        #[arg(long = "name", short = 'n')]
        name: String,
        /// R2 account ID
        #[arg(long)]
        account_id: String,
        /// Bucket name
        #[arg(long)]
        bucket_name: String,
        /// You can set a directory in the bucket with this prefix
        #[arg(long, default_value = "")]
        remote_prefix: String,
    },

    #[cfg(feature = "gcs")]
    /// Add a new Google Cloud Storage remote
    #[command()]
    Gcs {
        /// Name of the remote
        ///
        /// This must be unique among all remotes of the project
        #[arg(long = "name", short = 'n')]
        name: String,
        /// Bucket name
        #[arg(long)]
        bucket_name: String,
        /// Region of the server, e.g., europe-west3
        #[arg(long)]
        region: String,
        /// You can set a directory in the bucket with this prefix
        #[arg(long, default_value = "")]
        remote_prefix: String,
    },

    #[cfg(feature = "wasabi")]
    /// Add a new Wasabi remote
    #[command()]
    Wasabi {
        /// Name of the remote
        ///
        /// This must be unique among all remotes of the project
        #[arg(long = "name", short = 'n')]
        name: String,
        /// Bucket name
        #[arg(long)]
        bucket_name: String,
        /// Endpoint for the server, complete with the region if there is
        ///
        /// e.g. for eu-central-1 region, use s3.eu-central-1.wasabisys.com as the endpoint.
        #[arg(long, default_value = "s3.wasabisys.com")]
        endpoint: String,
        /// You can set a directory in the bucket with this prefix
        #[arg(long, default_value = "")]
        storage_prefix: String,
    },
}

/// Specifies a storage by either a name or a GUID.
///
/// Name is specified with `--name` option of most of the storage types.
/// Guid is generated or loaded in [XvcStorageOperations::init] operations and
/// kept in Storage structs.
#[derive(Debug, Clone, PartialEq, Eq, Display)]
pub enum StorageIdentifier {
    Name(String),
    Uuid(uuid::Uuid),
}

impl FromStr for StorageIdentifier {
    /// This tries to parse `s` as a [Uuid]. If it can't it
    /// considers it a name.
    ///
    /// The only way this fails is when `s` cannot be converted to string.
    /// That's very unlikely.
    fn from_str(s: &str) -> Result<Self> {
        match uuid::Uuid::parse_str(s) {
            Ok(uuid) => Ok(Self::Uuid(uuid)),
            Err(_) => Ok(Self::Name(s.to_string())),
        }
    }

    type Err = crate::Error;
}

/// Entry point for `xvc storage` group of commands.
///
/// It matches the subcommand in [StorageCLI::subcommand] and runs the
/// appropriate function.
///
/// Other arguments are passed to subcommands.
pub fn cmd_storage(
    input: std::io::StdinLock,
    output_snd: Sender<XvcOutputLine>,
    xvc_root: &XvcRoot,
    opts: StorageCLI,
) -> Result<()> {
    match opts.subcommand {
        StorageSubCommand::List => cmd_storage_list(input, output_snd, xvc_root),
        StorageSubCommand::Remove { name } => cmd_storage_remove(input, output_snd, xvc_root, name),
        StorageSubCommand::New(new) => cmd_storage_new(input, output_snd, xvc_root, new),
    }
}

/// Configure a new storage. 
/// 
/// The available storages and their configuration is dependent to compilation.
/// In minimum, it includes [local][cmd_storage_new_local] and
/// [generic][cmd_storage_new_generic]. 
/// 
/// This function matches [StorageNewSubCommand] and calls the appropriate
/// function from child modules. Most of the available options are behind 
/// feature flags, that also guard the modules. 
fn cmd_storage_new(
    input: std::io::StdinLock,
    output_snd: Sender<XvcOutputLine>,
    xvc_root: &XvcRoot,
    sc: StorageNewSubCommand,
) -> Result<()> {
    match sc {
        StorageNewSubCommand::Local { path, name } => {
            storage::local::cmd_storage_new_local(input, output_snd, xvc_root, path, name)
        }
        StorageNewSubCommand::Generic {
            name,
            init_command,
            list_command,
            download_command,
            upload_command,
            delete_command,
            max_processes,
            url,
            storage_dir: remote_dir,
        } => storage::generic::cmd_storage_new_generic(
            input,
            output_snd,
            xvc_root,
            name,
            url,
            remote_dir,
            max_processes,
            init_command,
            list_command,
            download_command,
            upload_command,
            delete_command,
        ),
        #[cfg(feature = "s3")]
        StorageNewSubCommand::S3 {
            name,
            remote_prefix,
            bucket_name,
            region,
        } => storage::s3::cmd_new_s3(
            input,
            output_snd,
            xvc_root,
            name,
            region,
            bucket_name,
            remote_prefix,
        ),
        #[cfg(feature = "minio")]
        StorageNewSubCommand::Minio {
            name,
            endpoint,
            bucket_name,
            remote_prefix,
            region,
        } => storage::minio::cmd_new_minio(
            input,
            output_snd,
            xvc_root,
            name,
            endpoint,
            bucket_name,
            region,
            remote_prefix,
        ),
        #[cfg(feature = "digital-ocean")]
        StorageNewSubCommand::DigitalOcean {
            name,
            bucket_name,
            region,
            remote_prefix,
        } => storage::digital_ocean::cmd_new_digital_ocean(
            input,
            output_snd,
            xvc_root,
            name,
            bucket_name,
            region,
            remote_prefix,
        ),
        #[cfg(feature = "r2")]
        StorageNewSubCommand::R2 {
            name,
            account_id,
            bucket_name,
            remote_prefix,
        } => storage::r2::cmd_new_r2(
            input,
            output_snd,
            xvc_root,
            name,
            account_id,
            bucket_name,
            remote_prefix,
        ),
        #[cfg(feature = "gcs")]
        StorageNewSubCommand::Gcs {
            name,
            bucket_name,
            region,
            remote_prefix,
        } => storage::gcs::cmd_new_gcs(
            input,
            output_snd,
            xvc_root,
            name,
            bucket_name,
            region,
            remote_prefix,
        ),
        #[cfg(feature = "wasabi")]
        StorageNewSubCommand::Wasabi {
            name,
            bucket_name,
            endpoint,
            storage_prefix,
        } => storage::wasabi::cmd_new_wasabi(
            input,
            output_snd,
            xvc_root,
            name,
            bucket_name,
            endpoint,
            storage_prefix,
        ),
        StorageNewSubCommand::Rsync {
            name,
            host,
            port,
            user,
            storage_dir,
        } => storage::rsync::cmd_new_rsync(
            input,
            output_snd,
            xvc_root,
            name,
            host,
            port,
            user,
            storage_dir,
        ),
    }
}

/// Removes a storage from the configurations. 
/// 
/// This doesn't remove the history associated with them. 
fn cmd_storage_remove(
    input: std::io::StdinLock,
    output_snd: Sender<XvcOutputLine>,
    xvc_root: &XvcRoot,
    name: String,
) -> Result<()> {
    todo!()
}

/// Lists all available storages. 
/// 
/// It runs [XvcStorage::display] and lists all elements line by line to
/// `output_snd`. 
fn cmd_storage_list(
    _input: std::io::StdinLock,
    output_snd: Sender<XvcOutputLine>,
    xvc_root: &XvcRoot,
) -> Result<()> {
    let store: XvcStore<XvcStorage> = xvc_root.load_store()?;

    for (_, s) in store.iter() {
        output_snd.send(XvcOutputLine::Output(format!("{}\n", s)))?;
    }

    Ok(())
}