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

use crate::stage0_config::{PleaseConfigBuilder, PleaseProjectConfigBuilder};

pub fn get_from_environment(vars: std::env::Vars) -> PleaseConfigBuilder {
    let vars: HashMap<String, String> = vars.collect();

    let env = detect_environment(&vars);

    match env {
        ExecutionEnvironment::Local => PleaseConfigBuilder {
            project: Some(PleaseProjectConfigBuilder {
                source: Some(PathBuf::from(".")),
                ..Default::default()
            }),
            settings: None,
        },
        ExecutionEnvironment::Drone => PleaseConfigBuilder {
            project: Some(PleaseProjectConfigBuilder {
                owner: Some(
                    vars.get("DRONE_REPO_OWNER")
                        .expect("DRONE_REPO_OWNER to be present")
                        .clone(),
                ),
                repository: Some(
                    vars.get("DRONE_REPO_NAME")
                        .expect("DRONE_REPO_NAME to be present")
                        .clone(),
                ),
                source: Some(PathBuf::from(".")),
                branch: Some(
                    vars.get("DRONE_REPO_BRANCH")
                        .expect("DRONE_REPO_BRANCH to be present")
                        .clone(),
                ),
            }),
            settings: None,
        },
    }
}

pub fn detect_environment(vars: &HashMap<String, String>) -> ExecutionEnvironment {
    if vars.get("DRONE").is_some() {
        return ExecutionEnvironment::Drone;
    }

    ExecutionEnvironment::Local
}

pub enum ExecutionEnvironment {
    Local,
    Drone,
}