use bollard::container::{StartContainerOptions, CreateContainerOptions, Config, NetworkingConfig};
use bollard::models::{EndpointSettings, EndpointIpamConfig};
use bollard::errors::Error;
use std::collections::hash_map::HashMap;

pub struct Container {
    name: String,
    start: bool,
    ip: String,
    net: String,
    id: Option<String>,
}

impl Container {
    pub async fn new(docker: bollard::Docker,
                name: String,
                ip: String,
                net: String) -> Result<Container, Error> {

        let mut container = Container {
            name: name,
            ip: ip,
            net: net,
            start: false,
            id: None,
        };

        match container.create(docker).await {
            Ok(c) => {
                container.start=true;
                container.id = Some(c);
                Ok(container)
            }
            Err(e) => Err(e),
        }
    }

    async fn create(&self, docker: bollard::Docker) -> Result<String, Error>{
        let create = docker.create_container(Some(
                                        create_options(self.name.clone())),
                                        create_config(self.ip.clone(), self.net.clone()))
                                        .await?;
        docker.start_container(&self.name, None::<StartContainerOptions<String>>).await?;
        return Ok(create.id);
    }

    pub fn get_id(&self) -> String {
        match &self.id {
            Some(id) => id.clone(),
            None => String::from(""),
        }
    }
}
fn create_config(ip: String, net: String) -> Config<String> {
    let endpoint = EndpointSettings {
        ipam_config: Some(EndpointIpamConfig{
                ipv4_address: Some(ip),
                ..Default::default()
            }),
        ..Default::default()
    };
    let mut hash = HashMap::new();
    hash.insert(net, endpoint);
    let net = NetworkingConfig {
        endpoints_config: hash
    };
    let env = vec!["EULA=TRUE".to_string()];
    Config {
        image: Some("itzg/minecraft-server:latest".to_string()),
        env: Some(env),
        networking_config: Some(net),
        ..Default::default()
    }
}

fn create_options(name: String) -> CreateContainerOptions<String> {
    CreateContainerOptions{
        name: name,
        platform: None,
    }
}

async fn create(docker: bollard::Docker, name: String, ip: String, net: String) -> Result<String, Error>{
    let create = docker.create_container(Some(create_options(name.clone())), create_config(ip, net)).await?;
    docker.start_container(&name, None::<StartContainerOptions<String>>).await?;
    return Ok(create.id);
}