//

// type TestResult = Result<(), Box<dyn std::error::Error>>;

use assert2::let_assert;

use crate::{config::AppConfig, f, NAME};

mod config {
    use super::*;

    use crate::config::{NextcloudConfig, TrelloConfig};
    use crate::s;

    #[test]
    fn load_config() {
        //given
        let fs = given::a_filesystem();
        let file = fs.base().join(f!("{}.toml", NAME));
        fs.file(&file)
            .write(
                [
                    "[trello]",
                    "api_key = \"trello-api-key\"",
                    "api_secret = \"trello-api-secret\"",
                    "board_name = \"trello-board-name\"",
                    "",
                    "[nextcloud]",
                    "hostname = \"nextcloud-hostname\"",
                    "username = \"nextcloud-username\"",
                    "password = \"nextcloud-password\"",
                    "board_id = 22",
                ]
                .join("\n"),
            )
            .expect("write file");
        let ctx = given::a_context(fs.as_real(), given::a_network().into(), given::a_printer());

        //when
        let_assert!(Ok(config) = AppConfig::load(&ctx));

        //then
        assert_eq!(
            config,
            AppConfig {
                trello: TrelloConfig {
                    api_key: s!("trello-api-key").into(),
                    api_secret: s!("trello-api-secret").into(),
                    board_name: s!("trello-board-name").into(),
                },
                nextcloud: NextcloudConfig {
                    hostname: s!("nextcloud-hostname").into(),
                    username: s!("nextcloud-username").into(),
                    password: s!("nextcloud-password").into(),
                    board_id: 22.into()
                }
            }
        );
    }
}

mod init {

    use test_log::test;

    use crate::{f, init::run, NAME};

    use super::given;
    use super::*;

    #[test]
    fn when_file_does_not_exist_should_create() {
        //given
        let fs = given::a_filesystem();
        let ctx = given::a_context(fs.as_real(), given::a_network().into(), given::a_printer());

        //when
        let_assert!(Ok(_) = run(&ctx));

        //then
        let path = ctx.fs.base().join(f!("{NAME}.toml"));
        let file = ctx.fs.file(&path);
        let contents = file.reader().expect("read file").to_string();
        assert_eq!(contents, include_str!("../default-config.toml"));
    }

    #[test]
    fn when_file_exists_should_err() {
        //given
        let fs = given::a_filesystem();
        let path = fs.base().join(f!("{NAME}.toml"));
        let file = fs.file(&path);
        file.write("").expect("create file");

        let ctx = given::a_context(fs.as_real(), given::a_network().into(), given::a_printer());
        //when
        let_assert!(Err(err) = run(&ctx));

        //then
        assert!(err
            .to_string()
            .contains("File already exists - not overwriting"));
    }
}

mod template {

    use std::collections::HashMap;

    use crate::template;

    #[test]
    fn expand_should_substitute_values() {
        //given
        let template = "pre{param1}mid{param2}post";
        let params = HashMap::from([("param1", "-v1-"), ("param2", "-v2-")]);

        //when
        let result = template::expand(template, params);

        //then
        assert_eq!(result, "pre-v1-mid-v2-post");
    }
}

mod given {
    use kxio::{
        fs::{FileSystem, TempFileSystem},
        net::{MockNet, Net},
        print::Printer,
    };

    use crate::Ctx;

    pub fn a_context(fs: FileSystem, net: Net, prt: Printer) -> Ctx {
        Ctx { fs, net, prt }
    }

    pub fn a_filesystem() -> TempFileSystem {
        kxio::fs::temp().expect("temp fs")
    }

    pub fn a_network() -> MockNet {
        kxio::net::mock()
    }

    pub fn a_printer() -> Printer {
        kxio::print::test()
    }
}