use super::{run_chroot, run_cmd, Job, UiSender};

/// Kullanıcı hesabı oluşturur ve şifresini ayarlar.
pub struct CreateUserJob {
    pub mount:         String,
    pub username:      String,
    pub password:      String,
    pub root_password: String,
}

#[async_trait::async_trait]
impl Job for CreateUserJob {
    fn name(&self) -> &str { "job_user" }

    async fn run(&self, ui: &UiSender) -> Result<(), String> {
        // wheel grubunun varlığını garantile (PisiLinux'ta olmayabilir)
        let group_file = format!("{}/etc/group", self.mount);
        let group_content = tokio::fs::read_to_string(&group_file)
            .await.unwrap_or_default();
        if !group_content.lines().any(|l| l.starts_with("wheel:")) {
            ui.log("wheel grubu oluşturuluyor…");
            run_chroot(&self.mount, &["groupadd", "-r", "wheel"]).await
                .unwrap_or_default(); // hata olsa bile devam et
        }

        // useradd: kullanıcıyı temel gruplarla oluştur
        // PisiLinux'ta "storage" grubu yoksa useradd hata verir; -M flag ile grub yoksa atla
        // Güvenli yöntem: önce her grubu tek tek ekle
        let groups = ["wheel", "users", "pnp", "disk", "audio", "video", "power", "dialout", "lp", "lpadmin", "cdrom", "floppy"];
        for grp in &groups {
            if group_content.lines().any(|l| l.starts_with(&format!("{}:", grp))) {
                // grup zaten var
            } else {
                // grup yoksa oluşturma (hata görmezden gel)
                let _ = run_chroot(&self.mount, &["groupadd", grp]).await;
            }
        }

        // Kullanıcıyı oluştur
        let groups_str = groups.join(",");
        ui.log(format!("useradd -m -G {} -s /bin/bash {}", groups_str, self.username));
        run_chroot(&self.mount, &[
            "useradd",
            "-m",
            "-G", &groups_str,
            "-s", "/bin/bash",
            &self.username,
        ]).await?;

        // // chpasswd ile şifre ayarla (stdin üzerinden güvenli)
        // ui.log(format!("Şifre ayarlanıyor: {}", self.username));
        // let chpasswd_input = format!("{}:{}", self.username, self.password);
        // set_password_via_chpasswd(&self.mount, &chpasswd_input).await?;

        // // Root şifresi: belirlenmişse ayarla, yoksa kilitle
        // if self.root_password.is_empty() {
        //     ui.log("Root hesabı kilitleniyor…");
        //     run_chroot(&self.mount, &["passwd", "-l", "root"]).await?;
        // } else {
        //     ui.log("Root şifresi ayarlanıyor…");
        //     let root_input = format!("root:{}", self.root_password);
        //     set_password_via_chpasswd(&self.mount, &root_input).await?;
        // }

        // 2. chpasswd ile şifre ayarla (YENİ BASİTLEŞTİRİLMİŞ VE KESİN YÖNTEM)
        ui.log(format!("Şifre ayarlanıyor: {}", self.username));
        // sh -c kullanarak echo ile chpasswd'e şifreyi güvenli bir şekilde üflüyoruz
        let user_cmd = format!("echo '{}:{}' | chpasswd -c SHA512", self.username, self.password);
        run_chroot(&self.mount, &["sh", "-c", &user_cmd]).await?;

        // 3. Root şifresi: belirlenmişse ayarla, yoksa kilitle
        if self.root_password.is_empty() {
            ui.log("Root hesabı kilitleniyor…");
            run_chroot(&self.mount, &["passwd", "-l", "root"]).await?;
        } else {
            ui.log("Root şifresi ayarlanıyor…");
            let root_cmd = format!("echo 'root:{}' | chpasswd -c SHA512", self.root_password);
            run_chroot(&self.mount, &["sh", "-c", &root_cmd]).await?;
}


        // sudoers: wheel grubu sudo yetkisi alsın
        let sudoers_dir = format!("{}/etc/sudoers.d", self.mount);
        tokio::fs::create_dir_all(&sudoers_dir).await
            .map_err(|e| format!("{} oluşturulamadı: {}", sudoers_dir, e))?;
        let sudoers_path = format!("{}/wheel", sudoers_dir);
        ui.log(format!("Yazılıyor: {}", sudoers_path));
        tokio::fs::write(&sudoers_path, "%wheel ALL=(ALL:ALL) ALL\n")
            .await
            .map_err(|e| format!("sudoers yazılamadı: {}", e))?;

        // Dosya izinleri: sudoers 440 olmalı
        run_cmd("chmod", &["440", &sudoers_path]).await?;

        Ok(())
    }
}

// /// `chpasswd` komutuna stdin üzerinden kullanıcı:şifre gönderir.
// async fn set_password_via_chpasswd(mount: &str, input: &str) -> Result<(), String> {
//     if DEMO_MODE.load(std::sync::atomic::Ordering::Relaxed) {
//         tokio::time::sleep(std::time::Duration::from_millis(2500)).await;
//         return Ok(());
//     }

//     use tokio::io::AsyncWriteExt;
//     use tokio::process::Command;

//     let mut child = Command::new("chroot")
//         .args([mount, "chpasswd"])
//         .stdin(std::process::Stdio::piped())
//         .stdout(std::process::Stdio::null())
//         .stderr(std::process::Stdio::piped())
//         .spawn()
//         .map_err(|e| format!("chpasswd başlatılamadı: {}", e))?;

//     if let Some(mut stdin) = child.stdin.take() {
//         let mut data = input.as_bytes().to_vec();
//         if !data.ends_with(b"\n") {
//             data.push(b'\n');
//         }
//         stdin.write_all(&data).await
//             .map_err(|e| format!("chpasswd stdin yazma hatası: {}", e))?;
//     }

//     let output = child.wait_with_output().await
//         .map_err(|e| format!("chpasswd bekleme hatası: {}", e))?;

//     if output.status.success() {
//         Ok(())
//     } else {
//         Err(String::from_utf8_lossy(&output.stderr).trim().to_string())
//     }
// }
