use std::sync::Arc;

use dagger_sdk::{HostDirectoryOptsBuilder, QueryContainerOptsBuilder};
use tokio::sync::Mutex;

#[tokio::main]
async fn main() -> eyre::Result<()> {
    color_eyre::install().unwrap();

    let client = dagger_sdk::connect().await?;

    let src = client.host().directory_opts(
        ".",
        HostDirectoryOptsBuilder::default()
            .exclude(vec!["target/", ".git/"])
            .build()?,
    );

    let variants = vec!["linux/amd64", "linux/arm64"];
    let platform_variants = Arc::new(Mutex::new(Vec::new()));

    tokio_scoped::scope(|s| {
        for platform in variants {
            let client = client.clone();
            let platform_variants = platform_variants.clone();
            let src = src.clone();

            s.spawn(async move {
                let rust_dep_image = client
                    .container_opts(
                        QueryContainerOptsBuilder::default()
                            .platform(platform)
                            .build()
                            .unwrap(),
                    )
                    .from("rustlang/rust:nightly")
                    .with_workdir("/app")
                    .with_directory(".", src.id().await.unwrap())
                    .with_exec(vec!["cargo", "build", "--release"]);

                let dep_image = client
                    .container_opts(
                        QueryContainerOptsBuilder::default()
                            .platform(platform)
                            .build()
                            .unwrap(),
                    )
                    .from("debian:bullseye")
                    .with_file(
                        "/usr/bin/update-deployment",
                        rust_dep_image
                            .file("target/release/update-deployment")
                            .id()
                            .await
                            .unwrap(),
                    );

                let mut platform_variants = platform_variants.lock().await;
                platform_variants.push(dep_image.id().await.unwrap())
            });
        }
    });

    let variants = platform_variants
        .lock()
        .await
        .iter()
        .map(|c| c.clone())
        .collect::<Vec<_>>();

    let tag = chrono::Utc::now().timestamp();

    let _ = client
        .container()
        .publish_opts(
            format!("kasperhermansen/update-deployment:{tag}"),
            dagger_sdk::ContainerPublishOptsBuilder::default()
                .platform_variants(variants)
                .build()?,
        )
        .await?;

    Ok(())
}