use std::env;
use std::env::VarError;

#[macro_use]
extern crate itconfig;


#[test]
#[should_panic(expected = "Environment variable \"MISS_VARIABLE\" is missing")]
fn should_panic_if_miss_env_variable() {
    config! {
        MISS_VARIABLE: bool,
    }

    cfg::init();
}


#[test]
fn one_variable() {
    env::set_var("DEBUG", "t");

    config! {
        DEBUG: bool,
    }

    cfg::init();
    assert_eq!(cfg::DEBUG(), true);
    env::remove_var("DEBUG");
}

#[test]
fn one_variable_with_default_value() {
    config! {
        DEBUG: bool => true,
    }

    cfg::init();
    assert_eq!(cfg::DEBUG(), true);
}

#[test]
fn few_variables_with_default_value() {
    config! {
        FOO: bool => true,
        BAR: bool => false,
    }

    cfg::init();
    assert_eq!(cfg::FOO(), true);
    assert_eq!(cfg::BAR(), false);
}

#[test]
fn different_types_with_default_value() {
    config! {
        NUMBER: i32 => 30,
        BOOL: bool => true,
        STR: String => "str",
        STRING: String => "string".to_string(),
    }

    cfg::init();
    assert_eq!(cfg::NUMBER(), 30);
    assert_eq!(cfg::BOOL(), true);
    assert_eq!(cfg::STR(), "str".to_string());
    assert_eq!(cfg::STRING(), "string".to_string());
}

#[test]
fn convert_bool_type_value_from_env() {
    env::set_var("T_BOOL", "t");
    env::set_var("TRUE_BOOL", "true");
    env::set_var("NUM_BOOL", "1");
    env::set_var("ON_BOOL", "on");
    env::set_var("CAMEL_CASE", "True");
    env::set_var("FALSE_BOOL", "false");

    config! {
        T_BOOL: bool,
        TRUE_BOOL: bool,
        NUM_BOOL: bool,
        ON_BOOL: bool,
        CAMEL_CASE: bool,
        FALSE_BOOL: bool,

    }

    cfg::init();
    assert_eq!(cfg::T_BOOL(), true);
    assert_eq!(cfg::TRUE_BOOL(), true);
    assert_eq!(cfg::NUM_BOOL(), true);
    assert_eq!(cfg::ON_BOOL(), true);
    assert_eq!(cfg::CAMEL_CASE(), true);
    assert_eq!(cfg::FALSE_BOOL(), false);
}

#[test]
fn convert_number_type_value_from_env() {
    env::set_var("I8", "10");
    env::set_var("I16", "10");
    env::set_var("I32", "10");
    env::set_var("I64", "10");
    env::set_var("I128", "10");
    env::set_var("ISIZE","10");
    env::set_var("U8", "10");
    env::set_var("U16", "10");
    env::set_var("U32", "10");
    env::set_var("U64", "10");
    env::set_var("U128", "10");
    env::set_var("USIZE","10");
    env::set_var("F32", "10");
    env::set_var("F64","10");

    config! {
        I8: i8,
        I16: i16,
        I32: i32,
        I64: i64,
        I128: i128,
        ISIZE: isize,
        U8: u8,
        U16: u16,
        U32: u32,
        U64: u64,
        U128: u128,
        USIZE: usize,
        F32: f32,
        F64: f64,
    }

    cfg::init();
    assert_eq!(cfg::I8(), 10);
    assert_eq!(cfg::I16(), 10);
    assert_eq!(cfg::I32(), 10);
    assert_eq!(cfg::I64(), 10);
    assert_eq!(cfg::ISIZE(), 10);
    assert_eq!(cfg::U8(), 10);
    assert_eq!(cfg::U16(), 10);
    assert_eq!(cfg::U32(), 10);
    assert_eq!(cfg::U64(), 10);
    assert_eq!(cfg::USIZE(), 10);
    assert_eq!(cfg::F32(), 10.0);
    assert_eq!(cfg::F64(), 10.0);
}


#[test]
fn change_configuration_module_name() {
    config! {
        #![mod_name = custom_config_name]

        DEBUG: bool => true,
    }

    custom_config_name::init();
    assert_eq!(custom_config_name::DEBUG(), true);
}


#[test]
fn configuration_with_namespace() {
    env::set_var("DB_HOST", "t");

    config! {
        DEBUG: bool => true,

        DB {
            HOST: bool,
            PORT: bool => true,
            USERNAME: bool => true,
        }

        APP {}
    }

    cfg::init();
    assert_eq!(cfg::DEBUG(), true);
    assert_eq!(cfg::DB::HOST(), true);
}

