type ConfigureRemoteFn = Box<dyn FnMut(crate::Remote<'_>) -> Result<crate::Remote<'_>, crate::remote::init::Error>>;

/// A utility to collect configuration on how to fetch from a remote and possibly create a working tree locally.
pub struct Prepare {
    /// A freshly initialized repository which is owned by us, or `None` if it was handed to the user
    repo: Option<crate::Repository>,
    /// The name of the remote, which defaults to `origin` if not overridden.
    remote_name: Option<String>,
    /// A function to configure a remote prior to fetching a pack.
    configure_remote: Option<ConfigureRemoteFn>,
    /// Options for preparing a fetch operation.
    #[cfg(any(feature = "async-network-client", feature = "blocking-network-client"))]
    fetch_options: crate::remote::ref_map::Options,
    /// The url to clone from
    #[allow(dead_code)]
    url: git_url::Url,
}

///
#[cfg(feature = "blocking-network-client")]
pub mod fetch {
    /// The error returned by [`Prepare::fetch_only()`][super::Prepare::fetch_only()].
    #[derive(Debug, thiserror::Error)]
    #[allow(missing_docs)]
    pub enum Error {
        #[error(transparent)]
        Connect(#[from] crate::remote::connect::Error),
        #[error(transparent)]
        PrepareFetch(#[from] crate::remote::fetch::prepare::Error),
        #[error(transparent)]
        Fetch(#[from] crate::remote::fetch::Error),
        #[error(transparent)]
        RemoteConfiguration(#[from] crate::remote::init::Error),
        #[error("Default remote configured at `clone.defaultRemoteName` is invalid")]
        RemoteName(#[from] crate::remote::name::Error),
        #[error("Failed to load repo-local git configuration before writing")]
        LoadConfig(#[from] git_config::file::init::from_paths::Error),
        #[error("Failed to store configured remote in memory")]
        SaveConfig(#[from] crate::remote::save::AsError),
        #[error("Failed to write repository configuration to disk")]
        SaveConfigIo(#[from] std::io::Error),
    }
}

///
pub mod prepare {
    use std::convert::TryInto;

    use crate::{clone::Prepare, Repository};

    /// The error returned by [`Prepare::new()`].
    #[derive(Debug, thiserror::Error)]
    #[allow(missing_docs)]
    pub enum Error {
        #[error(transparent)]
        Init(#[from] crate::init::Error),
        #[error(transparent)]
        UrlParse(#[from] git_url::parse::Error),
    }

    /// Instantiation
    impl Prepare {
        /// Create a new repository at `path` with `crate_opts` which is ready to clone from `url`, possibly after making additional adjustments to
        /// configuration and settings.
        ///
        /// Note that this is merely a handle to perform the actual connection to the remote, and if any of it fails the freshly initialized repository
        /// will be removed automatically as soon as this instance drops.
        pub fn new<Url, E>(
            url: Url,
            path: impl AsRef<std::path::Path>,
            create_opts: crate::create::Options,
            open_opts: crate::open::Options,
        ) -> Result<Self, Error>
        where
            Url: TryInto<git_url::Url, Error = E>,
            git_url::parse::Error: From<E>,
        {
            let url = url.try_into().map_err(git_url::parse::Error::from)?;
            let repo = crate::ThreadSafeRepository::init_opts(path, create_opts, open_opts)?.to_thread_local();
            Ok(Prepare {
                url,
                #[cfg(any(feature = "async-network-client", feature = "blocking-network-client"))]
                fetch_options: Default::default(),
                repo: Some(repo),
                remote_name: None,
                configure_remote: None,
            })
        }
    }

    /// Modification
    impl Prepare {
        /// Fetch a pack and update local branches according to refspecs, providing `progress` and checking `should_interrupt` to stop
        /// the operation.
        /// On success, the persisted repository is returned, and this method must not be called again to avoid a **panic**.
        /// On error, the method may be called again to retry as often as needed.
        ///
        /// Note that all data we created will be removed once this instance drops if the operation wasn't successful.
        #[cfg(feature = "blocking-network-client")]
        pub fn fetch_only(
            &mut self,
            progress: impl crate::Progress,
            should_interrupt: &std::sync::atomic::AtomicBool,
        ) -> Result<(Repository, crate::remote::fetch::Outcome), super::fetch::Error> {
            let repo = self
                .repo
                .as_mut()
                .expect("user error: multiple calls are allowed only until it succeeds");

            let remote_name = match self.remote_name.as_deref() {
                Some(name) => name.to_owned(),
                None => repo
                    .config
                    .resolved
                    .string("clone", None, "defaultRemoteName")
                    .map(|n| crate::remote::name::validated(n.to_string()))
                    .unwrap_or_else(|| Ok("origin".into()))?,
            };

            let mut remote = repo
                .remote_at(self.url.clone())?
                .with_refspec("+refs/heads/*:refs/remotes/origin/*", crate::remote::Direction::Fetch)
                .expect("valid static spec");
            if let Some(f) = self.configure_remote.as_mut() {
                remote = f(remote)?;
            }

            let mut metadata = git_config::file::Metadata::from(git_config::Source::Local);
            let config_path = repo.git_dir().join("config");
            metadata.path = Some(config_path.clone());
            let mut config =
                git_config::File::from_paths_metadata(Some(metadata), Default::default())?.expect("one file to load");
            remote.save_as_to(remote_name, &mut config)?;
            std::fs::write(config_path, config.to_bstring())?;

            let outcome = remote
                .connect(crate::remote::Direction::Fetch, progress)?
                .prepare_fetch(self.fetch_options.clone())?
                .receive(should_interrupt)?;

            let repo_config = git_features::threading::OwnShared::make_mut(&mut repo.config.resolved);
            let ids_to_remove: Vec<_> = repo_config
                .sections_and_ids()
                .filter_map(|(s, id)| (s.meta().source == git_config::Source::Local).then(|| id))
                .collect();
            for id in ids_to_remove {
                repo_config.remove_section_by_id(id);
            }
            repo_config.append(config);

            Ok((self.repo.take().expect("still present"), outcome))
        }
    }

    /// Builder
    impl Prepare {
        /// Set additional options to adjust parts of the fetch operation that are not affected by the git configuration.
        #[cfg(any(feature = "async-network-client", feature = "blocking-network-client"))]
        pub fn with_fetch_options(mut self, opts: crate::remote::ref_map::Options) -> Self {
            self.fetch_options = opts;
            self
        }
        /// Use `f` to apply arbitrary changes to the remote that is about to be used to fetch a pack.
        ///
        /// The passed in `remote` will be un-named and pre-configured to be a default remote as we know it from git-clone.
        /// It is not yet present in the configuration of the repository,
        /// but each change it will eventually be written to the configuration prior to performing a the fetch operation.
        pub fn configure_remote(
            mut self,
            f: impl FnMut(crate::Remote<'_>) -> Result<crate::Remote<'_>, crate::remote::init::Error> + 'static,
        ) -> Self {
            self.configure_remote = Some(Box::new(f));
            self
        }

        /// Set the remote's name to the given value after it was configured using the function provided via
        /// [`configure_remote()`][Self::configure_remote()].
        ///
        /// If not set here, it defaults to `origin` or the value of `clone.defaultRemoteName`.
        pub fn with_remote_name(mut self, name: impl Into<String>) -> Result<Self, crate::remote::name::Error> {
            self.remote_name = Some(crate::remote::name::validated(name)?);
            Ok(self)
        }
    }

    /// Consumption
    impl Prepare {
        /// Persist the contained repository as is even if an error may have occurred when interacting with the remote or checking out the main working tree.
        pub fn persist(mut self) -> Repository {
            self.repo.take().expect("present and consumed once")
        }
    }

    impl Drop for Prepare {
        fn drop(&mut self) {
            if let Some(repo) = self.repo.take() {
                std::fs::remove_dir_all(repo.work_dir().unwrap_or_else(|| repo.path())).ok();
            }
        }
    }

    impl From<Prepare> for Repository {
        fn from(prep: Prepare) -> Self {
            prep.persist()
        }
    }
}