use crate as git;

mod commit {
    use super::*;

    #[test]
    fn should_return_sha() {
        let sha = given::a_commit_sha();
        let commit = given::a_commit_with_sha(&sha);

        assert_eq!(commit.sha(), &sha);
    }
    #[test]
    fn should_return_message() {
        let message = given::a_commit_message();
        let commit = given::a_commit_with_message(&message);

        assert_eq!(commit.message(), &message);
    }
    #[test]
    fn should_convert_from_push() {
        let sha = given::a_commit_sha();
        let message = given::a_commit_message();
        let push = given::a_webhook_push(&sha, &message);
        let commit = git::Commit::from(push);

        let expected = git::Commit::new(
            git::commit::Sha::new(sha.to_string()),
            git::commit::Message::new(message.to_string()),
        );

        assert_eq!(commit, expected);
    }
}
mod generation {
    use crate::Generation;

    #[test]
    fn should_increment() {
        let mut g = Generation::new();
        assert_eq!(g.to_string(), "0");

        g.inc();

        assert_eq!(g.to_string(), "1");
    }
}
mod gitref {
    use crate::{commit, Commit, GitRef};
    #[test]
    fn should_convert_from_commit() {
        let commit = Commit::new(
            commit::Sha::new("sha".to_string()),
            commit::Message::new("message".to_string()),
        );
        let gitref = GitRef::from(commit);

        assert_eq!(gitref.to_string(), "sha");
    }
}
mod gitremote {
    use git_next_config::{Hostname, RepoPath};

    use crate::GitRemote;

    #[test]
    fn should_return_hostname() {
        let host = Hostname::new("localhost".to_string());
        let repo_path = RepoPath::new("kemitix/git-next".to_string());
        let gr = GitRemote::new(host.clone(), repo_path);

        assert_eq!(gr.host(), &host);
    }
    #[test]
    fn should_return_repo_path() {
        let host = Hostname::new("localhost".to_string());
        let repo_path = RepoPath::new("kemitix/git-next".to_string());
        let gr = GitRemote::new(host, repo_path.clone());

        assert_eq!(gr.repo_path(), &repo_path);
    }
}
mod push {
    use crate::{commit, Commit, GitRef};

    use crate::push::Force;

    #[test]
    fn force_no_should_display() {
        assert_eq!(Force::No.to_string(), "fast-forward")
    }
    #[test]
    fn force_from_should_display() {
        let commit = Commit::new(
            commit::Sha::new("sha".to_string()),
            commit::Message::new("message".to_string()),
        );
        assert_eq!(
            Force::From(GitRef::from(commit)).to_string(),
            "force-if-from:sha"
        )
    }
}
mod repo_details {

    use std::{collections::BTreeMap, path::PathBuf};

    use git_next_config::{
        ForgeAlias, ForgeConfig, ForgeType, GitDir, Hostname, RepoAlias, RepoPath, ServerRepoConfig,
    };
    use secrecy::ExposeSecret;

    use crate::{Generation, GitRemote, RepoDetails};

    #[test]
    fn should_return_origin() {
        let rd = RepoDetails::new(
            Generation::new(),
            &RepoAlias::new("foo"),
            &ServerRepoConfig::new(
                "repo".to_string(),
                "branch".to_string(),
                None,
                None,
                None,
                None,
            ),
            &ForgeAlias::new("default".to_string()),
            &ForgeConfig::new(
                ForgeType::MockForge,
                "host".to_string(),
                "user".to_string(),
                "token".to_string(),
                BTreeMap::new(),
            ),
            GitDir::from(PathBuf::default().join("foo")),
        );

        assert_eq!(
            rd.origin().expose_secret(),
            "https://user:token@host/repo.git"
        );
    }
    #[test]
    fn should_return_git_remote() {
        let rd = RepoDetails::new(
            Generation::new(),
            &RepoAlias::new("foo"),
            &ServerRepoConfig::new(
                "user/repo".to_string(),
                "branch".to_string(),
                None,
                None,
                None,
                None,
            ),
            &ForgeAlias::new("default".to_string()),
            &ForgeConfig::new(
                ForgeType::MockForge,
                "host".to_string(),
                "user".to_string(),
                "token".to_string(),
                BTreeMap::new(),
            ),
            GitDir::from(PathBuf::default().join("foo")),
        );

        assert_eq!(
            rd.git_remote(),
            GitRemote::new(
                Hostname::new("host".to_string()),
                RepoPath::new("user/repo".to_string())
            )
        );
    }
}
// mod branch {
//     use super::*;
//     use assert2::let_assert;
//     #[test]
//     fn reset_should_fetch_then_push() {
//         // let repository = given::a_mock_open_repository();
//         let fs = given::a_filesystem();
//         let repo_detauls = given::repo_details(&fs);
//         let repository = given::a_mock_open_repository();
//         let_assert!(
//             Ok(result) = git::branch::reset(
//                 repository,
//                 &repo_details,
//                 &repo_details.branch,
//                 git_ref,
//                 force
//             )
//         );
//     }
// }
mod given {
    #![allow(dead_code)]
    //
    use crate as git;
    use config::{
        BranchName, ForgeAlias, ForgeConfig, ForgeType, GitDir, RepoAlias, RepoBranches,
        ServerRepoConfig, WebhookAuth, WebhookId,
    };
    use git_next_config as config;

