[package]
name    = "metrics-engine"
version = "0.1.0"
edition = "2021"

[dependencies]
# ── Azure Identity (autenticación) ──────────────────────────────
azure_identity              = "0.21"   # DeveloperTools / ManagedIdentity / ClientSecret

# ── Servicios Azure (re-exportan azure_core) ─────────────────────
azure_security_keyvault_secrets = "0.21"
azure_storage_blobs         = "0.21"

# ── Runtime async ────────────────────────────────────────────────
tokio   = { version = "1", features = ["full"] }

# ── Config y errores ─────────────────────────────────────────────
anyhow  = "1"
dotenvy = "0.15"            # carga .env en local (nunca en producción)

# ── Serialización ────────────────────────────────────────────────
serde       = { version = "1", features = ["derive"] }
serde_json  = "1"

/// auth.rs — CultivaMetrics · metrics-engine
/// Factory de credenciales Azure según entorno de ejecución.
///
/// Estrategia:
///   APP_ENV=development → DeveloperToolsCredential (az login)
///   APP_ENV=production  → ManagedIdentityCredential (AKS system-assigned)
///   APP_ENV=ci          → ClientSecretCredential (Service Principal)

use anyhow::{Context, Result};
use azure_identity::{
    ClientSecretCredential,
    DeveloperToolsCredential,
    ManagedIdentityCredential,
};
use std::sync::Arc;

/// Tipo alias — agrupa todos los credenciales posibles tras un Arc
pub type AzureCredential = Arc<dyn azure_core::auth::TokenCredential>;

#[derive(Debug, Clone, PartialEq)]
pub enum AppEnv {
    Development,
    Production,
    Ci,
}

impl AppEnv {
    pub fn from_env() -> Self {
        match std::env::var("APP_ENV").as_deref() {
            Ok("production")  => AppEnv::Production,
            Ok("ci")          => AppEnv::Ci,
            _                => AppEnv::Development, // seguro por defecto
        }
    }
}

/// Construye la credencial adecuada para el entorno actual.
/// El caller recibe un Arc thread-safe: clonar es barato.
pub fn build_credential(env: &AppEnv) -> Result<AzureCredential> {
    let cred: AzureCredential = match env {

        AppEnv::Development => {
            // Prueba az login, luego azd auth login. Sin secretos en código.
            let c = DeveloperToolsCredential::new(None)
                .context("DeveloperToolsCredential: ejecuta `az login` primero")?;
            Arc::new(c)
        }

        AppEnv::Production => {
            // AKS system-assigned managed identity: sin secretos, sin rotación manual.
            let c = ManagedIdentityCredential::new(None)
                .context("ManagedIdentityCredential: verifica que el pod tenga la MI asignada")?;
            Arc::new(c)
        }

        AppEnv::Ci => {
            // Service Principal para GitHub Actions. Vars en GitHub Secrets.
            let tenant_id = std::env::var("AZURE_TENANT_ID")
                .context("falta AZURE_TENANT_ID")?;
            let client_id = std::env::var("AZURE_CLIENT_ID")
                .context("falta AZURE_CLIENT_ID")?;
            let client_secret = std::env::var("AZURE_CLIENT_SECRET")
                .context("falta AZURE_CLIENT_SECRET")?;
            let c = ClientSecretCredential::new(
                &tenant_id, &client_id, &client_secret, None
            ).context("ClientSecretCredential: verifica las vars de entorno")?;
            Arc::new(c)
        }
    };

    Ok(cred)
}

/// main.rs — CultivaMetrics · metrics-engine
/// Muestra cómo reutilizar una sola credencial para múltiples clientes.
/// Los clientes son thread-safe: crea una vez, comparte en todo Tokio.

mod auth;

use anyhow::Result;
use auth::{AppEnv, build_credential};
use azure_security_keyvault_secrets::SecretClient;
use azure_storage_blobs::prelude::*;

/// Configuración del tenant de CultivaMetrics (no son secretos)
const KEY_VAULT_URL: &str  = "https://cultiva-metrics-kv.vault.azure.net/";
const STORAGE_ACCOUNT: &str = "cultivametricsdata";
const BLOB_CONTAINER: &str  = "campañas-parquet";

#[tokio::main]
async fn main() -> Result<()> {
    // Carga .env solo en desarrollo (dotenvy es no-op si no existe el archivo)
    let _ = dotenvy::dotenv();

    let env        = AppEnv::from_env();
    let credential = build_credential(&env)?;

    println!("Entorno: {:?} → credencial configurada", env);

    // ── 1. Key Vault: leer API key del cliente ────────────────────────────
    // Clonar credential es O(1) — es un Arc, sin copia del token subyacente
    let kv_client = SecretClient::new(
        KEY_VAULT_URL,
        credential.clone(),  // ← clon del Arc, thread-safe
        None,
    )?;

    let secret = kv_client
        .get_secret("cliente-acme-api-key", None)
        .await?
        .into_model()?;

    println!("API key recuperada: {} chars", secret.value.len());

    // ── 2. Blob Storage: leer dataset de campañas ─────────────────────────
    let blob_client = ClientBuilder::new(
        STORAGE_ACCOUNT,
        StorageCredentials::token_credential(credential.clone()),
    )
    .blob_client(BLOB_CONTAINER, "q2-2026-campaign-data.parquet");

    let data = blob_client.get_content().await?;
    println!("Dataset descargado: {} bytes", data.len());

    // ── 3. Cognitive Services: inferencia ML (llamada REST con Bearer token)
    let token = credential
        .get_token(&["https://cognitiveservices.azure.com/.default"])
        .await?;

    println!(
        "Token Cognitive Services obtenido (expira: {:?})",
        token.expires_on
    );

    // Aquí iría la llamada HTTP a /score con Bearer token.value
    // Los clientes son reusables: créalos una vez fuera de esta función.

    Ok(())
}