use wami::arn::{TenantPath, WamiArn};
use wami::context::WamiContext;
use wami::store::memory::InMemoryStore;
use wami::store::traits::UserStore;
use wami::wami::identity::user::builder::build_user;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize storage
    let mut store = InMemoryStore::default();
    
    // Create WAMI context with ARN (using numeric tenant IDs)
    let context = WamiContext::builder()
        .instance_id("123456789012")
        .tenant_path(TenantPath::single(0)) // Root tenant uses ID 0
        .caller_arn(
            WamiArn::builder()
                .service(wami::arn::Service::Iam)
                .tenant_path(TenantPath::single(0))
                .wami_instance("123456789012")
                .resource("user", "admin")
                .build()?,
        )
        .is_root(false)
        .build()?;
    
    // Build a user (pure function with ARN support)
    let user = build_user(
        "alice".to_string(),
        Some("/engineering/".to_string()),
        &context,
    )?;
    
    // Store it
    let created = store.create_user(user).await?;
    println!("✅ Created user: {}", created.user_name);
    println!("✅ WAMI ARN: {}", created.wami_arn);
    
    // Retrieve it
    let retrieved = store.get_user("alice").await?;
    println!("✅ Retrieved: {:?}", retrieved.unwrap().user_name);
    
    Ok(())
}

use wami::arn::{TenantPath, WamiArn};
use wami::context::WamiContext;
use wami::wami::identity::{user, group, role};

// Create WAMI context
let context = WamiContext::builder()
    .instance_id("123456789012")
    .tenant_path(TenantPath::single(0)) // Root tenant uses ID 0
    .caller_arn(
        WamiArn::builder()
            .service(wami::arn::Service::Iam)
            .tenant_path(TenantPath::single(0))
            .wami_instance("123456789012")
            .resource("user", "admin")
            .build()?,
    )
    .is_root(false)
    .build()?;

// Create user
let user = user::builder::build_user("alice".into(), None, &context)?;
store.create_user(user).await?;

// Create group and add user
let group = group::builder::build_group("admins".into(), None, &context)?;
store.create_group(group).await?;
store.add_user_to_group("admins", "alice").await?;

// Create role with trust policy
let trust_policy = r#"{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"AWS":"*"},"Action":"sts:AssumeRole"}]}"#;
let role = role::builder::build_role(
    "AdminRole".into(),
    trust_policy.to_string(),
    None,
    None,
    None,
    &context,
)?;
store.create_role(role).await?;

use wami::arn::{TenantPath, WamiArn};
use wami::context::WamiContext;
use wami::wami::credentials::access_key::builder::build_access_key;
use wami::service::{SessionTokenService, AssumeRoleService};
use wami::wami::sts::session_token::requests::GetSessionTokenRequest;

// Create WAMI context (using numeric tenant IDs)
let context = WamiContext::builder()
    .instance_id("123456789012")
    .tenant_path(TenantPath::single(0)) // Root tenant uses ID 0
    .caller_arn(
        WamiArn::builder()
            .service(wami::arn::Service::Iam)
            .tenant_path(TenantPath::single(0))
            .wami_instance("123456789012")
            .resource("user", "alice")
            .build()?,
    )
    .is_root(false)
    .build()?;

// Create access keys (uses context)
let key = build_access_key("alice".to_string(), &context)?;
store.create_access_key(key).await?;

// Create temporary session (via service layer)
let sts_service = SessionTokenService::new(store.clone());
let token_req = GetSessionTokenRequest {
    duration_seconds: Some(3600),
    serial_number: None,
    token_code: None,
};
let session = sts_service
    .get_session_token(&context, token_req, &user_arn)
    .await?;

use wami::arn::{WamiArn, Service, TenantPath};

// Build a WAMI native ARN (using numeric tenant IDs)
let arn = WamiArn::builder()
    .service(Service::Iam)
    .tenant_hierarchy(vec![12345678, 87654321, 99999999]) // Opaque numeric IDs
    .wami_instance("999888777")
    .resource("user", "77557755")
    .build()?;

println!("{}", arn);
// Output: arn:wami:iam:12345678/87654321/99999999:wami:999888777:user/77557755

// Build a cloud-synced ARN
let cloud_arn = WamiArn::builder()
    .service(Service::Iam)
    .tenant(12345678) // Numeric tenant ID
    .wami_instance("999888777")
    .cloud_provider("aws", "223344556677")
    .resource("user", "77557755")
    .build()?;

println!("{}", cloud_arn);
// Output: arn:wami:iam:12345678:wami:999888777:aws:223344556677:global:user/77557755

// Parse an ARN
let parsed = WamiArn::from_str("arn:wami:iam:12345678:wami:999888777:user/77557755")?;
println!("Resource type: {}", parsed.resource_type());

use wami::wami::tenant::{Tenant, TenantId};

// Create parent tenant (service generates unique numeric ID)
let parent = tenant_service
    .create_tenant(
        &context,
        "acme-corp".to_string(),
        Some("ACME Corp".to_string()),
        None, // No parent, this is a root tenant
    )
    .await?;
let parent_id = parent.id.clone();

// Create child tenant
let child = tenant_service
    .create_tenant(
        &context,
        "engineering".to_string(),
        Some("Engineering Dept".to_string()),
        Some(parent_id.clone()),
    )
    .await?;
let child_id = child.id.clone();

// Query hierarchy
let descendants = store.get_descendants(&parent_id).await?;