    use rand::RngCore;

    use crate::RepoDetails;

    pub fn a_webhook_auth() -> WebhookAuth {
        WebhookAuth::generate()
    }

    pub enum Header {
        Valid(WebhookAuth, config::webhook::message::Body),
        Missing,
        Invalid,
    }

    pub fn a_webhook_message_body() -> config::webhook::message::Body {
        config::webhook::message::Body::new(a_name())
    }

    pub fn repo_branches() -> RepoBranches {
        RepoBranches::new(a_name(), a_name(), a_name())
    }

    pub fn a_forge_alias() -> ForgeAlias {
        ForgeAlias::new(a_name())
    }

    pub fn a_repo_alias() -> RepoAlias {
        RepoAlias::new(a_name())
    }

    pub fn a_network() -> kxio::network::MockNetwork {
        kxio::network::MockNetwork::new()
    }

    pub fn a_webhook_url(
        forge_alias: &ForgeAlias,
        repo_alias: &RepoAlias,
    ) -> git_next_config::server::WebhookUrl {
        config::server::Webhook::new(a_name()).url(forge_alias, repo_alias)
    }

    pub fn any_webhook_url() -> git_next_config::server::WebhookUrl {
        a_webhook_url(&a_forge_alias(), &a_repo_alias())
    }

    pub fn a_name() -> String {
        use rand::Rng;
        use std::iter;

        fn generate(len: usize) -> String {
            const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
            let mut rng = rand::thread_rng();
            let one_char = || CHARSET[rng.gen_range(0..CHARSET.len())] as char;
            iter::repeat_with(one_char).take(len).collect()
        }
        generate(5)
    }

    pub fn a_webhook_id() -> WebhookId {
        WebhookId::new(a_name())
    }

    pub fn a_github_webhook_id() -> i64 {
        rand::thread_rng().next_u32().into()
    }

    pub fn a_branch_name() -> BranchName {
        BranchName::new(a_name())
    }

    pub fn a_git_dir(fs: &kxio::fs::FileSystem) -> GitDir {
        let dir_name = a_name();
        let dir = fs.base().join(dir_name);
        GitDir::new(&dir)
    }

    pub fn a_forge_config() -> ForgeConfig {
        ForgeConfig::new(
            ForgeType::MockForge,
            a_name(),
            a_name(),
            a_name(),
            Default::default(), // no repos
        )
    }

    pub fn a_server_repo_config() -> ServerRepoConfig {
        let main = a_branch_name().into_string();
        let next = a_branch_name().into_string();
        let dev = a_branch_name().into_string();
        ServerRepoConfig::new(
            format!("{}/{}", a_name(), a_name()),
            main.clone(),
            None,
            Some(main),
            Some(next),
            Some(dev),
        )
    }

    pub fn a_commit() -> git::Commit {
        git::Commit::new(a_commit_sha(), a_commit_message())
    }

    pub fn a_commit_with_message(message: &git::commit::Message) -> git::Commit {
        git::Commit::new(a_commit_sha(), message.to_owned())
    }

    pub fn a_commit_with_sha(sha: &git::commit::Sha) -> git::Commit {
        git::Commit::new(sha.to_owned(), a_commit_message())
    }

    pub fn a_commit_with(sha: &git::commit::Sha, message: &git::commit::Message) -> git::Commit {
        git::Commit::new(sha.to_owned(), message.to_owned())
    }

    pub fn a_commit_message() -> git::commit::Message {
        git::commit::Message::new(a_name())
    }

    pub fn a_commit_sha() -> git::commit::Sha {
        git::commit::Sha::new(a_name())
    }

    pub fn a_webhook_push(
        sha: &git::commit::Sha,
        message: &git::commit::Message,
    ) -> config::webhook::Push {
        let branch = a_branch_name();
        config::webhook::Push::new(branch, sha.to_string(), message.to_string())
    }

    pub fn a_filesystem() -> kxio::fs::FileSystem {
        kxio::fs::temp().unwrap_or_else(|e| panic!("{}", e))
    }

    pub fn repo_details(fs: &kxio::fs::FileSystem) -> git::RepoDetails {
        let generation = git::Generation::new();
        let repo_alias = a_repo_alias();
        let server_repo_config = a_server_repo_config();
        let forge_alias = a_forge_alias();
        let forge_config = a_forge_config();
        let gitdir = a_git_dir(fs);
        RepoDetails::new(
            generation,
            &repo_alias,
            &server_repo_config,
            &forge_alias,
            &forge_config,
            gitdir,
        )
    }
}