use crate::cloud::CloudOptions;
use crate::config::HazeConfig;
use crate::image::pull_image;
use crate::service::{split_cmnd, ServiceTrait};
use crate::Result;
use bollard::models::{ContainerCreateBody, EndpointSettings, HostConfig, NetworkingConfig};
use bollard::query_parameters::CreateContainerOptions;
use bollard::Docker;
use maplit::hashmap;
use miette::{Context, IntoDiagnostic};
use std::fs::{create_dir_all, write};

#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Sftp;

#[async_trait::async_trait]
impl ServiceTrait for Sftp {
    fn name(&self) -> &str {
        "sftp"
    }

    async fn spawn(
        &self,
        docker: &Docker,
        cloud_id: &str,
        network: &str,
        _config: &HazeConfig,
        _options: &CloudOptions,
    ) -> Result<Vec<String>> {
        let image = "atmoz/sftp:alpine";
        pull_image(docker, image).await?;
        let options = Some(CreateContainerOptions {
            name: self.container_name(cloud_id),
            ..CreateContainerOptions::default()
        });
        let config = ContainerCreateBody {
            image: Some(image.into()),
            host_config: Some(HostConfig {
                network_mode: Some(network.to_string()),
                ..Default::default()
            }),
            labels: Some(hashmap! {
                "haze-type".into() => self.name().into(),
                "haze-cloud-id".into() => cloud_id.into(),
            }),
            networking_config: Some(NetworkingConfig {
                endpoints_config: Some(hashmap! {
                    network.into() => EndpointSettings {
                        aliases: Some(vec![self.name().to_string()]),
                        ..Default::default()
                    }
                }),
            }),
            cmd: Some(vec![
                "test:test:::data".into(),
                "ldaptest:test:::data".into(),
            ]),
            ..Default::default()
        };
        let id = docker
            .create_container(options, config)
            .await
            .into_diagnostic()?
            .id;
        docker.start_container(&id, None).await.into_diagnostic()?;
        Ok(vec![id])
    }

    fn container_name(&self, cloud_id: &str) -> Option<String> {
        Some(format!("{}-sftp", cloud_id))
    }

    fn apps(&self) -> &'static [&'static str] {
        &["files_external"]
    }

    async fn post_setup(
        &self,
        _docker: &Docker,
        _cloud_id: &str,
        _config: &HazeConfig,
    ) -> Result<Vec<Vec<String>>> {
        Ok(vec![
            split_cmnd("occ files_external:create sftp sftp password::password"),
            split_cmnd("occ files_external:config 1 host sftp"),
            split_cmnd("occ files_external:config 1 user test"),
            split_cmnd("occ files_external:config 1 root data"),
            split_cmnd("occ files_external:config 1 password test"),
        ])
    }
}

#[derive(Debug, Clone, Eq, PartialEq)]
pub struct SftpKey;

#[async_trait::async_trait]
impl ServiceTrait for SftpKey {
    fn name(&self) -> &str {
        "sftp-key"
    }

    async fn spawn(
        &self,
        docker: &Docker,
        cloud_id: &str,
        network: &str,
        config: &HazeConfig,
        _options: &CloudOptions,
    ) -> Result<Vec<String>> {
        let image = "atmoz/sftp:alpine";
        pull_image(docker, image).await?;
        let options = Some(CreateContainerOptions {
            name: self.container_name(cloud_id),
            ..CreateContainerOptions::default()
        });
        let key_dir = config.work_dir.join("certificates/sftp");
        create_dir_all(&key_dir)
            .into_diagnostic()
            .wrap_err("Failed to create sftp certificate directory")?;
        let private_path = key_dir.join("id_rsa");
        let public_path = key_dir.join("id_rsa.pub");
        let private_key = include_str!("../../certificates/sftp/id_rsa");
        let public_key = include_str!("../../certificates/sftp/id_rsa.pub");
        if !private_path.exists() {
            write(&private_path, private_key)
                .into_diagnostic()
                .wrap_err("Failed to write sftp client certificate")?;
        }
        if !public_path.exists() {
            write(&public_path, public_key)
                .into_diagnostic()
                .wrap_err("Failed to write sftp client key")?;
        }

        let volumes = vec![format!("{public_path}:/home/test/.ssh/keys/id_rsa:ro")];

        let config = ContainerCreateBody {
            image: Some(image.into()),
            host_config: Some(HostConfig {
                network_mode: Some(network.to_string()),
                binds: Some(volumes),
                ..Default::default()
            }),
            labels: Some(hashmap! {
                "haze-type".into() => self.name().into(),
                "haze-cloud-id".into() => cloud_id.into(),
            }),
            networking_config: Some(NetworkingConfig {
                endpoints_config: Some(hashmap! {
                    network.into() => EndpointSettings {
                        aliases: Some(vec![self.name().to_string()]),
                        ..Default::default()
                    }
                }),
            }),
            cmd: Some(vec!["test::::data".into()]),
            ..Default::default()
        };
        let id = docker
            .create_container(options, config)
            .await
            .into_diagnostic()?
            .id;
        docker.start_container(&id, None).await.into_diagnostic()?;
        Ok(vec![id])
    }

    fn container_name(&self, cloud_id: &str) -> Option<String> {
        Some(format!("{}-sftp-key", cloud_id))
    }

    fn apps(&self) -> &'static [&'static str] {
        &["files_external"]
    }

    async fn post_setup(
        &self,
        _docker: &Docker,
        _cloud_id: &str,
        _config: &HazeConfig,
    ) -> Result<Vec<Vec<String>>> {
        Ok(vec![
            split_cmnd("occ files_external:create sftp sftp publickey::rsa_private"),
            split_cmnd("occ files_external:config 1 host sftp-key"),
            split_cmnd("occ files_external:config 1 user test"),
            split_cmnd("occ files_external:config 1 root data"),
            vec![
                "occ".into(),
                "files_external:config".into(),
                "--value-from-file".into(),
                "1".into(),
                "private_key".into(),
                "/certificates/sftp/id_rsa".into(),
            ],
        ])
    }
}