#[test]
fn configuration_with_nested_namespaces() {
    config! {
        FIRST {
            SECOND {
                THIRD {
                    FOO: u32 => 50,
                }
            }
        }
    }

    cfg::init();
    assert_eq!(cfg::FIRST::SECOND::THIRD::FOO(), 50);
}

#[cfg(feature = "meta_namespace")]
#[test]
fn configuration_namespaces_with_custom_meta() {
    config! {
        FIRST {
            #[cfg(feature = "meta_namespace")]
            SECOND {
                THIRD {
                    FOO: u32 => 50,
                }
            }
        }
    }

    cfg::init();
    assert_eq!(cfg::FIRST::SECOND::THIRD::FOO(), 50);
}

#[test]
fn configuration_variables_and_namespace_in_lowercase() {
    env::set_var("TESTING", "t");
    env::set_var("NAMESPACE_FOO", "t");

    config! {
        testing: bool,

        namespace {
            foo: bool,
        }
    }

    cfg::init();
    assert_eq!(cfg::testing(), true);
    assert_eq!(cfg::namespace::foo(), true);
}


#[test]
fn custom_environment_name_for_variable() {
    env::set_var("MY_CUSTOM_NAME", "95");

    config! {
        #[env_name = "MY_CUSTOM_NAME"]
        PER_PAGE: i32,

        APP {
            #[env_name = "MY_CUSTOM_NAME"]
            RECIPES_PER_PAGE: i32,
        }
    }

    cfg::init();
    assert_eq!(cfg::PER_PAGE(), 95);
    assert_eq!(cfg::APP::RECIPES_PER_PAGE(), 95);
}

#[test]
fn stranger_meta_data() {
    env::set_var("MY_CUSTOM_NAME", "95");

    config! {
        #[cfg(feature = "postgres")]
        #[env_name = "MY_CUSTOM_NAME"]
        DATABASE_URL: String,

        #[cfg(not(feature = "postgres"))]
        #[env_name = "MY_CUSTOM_NAME"]
        DATABASE_URL: i32,
    }

    cfg::init();
    #[cfg(not(feature = "postgres"))]
    assert_eq!(cfg::DATABASE_URL(), 95);

    #[cfg(feature = "postgres")]
    assert_eq!(cfg::DATABASE_URL(), "95");
}

#[test]
fn setting_default_env_variable() {
    config! {
        DEFAULT_ENV_STRING: String => "localhost",
        DEFAULT_ENV_BOOLEAN: bool => true,
        DEFAULT_ENV_UINT: u32 => 40,
        DEFAULT_ENV_FLOAT: f64 => 40.9,
    }

    cfg::init();

    assert_eq!(env::var("DEFAULT_ENV_STRING"), Ok("localhost".to_string()));
    assert_eq!(env::var("DEFAULT_ENV_BOOLEAN"), Ok("true".to_string()));
    assert_eq!(env::var("DEFAULT_ENV_UINT"), Ok("40".to_string()));
    assert_eq!(env::var("DEFAULT_ENV_FLOAT"), Ok("40.9".to_string()));
}


#[test]
fn concatenate_environment_variables() {
    env::set_var("POSTGRES_USERNAME", "user");
    env::set_var("POSTGRES_PASSWORD", "pass");
    env::set_var("POSTGRES_HOST", "localhost");
    env::set_var("POSTGRES_DB", "test");

    config! {
        DATABASE_URL < (
            "postgres://",
            POSTGRES_USERNAME,
            ":",
            POSTGRES_PASSWORD,
            "@",
            POSTGRES_HOST,
            "/",
            POSTGRES_DB,
        ),
    }

    cfg::init();
    assert_eq!(cfg::DATABASE_URL(), String::from("postgres://user:pass@localhost/test"));
}


#[test]
fn setting_default_concat_env_variable() {
    env::set_var("SETTING_DEFAULT_CONCAT_ENV_VARIABLE", "custom");

    config! {
        DEFAULT_CONCAT_ENV < (
            "string",
            "/",
            SETTING_DEFAULT_CONCAT_ENV_VARIABLE,
        ),
    }

    cfg::init();
    assert_eq!(env::var("DEFAULT_CONCAT_ENV"), Ok("string/custom".to_string()));
}


#[test]
#[should_panic(expected = "Environment variable \"PG_USERNAME\" is missing")]
fn concatenate_not_defined_environment_variables() {
    config! {
        DATABASE_URL < (
            "postgres://",
            PG_USERNAME,
            ":",
            PG_PASSWORD,
            "@",
            PG_HOST,
            "/",
            PG_DB,
        ),
    }
    cfg::init();
}


