#Bus 접근 패턴 Cookbook

// 나쁜 예: 둘 다 String을 삽입, 두 번째가 첫 번째를 덮어씀
bus.insert::<String>("user-123".into());     // UserId?
bus.insert::<String>("order-456".into());    // OrderId? UserId를 덮어씀!

#[derive(Debug, Clone)]
struct UserId(pub String);

#[derive(Debug, Clone)]
struct OrderId(pub String);

#[derive(Debug, Clone)]
struct TenantId(pub String);

// 각 타입이 Bus에서 자신만의 슬롯을 차지
bus.insert(UserId("user-123".into()));
bus.insert(OrderId("order-456".into()));
bus.insert(TenantId("tenant-789".into()));

// 각각 독립적으로 읽기
let user = bus.read::<UserId>();    // Some(UserId("user-123"))
let order = bus.read::<OrderId>();  // Some(OrderId("order-456"))

use sqlx::PgPool;

#[derive(Debug, Clone)]
struct DbPool(pub PgPool);

// bus_injector로 풀 삽입 (요청당 한 번 실행)
Ranvier::http()
    .bus_injector({
        let pool = PgPool::connect(&database_url).await?;
        move |_parts: &http::request::Parts, bus: &mut Bus| {
            bus.insert(DbPool(pool.clone()));
        }
    })
    .get("/api/users", list_users_circuit)
    .run(())
    .await?;

#[async_trait]
impl Transition<(), Vec<User>> for ListUsers {
    type Error = String;
    type Resources = ();

    async fn run(
        &self,
        _input: (),
        _resources: &Self::Resources,
        bus: &mut Bus,
    ) -> Outcome<Vec<User>, Self::Error> {
        let pool = &bus.require::<DbPool>().0;
        let users = sqlx::query_as::<_, User>("SELECT * FROM users")
            .fetch_all(pool)
            .await
            .map_err(|e| e.to_string())?;
        Outcome::next(users)
    }
}

use ranvier_core::prelude::*;
use ranvier_runtime::Axon;

#[derive(Debug, Clone)]
struct ValidationResult {
    is_valid: bool,
    warnings: Vec<String>,
}

#[derive(Debug, Clone)]
struct EnrichedOrder {
    original: CreateOrder,
    tax_amount: f64,
    shipping_cost: f64,
}

let order_pipeline = Axon::typed::<CreateOrder, String>("order-pipeline")
    // 단계 1: 검증하고 결과를 Bus에 쓰기
    .then_fn("validate", |order, _res, bus| async move {
        let result = ValidationResult {
            is_valid: order.quantity > 0,
            warnings: vec![],
        };
        bus.insert(result.clone());
        if result.is_valid {
            Outcome::next(order)
        } else {
            Outcome::fault("검증 실패".to_string())
        }
    })
    // 단계 2: 보강하고 보강된 데이터를 Bus에 쓰기
    .then_fn("enrich", |order, _res, bus| async move {
        let enriched = EnrichedOrder {
            tax_amount: order.quantity as f64 * 0.08,
            shipping_cost: 5.99,
            original: order,
        };
        bus.insert(enriched.clone());
        Outcome::next(enriched)
    })
    // 단계 3: 이전 두 결과 읽기
    .then_fn("finalize", |enriched, _res, bus| async move {
        let validation = bus.require::<ValidationResult>();
        let total = enriched.tax_amount + enriched.shipping_cost;
        Outcome::next(format!(
            "주문 확인: ${:.2} 총액, {} 경고",
            total,
            validation.warnings.len()
        ))
    });

use ranvier_guard::prelude::*;

let circuit = Axon::simple::<String>("user-info")
    .then_fn("read-auth", |_input, _res, bus| async move {
        // AuthGuard가 인증 성공 후 IamIdentity를 삽입
        let identity = bus.get_cloned::<ranvier_core::iam::IamIdentity>();
        let subject = identity.map(|id| id.subject)
            .unwrap_or_else(|_| "anonymous".into());

        // RequestIdGuard가 RequestId (UUID v4)를 삽입
        let request_id = bus.get_cloned::<RequestId>()
            .map(|r| r.0)
            .unwrap_or_default();

        // CompressionGuard가 CompressionConfig를 삽입
        let encoding = bus.read::<CompressionConfig>()
            .map(|c| c.encoding.as_str())
            .unwrap_or("identity");

        Outcome::next(format!(
            "user={}, request={}, encoding={}",
            subject, request_id, encoding
        ))
    });

use ranvier_core::bus::{Bus, BusAccessPolicy, BusTypeRef};

// 특정 타입만 허용
let policy = BusAccessPolicy::allow_only(vec![
    BusTypeRef::of::<UserId>(),
    BusTypeRef::of::<DbPool>(),
]);
bus.set_access_policy(policy);

// 또는 특정 민감한 타입만 거부
let policy = BusAccessPolicy::deny_only(vec![
    BusTypeRef::of::<AuthorizationHeader>(),
]);
bus.set_access_policy(policy);

// 완료 시 정책 제거
bus.clear_access_policy();

#[tokio::test]
async fn test_order_enrichment() {
    let mut bus = Bus::new();
    bus.insert(DbPool(test_pool().await));

    let transition = EnrichOrder;
    let input = CreateOrder {
        product_id: "prod-1".into(),
        quantity: 2,
        shipping_address: "123 Main St".into(),
    };

    let result = transition.run(input, &(), &mut bus).await;
    assert!(matches!(result, Outcome::Next(_)));

    // Bus 부수 효과 검증
    let enriched = bus.get_cloned::<EnrichedOrder>().expect("Bus에 있어야 함");
    assert!(enriched.tax_amount > 0.0);
}

// BEFORE (v0.42):
let pool = bus.read::<PgPool>().cloned()
    .ok_or_else(|| "PgPool 없음".to_string())?;

// AFTER (v0.43):
let pool = bus.get_cloned::<PgPool>().expect("PgPool");

// Outcome 컨텍스트에서 try_outcome!과 함께:
use ranvier_core::try_outcome;
let pool = try_outcome!(bus.get_cloned::<PgPool>(), "PgPool이 Bus에 없음");

use ranvier_http::BusHttpExt;  // 또는 prelude를 통해

// Path 파라미터 (자동 파싱): /users/:id
let id: u64 = bus.path_param("id")?;  // Result<T: FromStr, String>

// Query 파라미터 (옵션): /items?page=2
let page: Option<i64> = bus.query_param("page");

// 기본값이 있는 Query: /items?per_page=10
let per_page: i64 = bus.query_param_or("per_page", 10);

let id: u64 = match bus.read::<PathParams>().and_then(|p| p.get("id")) {
    Some(raw) => match raw.parse() {
        Ok(id) => id,
        Err(_) => return Outcome::Fault("유효하지 않은 ID".into()),
    },
    None => return Outcome::Fault("ID 누락".into()),
};

let id: u64 = match bus.path_param("id") {
    Ok(id) => id,
    Err(e) => return Outcome::Fault(e),
};