// Example: How to update your event handlers to call the database service
// Place this in your main project's event_handlers directory

use crate::events::registry::events::CompanyRegistered;
use reqwest;

pub async fn handle_company_registered(event: CompanyRegistered) {
    println!("🏢 Company Registered!");
    println!("   Company: {}", event.company_name);
    println!("   Admin: {}", event.company_admin);
    
    // Call database microservice
    let client = reqwest::Client::new();
    let request_body = serde_json::json!({
        "company_pubkey": event.company.to_string(),
        "company_name": event.company_name,
        "company_admin_pubkey": event.company_admin.to_string(),
        "local_admin_pubkey": event.local_admin.to_string(),
        "eua_vault": event.eua_vault.to_string(),
        "ghg_vault": event.ghg_vault.to_string(),
        "usdc_vault": event.usdc_vault.to_string(),
        "registry_pubkey": event.registry.to_string(),
    });
    
    match client
        .post("http://localhost:3000/api/registry/companies")
        .json(&request_body)
        .send()
        .await
    {
        Ok(response) => {
            if response.status().is_success() {
                println!("   ✅ Successfully saved to database");
            } else {
                eprintln!("   ❌ Database error: {}", response.status());
            }
        }
        Err(e) => {
            eprintln!("   ❌ Failed to contact database service: {}", e);
        }
    }
}

// Similar pattern for other event handlers:

use crate::events::registry::events::LocalAdminRegistered;

pub async fn handle_local_admin_registered(event: LocalAdminRegistered) {
    println!("👤 Local Admin Registered!");
    println!("   State: {}", event.state_name);
    
    let client = reqwest::Client::new();
    let request_body = serde_json::json!({
        "local_admin_pubkey": event.local_admin.to_string(),
        "admin_pubkey": event.admin_pubkey.to_string(),
        "state_name": event.state_name,
        "registry_pubkey": event.registry.to_string(),
    });
    
    match client
        .post("http://localhost:3000/api/registry/local-admins")
        .json(&request_body)
        .send()
        .await
    {
        Ok(response) => {
            if response.status().is_success() {
                println!("   ✅ Successfully saved to database");
            } else {
                eprintln!("   ❌ Database error: {}", response.status());
            }
        }
        Err(e) => {
            eprintln!("   ❌ Failed to contact database service: {}", e);
        }
    }
}

use crate::events::registry::events::EuaMintedToVault;

pub async fn handle_eua_minted(event: EuaMintedToVault) {
    println!("💰 EUA Minted!");
    
    let client = reqwest::Client::new();
    let request_body = serde_json::json!({
        "company_pubkey": event.company.to_string(),
        "company_name": event.company_name,
        "eua_vault": event.eua_vault.to_string(),
        "amount": event.amount as i64,
        "minted_by": event.minted_by.to_string(),
        "eua_mint": event.eua_mint.to_string(),
    });
    
    match client
        .post("http://localhost:3000/api/registry/eua-minting")
        .json(&request_body)
        .send()
        .await
    {
        Ok(response) => {
            if response.status().is_success() {
                println!("   ✅ Successfully logged to database");
            } else {
                eprintln!("   ❌ Database error: {}", response.status());
            }
        }
        Err(e) => {
            eprintln!("   ❌ Failed to contact database service: {}", e);
        }
    }
}

use crate::events::registry::events::GhgMintedToVault;

pub async fn handle_ghg_minted(event: GhgMintedToVault) {
    println!("🌿 GHG Minted!");
    
    let client = reqwest::Client::new();
    let request_body = serde_json::json!({
        "company_pubkey": event.company.to_string(),
        "company_name": event.company_name,
        "ghg_vault": event.ghg_vault.to_string(),
        "amount": event.amount as i64,
        "local_admin_pubkey": event.local_admin.to_string(),
        "local_admin_state": event.local_admin_state,
        "verification_note": event.verification_note,
        "ghg_mint": event.ghg_mint.to_string(),
    });
    
    match client
        .post("http://localhost:3000/api/registry/ghg-minting")
        .json(&request_body)
        .send()
        .await
    {
        Ok(response) => {
            if response.status().is_success() {
                println!("   ✅ Successfully logged to database");
            } else {
                eprintln!("   ❌ Database error: {}", response.status());
            }
        }
        Err(e) => {
            eprintln!("   ❌ Failed to contact database service: {}", e);
        }
    }
}

use crate::events::registry::events::EuaTransferredBetweenVaults;

pub async fn handle_eua_transferred(event: EuaTransferredBetweenVaults) {
    println!("🔄 EUA Transferred!");
    
    let client = reqwest::Client::new();
    let request_body = serde_json::json!({
        "from_company_pubkey": event.from_company.to_string(),
        "from_company_name": event.from_company_name,
        "to_company_pubkey": event.to_company.to_string(),
        "to_company_name": event.to_company_name,
        "from_vault": event.from_vault.to_string(),
        "to_vault": event.to_vault.to_string(),
        "amount": event.amount as i64,
        "authorized_by": event.authorized_by.to_string(),
    });
    
    match client
        .post("http://localhost:3000/api/registry/eua-transfers")
        .json(&request_body)
        .send()
        .await
    {
        Ok(response) => {
            if response.status().is_success() {
                println!("   ✅ Successfully logged to database");
            } else {
                eprintln!("   ❌ Database error: {}", response.status());
            }
        }
        Err(e) => {
            eprintln!("   ❌ Failed to contact database service: {}", e);
        }
    }
}

use crate::events::registry::events::CompanyStatusUpdated;

pub async fn handle_company_status_updated(event: CompanyStatusUpdated) {
    println!("🔄 Company Status Updated!");
    
    let client = reqwest::Client::new();
    let request_body = serde_json::json!({
        "company_pubkey": event.company.to_string(),
        "is_active": event.is_active,
    });
    
    match client
        .put("http://localhost:3000/api/registry/companies/status")
        .json(&request_body)
        .send()
        .await
    {
        Ok(response) => {
            if response.status().is_success() {
                println!("   ✅ Successfully updated in database");
            } else {
                eprintln!("   ❌ Database error: {}", response.status());
            }
        }
        Err(e) => {
            eprintln!("   ❌ Failed to contact database service: {}", e);
        }
    }
}

use crate::events::registry::events::LocalAdminStatusUpdated;

pub async fn handle_local_admin_status_updated(event: LocalAdminStatusUpdated) {
    println!("🔄 Local Admin Status Updated!");
    
    let client = reqwest::Client::new();
    let request_body = serde_json::json!({
        "local_admin_pubkey": event.local_admin.to_string(),
        "is_active": event.is_active,
    });
    
    match client
        .put("http://localhost:3000/api/registry/local-admins/status")
        .json(&request_body)
        .send()
        .await
    {
        Ok(response) => {
            if response.status().is_success() {
                println!("   ✅ Successfully updated in database");
            } else {
                eprintln!("   ❌ Database error: {}", response.status());
            }
        }
        Err(e) => {
            eprintln!("   ❌ Failed to contact database service: {}", e);
        }
    }
}