#[test]
fn default_value_for_concatenate_env_parameter() {
    config! {
        CONCATENATED_DATABASE_URL < (
            "postgres://",
            NOT_DEFINED_PG_USERNAME => "user",
            ":",
            NOT_DEFINED_PG_PASSWORD => "pass",
            "@",
            NOT_DEFINED_PG_HOST => "localhost:5432",
            "/",
            NOT_DEFINED_PG_DB => "test",
        ),
    }

    cfg::init();
    assert_eq!(
        env::var("CONCATENATED_DATABASE_URL"),
        Ok("postgres://user:pass@localhost:5432/test".to_string())
    );
}

#[test]
fn envname_meta_for_concatenated_env_variable() {
    config! {
        #[env_name = "CUSTOM_CONCAT_ENVNAME"]
        CONCAT_ENVVAR < (
            "postgres://",
            NOT_DEFINED_PG_USERNAME => "user",
            ":",
            NOT_DEFINED_PG_PASSWORD => "pass",
            "@",
            NOT_DEFINED_PG_HOST => "localhost:5432",
            "/",
            NOT_DEFINED_PG_DB => "test",
        ),
    }

    cfg::init();
    assert_eq!(
        env::var("CUSTOM_CONCAT_ENVNAME"),
        Ok("postgres://user:pass@localhost:5432/test".to_string())
    );
    assert_eq!(env::var("CONCAT_ENVVAR"), Err(VarError::NotPresent));
}

#[test]
fn concatenated_environment_variable_in_namespace() {
    config! {
        CONCATED_NAMESPACE {
            CONCAT_ENVVAR < (
                "postgres://",
                NOT_DEFINED_PG_USERNAME => "user",
                ":",
                NOT_DEFINED_PG_PASSWORD => "pass",
                "@",
                NOT_DEFINED_PG_HOST => "localhost:5432",
                "/",
                NOT_DEFINED_PG_DB => "test",
            ),
        }
    }

    cfg::init();
    assert_eq!(
        env::var("CONCATED_NAMESPACE_CONCAT_ENVVAR"),
        Ok("postgres://user:pass@localhost:5432/test".to_string())
    );
    assert_eq!(env::var("CONCAT_ENVVAR"), Err(VarError::NotPresent));
}


#[test]
#[cfg(feature = "static")]
fn static_variables() {
    config! {
        static STATIC_STR => "test",
        static STATIC_STRING: String => "test",
        static STATIC_I8: i8 => 1,
        static STATIC_I16: i16 => 1,
        static STATIC_I32: i32 => 1,
        static STATIC_I64: i64 => 1,
        static STATIC_I128: i128 => 1,
        static STATIC_ISIZE: isize => 1,
        static STATIC_U8: u8 => 1,
        static STATIC_U16: u16 => 1,
        static STATIC_U32: u32 => 1,
        static STATIC_U64: u64 => 1,
        static STATIC_U128: u128 => 1,
        static STATIC_USIZE: usize => 1,
        static STATIC_F32: f32 => 1,
        static STATIC_F64: f64 => 1,
        static STATIC_CONCAT_VARIABLE < (
            "static ",
            STATIC_CONCAT_PART => "part",
        ),
    }

    cfg::init();

    assert_eq!(cfg::STATIC_STR(), "test");
    assert_eq!(cfg::STATIC_STRING(), "test".to_string());
    assert_eq!(cfg::STATIC_I8(), 1);
    assert_eq!(cfg::STATIC_I16(), 1);
    assert_eq!(cfg::STATIC_I32(), 1);
    assert_eq!(cfg::STATIC_I64(), 1);
    assert_eq!(cfg::STATIC_I128(), 1);
    assert_eq!(cfg::STATIC_ISIZE(), 1);
    assert_eq!(cfg::STATIC_U8(), 1);
    assert_eq!(cfg::STATIC_U16(), 1);
    assert_eq!(cfg::STATIC_U32(), 1);
    assert_eq!(cfg::STATIC_U64(), 1);
    assert_eq!(cfg::STATIC_U128(), 1);
    assert_eq!(cfg::STATIC_USIZE(), 1);
    assert_eq!(cfg::STATIC_F32(), 1.0);
    assert_eq!(cfg::STATIC_F64(), 1.0);
    assert_eq!(cfg::STATIC_CONCAT_VARIABLE(), "static part".to_string())
}