//! Utilitaires Android partagés entre bridge et éditeur desktop.
//!
//! Module non disponible en WASM (dépend de `std::process` et du système de fichiers natif).

#![cfg(not(target_arch = "wasm32"))]

use std::path::{Path, PathBuf};

/// Insère/remplace la section `[package.metadata.android.signing.release]` dans le Cargo.toml.
/// Cherche le marqueur commenté généré par san-codegen et tronque à partir de là,
/// puis réécrit la section avec les vraies valeurs.
pub fn patch_signing_to_cargo_toml(
    cargo_toml: &Path,
    keystore_path: &str,
    keystore_password: &str,
    key_alias: &str,
    key_password: &str,
) -> std::io::Result<()> {
    let content = std::fs::read_to_string(cargo_toml)?;
    let cutpoint = content
        .find("\n# Signature release")
        .or_else(|| content.find("\n[package.metadata.android.signing.release]"));
    let base = match cutpoint {
        Some(pos) => content[..pos].trim_end().to_string(),
        None => content.trim_end().to_string(),
    };
    let ks = keystore_path.replace('\\', "/");
    let new_content = format!(
        "{base}\n\n[package.metadata.android.signing.release]\npath = \"{ks}\"\nkeystore_password = \"{keystore_password}\"\nkey_alias = \"{key_alias}\"\nkey_password = \"{key_password}\"\n"
    );
    std::fs::write(cargo_toml, new_content)
}

/// Cherche le dernier APK produit dans `project_root/target/{debug,release}/apk/*.apk`.
/// Retourne le chemin le plus récemment modifié, ou `None` si aucun.
pub fn find_last_apk(project_root: &Path, release: bool) -> Option<PathBuf> {
    let apk_dir = project_root
        .join("target")
        .join(if release { "release" } else { "debug" })
        .join("apk");
    let entries = std::fs::read_dir(&apk_dir).ok()?;
    entries
        .filter_map(|e| e.ok())
        .filter(|e| e.path().extension().and_then(|s| s.to_str()) == Some("apk"))
        .max_by_key(|e| e.metadata().and_then(|m| m.modified()).ok())
        .map(|e| e.path())
}

/// Vérifie que l'exécutable `keytool` (fourni par tout JDK) est accessible dans le PATH.
/// Retourne `Ok(())` s'il répond à `keytool -help`, sinon une erreur lisible.
pub fn check_keytool_available() -> Result<(), String> {
    match std::process::Command::new("keytool")
        .arg("-help")
        .stdout(std::process::Stdio::null())
        .stderr(std::process::Stdio::null())
        .status()
    {
        Ok(s) if s.success() => Ok(()),
        Ok(s) => Err(format!("keytool présent mais a retourné le code {s}")),
        Err(_) => Err(
            "keytool introuvable dans le PATH. Installe un JDK (OpenJDK, Temurin, \
             Android Studio) et ajoute son dossier bin/ au PATH."
                .to_string(),
        ),
    }
}

/// Retourne le chemin standard du keystore Android debug selon l'OS.
/// Windows : `%USERPROFILE%\.android\debug.keystore`
/// Unix    : `$HOME/.android/debug.keystore`
pub fn default_debug_keystore_path() -> PathBuf {
    let home = std::env::var("USERPROFILE")
        .or_else(|_| std::env::var("HOME"))
        .unwrap_or_default();
    PathBuf::from(home).join(".android").join("debug.keystore")
}

/// Vérifie que le keystore Android debug existe au chemin standard, le crée
/// sinon via `keytool`. Retourne le chemin absolu en cas de succès.
///
/// Mots de passe et alias utilisés : `android` / `androiddebugkey` / `android`
/// (valeurs standard Android attendues par `cargo-apk`).
pub fn ensure_android_debug_keystore() -> Result<PathBuf, String> {
    let keystore = default_debug_keystore_path();
    if keystore.exists() {
        return Ok(keystore);
    }

    if let Some(parent) = keystore.parent() {
        std::fs::create_dir_all(parent)
            .map_err(|e| format!("Création {}: {e}", parent.display()))?;
    }

    let ks_str = keystore.to_string_lossy().to_string();
    let output = std::process::Command::new("keytool")
        .args([
            "-genkeypair", "-v",
            "-keystore", &ks_str,
            "-storepass", "android",
            "-alias", "androiddebugkey",
            "-keypass", "android",
            "-keyalg", "RSA",
            "-keysize", "2048",
            "-validity", "10000",
            "-dname", "CN=Android Debug,O=Android,C=US",
        ])
        .output()
        .map_err(|e| format!("Lancement keytool: {e} (JDK installé ? keytool dans le PATH ?)"))?;

    if !output.status.success() {
        return Err(format!(
            "keytool a échoué ({}): {}",
            output.status,
            String::from_utf8_lossy(&output.stderr)
        ));
    }
    Ok(keystore)
}
