#Ranvier 철학: 의견이 분명한 핵심, 유연한 경계

use ranvier::prelude::*;

#[transition]
async fn validate_input(req: Request) -> Outcome<ValidRequest, ValidationError> {
    if req.body.is_empty() {
        return Outcome::err(ValidationError::EmptyBody);
    }
    Outcome::ok(ValidRequest::from(req))
}

#[transition]
async fn process(input: ValidRequest) -> Outcome<Response, ProcessError> {
    // 비즈니스 로직
    let result = compute(&input).await?;
    Outcome::ok(Response::new(result))
}

// 조합:
let pipeline = Axon::simple::<AppError>()
    .pipe(validate_input, process)
    .build();

// Transition은 Outcome을 반환합니다
#[transition]
async fn fetch_user(id: UserId) -> Outcome<User, DatabaseError> {
    match db.get_user(id).await {
        Ok(user) => Outcome::ok(user),
        Err(e) => Outcome::err(DatabaseError::from(e)),
    }
}

// Outcome 값은 표시된 경우 자동으로 Bus에 저장됩니다
#[transition]
async fn enrich_user(user: User) -> Outcome<EnrichedUser, EnrichmentError> {
    // 'user'는 Bus에서 왔습니다 (자동 주입)
    let profile = fetch_profile(&user).await?;
    Outcome::ok(EnrichedUser { user, profile })
}

#[transition]
async fn authenticate(req: Request) -> Outcome<AuthContext, AuthError> {
    let token = extract_token(&req)?;
    let auth = validate(token).await?;
    // AuthContext가 다운스트림 transition을 위해 자동으로 Bus에 저장됩니다
    Outcome::ok(auth)
}

#[transition]
async fn authorize(auth: &AuthContext) -> Outcome<(), AuthError> {
    // 'auth'가 Bus에서 자동으로 주입됩니다 (타입별로)
    if !auth.has_role("admin") {
        return Outcome::err(AuthError::Unauthorized);
    }
    Outcome::ok(())
}

#[transition]
async fn handle_request(auth: &AuthContext, req: &Request) -> Outcome<Response, AppError> {
    // 'auth'와 'req' 모두 Bus에서 주입됩니다
    Ok(Response::new(format!("Hello, {}", auth.user_id)))
}

// Schematic 구축
let schematic = Axon::simple::<AppError>()
    .pipe(authenticate, authorize, handle_request)
    .build();

// 실행
let outcome = schematic.execute(request).await;

// JSON으로 내보내기 (VSCode 시각화용)
let json = schematic.to_json();
std::fs::write("schematic.json", json)?;

┌─────────────┐    ┌──────────┐    ┌────────────────┐
│ authenticate│───▶│ authorize│───▶│ handle_request │
│             │    │          │    │                │
│ Output:     │    │ Input:   │    │ Input:         │
│ AuthContext │    │ &AuthCtx │    │ &AuthCtx, &Req │
└─────────────┘    └──────────┘    └────────────────┘

// ❌ 유연한 프레임워크의 혼란:
// "미들웨어를 사용해야 할까? 추출기? 가드? 서비스 레이어?"

// ✅ Ranvier의 명확성:
// "Transition을 작성하세요. .pipe()로 체이닝하세요. 완료."
#[transition]
async fn my_logic(input: Input) -> Outcome<Output, Error> {
    // 비즈니스 로직
}

src/
├── transitions/   # 비즈니스 로직 (Transition 함수)
├── outcomes/      # 도메인 타입
├── schematics/    # 파이프라인 조합
└── main.rs        # Axon 설정

use tower::ServiceBuilder;
use tower_http::cors::CorsLayer;
use ranvier::prelude::*;

// Tower가 인프라를 처리합니다 (CORS, 추적, 타임아웃)
let app = ServiceBuilder::new()
    .layer(CorsLayer::permissive())
    .layer(TraceLayer::new_for_http())
    .layer(TimeoutLayer::new(Duration::from_secs(30)))
    .service(ranvier_handler);

// Ranvier가 비즈니스 로직을 처리합니다 (ranvier_handler 내부)
#[transition]
async fn business_logic(req: Request) -> Outcome<Response, AppError> {
    // 순수 비즈니스 로직, 인프라 관심사 없음
}

// 레거시 Tower 인증 레이어 (유지, 작동합니다)
let auth_layer = RequireAuthorizationLayer::new(...);

// 새로운 Ranvier 비즈니스 로직 (시각화 얻기)
#[transition]
async fn new_feature(auth: &AuthContext) -> Outcome<Response, Error> {
    // Schematic 시각화를 사용한 최신 코드
}

// 결합
let app = ServiceBuilder::new()
    .layer(auth_layer)  // Tower (레거시)
    .service(ranvier_pipeline);  // Ranvier (새로운)

// ✅ 핵심: Transition으로서의 비즈니스 로직
#[transition]
async fn validate_order(order: Order) -> Outcome<ValidOrder, ValidationError> {
    if order.items.is_empty() {
        return Outcome::err(ValidationError::EmptyOrder);
    }
    Outcome::ok(ValidOrder::from(order))
}

// ✅ 핵심: Bus의 상태
#[transition]
async fn calculate_tax(order: &ValidOrder, tax_rate: &TaxRate) -> Outcome<Tax, TaxError> {
    // tax_rate가 Bus에서 주입됩니다
}

// ✅ 핵심: Axon으로 조합
let pipeline = Axon::simple()
    .pipe(validate_order, calculate_tax, apply_discount)
    .build();

// ❌ 하지 마세요: Transition 대신 일반 함수
async fn my_logic(input: Input) -> Result<Output, Error> {
    // Schematic에 표시되지 않음, .pipe()로 조합할 수 없음
}

// ❌ 하지 마세요: Bus 대신 전역 상태
static AUTH: Mutex<Option<AuthContext>> = Mutex::new(None);
// 암시적 의존성, 테스트할 수 없음, 시각화되지 않음

// ✅ 에지: Tower 미들웨어
use tower::ServiceBuilder;
use tower_http::cors::CorsLayer;

let app = ServiceBuilder::new()
    .layer(CorsLayer::permissive())
    .service(ranvier_handler);

// ✅ 에지: 데이터베이스용 sqlx
#[transition]
async fn fetch_user(pool: &PgPool, id: UserId) -> Outcome<User, DbError> {
    let user = sqlx::query_as("SELECT * FROM users WHERE id = $1")
        .bind(id)
        .fetch_one(pool)
        .await?;
    Outcome::ok(user)
}

// ✅ 에지: 캐싱용 redis
#[transition]
async fn get_cached(cache: &RedisPool, key: &str) -> Outcome<String, CacheError> {
    let value = cache.get(key).await?;
    Outcome::ok(value)
}

// 옵션 A: Transition (Ranvier 방식, 시각화됨)
#[transition]
async fn authenticate(req: Request) -> Outcome<AuthContext, AuthError> {
    // Schematic 그래프에 표시됨
}

// 옵션 B: Tower (생태계 방식, 시각화되지 않음)
let app = ServiceBuilder::new()
    .layer(RequireAuthorizationLayer::new(...))
    .service(ranvier_handler);

// 헬퍼 함수 (Transition 외부) — Result OK
fn parse_config(path: &Path) -> Result<Config, ConfigError> {
    // ...
}

// Transition (핵심) — Outcome 필수
#[transition]
async fn load_config(path: &Path) -> Outcome<Config, AppError> {
    let config = parse_config(path)
        .map_err(AppError::from)?;  // Result → Outcome 변환
    Outcome::ok(config)
}

// 요청 범위: Bus (요청마다 변경됨)
#[transition]
async fn handler(auth: &AuthContext, tenant: &TenantId) -> Outcome<...> {
    // auth, tenant은 Bus에서 옴
}

// 전역 공유: Axum State (모든 요청에 대해 동일)
async fn axum_route(
    State(pool): State<PgPool>,
    State(schematic): State<Schematic>,
) -> Response {
    // pool, schematic은 요청 간에 공유됨
}

// 간단한 경우: Tower 미들웨어 (시각화되지 않음)
let app = ServiceBuilder::new()
    .layer(ValidateRequestHeaderLayer::bearer("secret"))
    .service(ranvier_handler);

// 복잡한 경우: Transition (시각화됨)
#[transition]
async fn authenticate(req: Request) -> Outcome<AuthContext, AuthError> { /*...*/ }

#[transition]
async fn check_subscription(auth: &AuthContext) -> Outcome<(), AuthError> { /*...*/ }

#[transition]
async fn authorize(auth: &AuthContext, required_role: &str) -> Outcome<(), AuthError> { /*...*/ }

let pipeline = Axon::simple()
    .pipe(authenticate, check_subscription, authorize, handle_request)
    .build();

use tower::ServiceBuilder;
use tower_http::cors::{CorsLayer, Any};

let app = ServiceBuilder::new()
    .layer(
        CorsLayer::new()
            .allow_origin(Any)
            .allow_methods(Any)
    )
    .service(ranvier_handler);

// Transition 내부에서 모든 DB 라이브러리 사용
#[transition]
async fn fetch_user(pool: &PgPool, id: UserId) -> Outcome<User, DbError> {
    let user = sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", id)
        .fetch_one(pool)
        .await
        .map_err(DbError::from)?;
    Outcome::ok(user)
}

#[transition]
async fn update_balance(user: &User, amount: i64) -> Outcome<(), DbError> {
    // Schematic에 표시됨: fetch_user → update_balance
    sqlx::query!("UPDATE users SET balance = balance + $1 WHERE id = $2", amount, user.id)
        .execute(pool)
        .await?;
    Outcome::ok(())
}

use tower_http::trace::TraceLayer;

let app = ServiceBuilder::new()
    .layer(TraceLayer::new_for_http())  // 자동 추적
    .service(ranvier_handler);

// 또는 Transition 내부에서 수동 계측:
#[transition]
async fn process(input: Input) -> Outcome<Output, Error> {
    tracing::info!("Processing input: {:?}", input);
    // ...
}

// Tower가 HTTP → WebSocket으로 업그레이드
let ws_layer = WebSocketUpgrade::new(|socket| async {
    // WebSocket 핸들러 내부:
    while let Some(msg) = socket.recv().await {
        // Ranvier Transition이 각 메시지를 처리
        let outcome = message_pipeline.execute(msg).await;
        socket.send(outcome.into()).await;
    }
});

START
  │
  ├─ 핵심 비즈니스 로직? ───예──> Ranvier 방식 (Transition)
  │
  ├─ 시각화 필요? ────예──> Ranvier 방식
  │
  ├─ 순수 인프라? ───예──> 생태계 방식 (Tower/라이브러리)
  │
  ├─ 기존에서 마이그레이션? ────예──> 하이브리드 (Tower + Ranvier)
  │
  └─ 기본 ────────────────────> Ranvier 방식 (확실하지 않을 때)

                    START: "Ranvier, Tower, 또는 둘 다 사용해야 할까요?"
                                      │
                                      ▼
        ┌─────────────────────────────────────────────────────┐
        │  Q1: 처음부터 새 프로젝트를 시작하고 있습니까?       │
        └─────────────────────────────────────────────────────┘
                 │                                │
                예                               아니요
                 │                                │
                 ▼                                ▼
        ┌───────────────────┐         ┌─────────────────────────┐
        │ Ranvier 방식      │         │ Q2: 기존 코드베이스?     │
        │ (Transition)      │         └─────────────────────────┘
        │                   │                     │
        │ ✅ 권장:          │         ┌───────────┴──────────────┐
        │ - 완전한 가시성   │        예                         아니요
        │ - 깨끗한 시작     │         │                          │
        │ - 모범 사례       │         ▼                          ▼
        └───────────────────┘  ┌──────────────┐      ┌──────────────────┐
                               │ Tower 앱?    │      │ 다른 프레임워크?  │
                               └──────────────┘      └──────────────────┘
                                      │                       │
                              ┌───────┴────────┐             │
                             예               아니요          │
                              │                 │             │
                              ▼                 ▼             ▼
                     ┌────────────────┐  ┌─────────────┐  ┌────────────┐
                     │ 하이브리드     │  │ actix/Axum? │  │ 독립형     │
                     │ (Tower +       │  └─────────────┘  │ 서비스?    │
                     │  Ranvier)      │         │         └────────────┘
                     │                │    ┌────┴─────┐        │
                     │ ✅ 시작:       │   예        아니요      │
                     │ - Tower 유지   │    │          │         ▼
                     │   레이어       │    ▼          ▼    ┌──────────┐
                     │ - 새 기능에    │ ┌─────┐  ┌──────┐ │ Ranvier  │
                     │   Ranvier 추가 │ │actix│  │사용자│ │ with     │
                     │                │ │에   │  │정의  │ │ 생태계   │
                     └────────────────┘ │임베드│ │래핑  │ │ 도구     │
                                        └─────┘  └──────┘ └──────────┘

# 새 프로젝트 생성
cargo new my-app
cd my-app

# Ranvier 추가
cargo add ranvier --features http

# 첫 번째 transition 작성
cat > src/main.rs <<'EOF'
use ranvier::prelude::*;

#[transition]
async fn hello() -> Outcome<String, Never> {
    Outcome::ok("Hello from Ranvier!".into())
}

#[tokio::main]
async fn main() {
    let app = Axon::simple().pipe(hello).build();
    // HTTP 서버 설정...
}
EOF

// 1주차: 모든 Tower 레이어 유지, 하나의 새 엔드포인트에 Ranvier 추가
let existing_tower_app = ServiceBuilder::new()
    .layer(CorsLayer::permissive())
    .layer(AuthLayer::new(...))
    .layer(TraceLayer::new())
    .service(tower_router);  // 기존 유지

// 새 기능을 위한 Ranvier 핸들러 추가
#[transition]
async fn new_feature() -> Outcome<Response, Error> {
    // 새 코드는 Ranvier 사용
}

// 2-4주차: 더 많은 엔드포인트를 Ranvier로 변환
// 5주차 이상: 선택적으로 Tower auth를 Ranvier Transition으로 변환

use actix_web::{web, App, HttpServer, HttpResponse};
use ranvier::prelude::*;

// Ranvier transition
#[transition]
async fn process(input: String) -> Outcome<String, Error> {
    // 비즈니스 로직
    Outcome::ok(input.to_uppercase())
}

// actix 핸들러가 Ranvier 호출
async fn actix_handler(body: String) -> HttpResponse {
    let schematic = Axon::simple().pipe(process).build();
    match schematic.execute(body).await {
        Ok(result) => HttpResponse::Ok().body(result),
        Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
    }
}

#[actix_web::main]
async fn main() {
    HttpServer::new(|| {
        App::new().route("/", web::post().to(actix_handler))
    }).bind("127.0.0.1:8080")?.run().await
}

use axum::{Router, routing::post, extract::State};

// Ranvier schematic을 공유 상태로
#[tokio::main]
async fn main() {
    let schematic = Axon::simple().pipe(process).build();

    let app = Router::new()
        .route("/", post(axum_handler))
        .with_state(schematic);

    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await
}

async fn axum_handler(State(schematic): State<Schematic>, body: String) -> String {
    schematic.execute(body).await.unwrap_or_else(|e| e.to_string())
}

// Ranvier의 복잡한 비즈니스 로직
let order_pipeline = Axon::simple()
    .pipe(validate_order, check_inventory)
    .parallel(calculate_tax, apply_discount, check_fraud)
    .pipe(charge_payment, create_shipment, send_confirmation)
    .build();

// 모든 HTTP 프레임워크로 서빙
// - Hyper: ranvier-http
// - Axum: State(order_pipeline)
// - actix: web::Data<Schematic>
// - Tower: ServiceBuilder::service(ranvier_adapter)

// Tower만 사용
let app = ServiceBuilder::new()
    .layer(CorsLayer::permissive())
    .layer(AuthLayer::bearer("secret"))
    .service(simple_handler);

// Ranvier: 간단
#[transition]
async fn my_logic(input: Input) -> Outcome<Output, Error> { ... }

// Tower: 복잡
impl<S> Service<Request> for MyService<S> {
    type Response = Response;
    type Error = Error;
    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
    fn call(&mut self, req: Request) -> Self::Future { ... }
}

┌─────────────────────────────┐
│ API Gateway (Tower/Axum)    │  ← 간단한 라우팅
└──────────┬──────────────────┘
           │
           ▼
┌─────────────────────────────┐
│ Orchestrator (Ranvier)      │  ← 복잡한 워크플로우, 시각화됨
│  - 다중 서비스 호출         │
│  - Saga 패턴                │
│  - 보상 로직                │
└──────┬─────┬────────┬───────┘
       │     │        │
       ▼     ▼        ▼
   ┌────┐ ┌────┐  ┌────┐
   │User│ │Pay │  │Ship│       ← 간단한 CRUD (모든 프레임워크)
   └────┘ └────┘  └────┘

use ranvier::prelude::*;
use jsonwebtoken::{decode, DecodingKey, Validation};
use serde::{Deserialize, Serialize};

// 도메인 타입
#[derive(Debug, Clone, Serialize, Deserialize)]
struct AuthContext {
    user_id: String,
    roles: Vec<String>,
}

#[derive(Debug, thiserror::Error)]
enum AuthError {
    #[error("Missing authorization header")]
    MissingHeader,
    #[error("Invalid token: {0}")]
    InvalidToken(String),
    #[error("Unauthorized: requires role {0}")]
    Unauthorized(String),
}

// Transition 1: JWT 추출 및 검증
#[transition]
async fn authenticate(req: Request) -> Outcome<AuthContext, AuthError> {
    // Authorization 헤더 추출
    let header = req.headers()
        .get("Authorization")
        .ok_or(AuthError::MissingHeader)?;

    let token = header
        .to_str()
        .ok()?
        .strip_prefix("Bearer ")
        .ok_or(AuthError::InvalidToken("Invalid format".into()))?;

    // JWT 검증
    let secret = std::env::var("JWT_SECRET").expect("JWT_SECRET not set");
    let key = DecodingKey::from_secret(secret.as_bytes());
    let claims = decode::<AuthContext>(token, &key, &Validation::default())
        .map_err(|e| AuthError::InvalidToken(e.to_string()))?
        .claims;

    // AuthContext가 자동으로 Bus에 저장됩니다
    Outcome::ok(claims)
}

// Transition 2: 역할 기반 권한 부여 확인
#[transition]
async fn authorize(auth: &AuthContext, required_role: &str) -> Outcome<(), AuthError> {
    // AuthContext가 Bus에서 자동으로 주입됩니다
    if !auth.roles.contains(&required_role.to_string()) {
        return Outcome::err(AuthError::Unauthorized(required_role.into()));
    }
    Outcome::ok(())
}

// Transition 3: 감사 로그 (선택 사항)
#[transition]
async fn audit_log(auth: &AuthContext, req: &Request) -> Outcome<(), Never> {
    tracing::info!(
        user_id = %auth.user_id,
        path = %req.uri().path(),
        "Authenticated request"
    );
    Outcome::ok(())
}

// Transition 4: 비즈니스 로직
#[transition]
async fn protected_handler(auth: &AuthContext) -> Outcome<Response, AppError> {
    let body = format!("Hello, {}! Roles: {:?}", auth.user_id, auth.roles);
    Ok(Response::new(body.into()))
}

// 파이프라인 조합
fn main() {
    let admin_pipeline = Axon::simple::<AppError>()
        .pipe(authenticate, |auth| authorize(auth, "admin"), audit_log, protected_handler)
        .build();

    // VSCode에서 시각화:
    // authenticate → authorize → audit_log → protected_handler
    //                  ↓ (권한 없는 경우)
    //                401 Unauthorized
}

use tower::ServiceBuilder;
use tower_http::auth::RequireAuthorizationLayer;
use hyper::{Request, Response, Body};

// Tower 권한 부여 검증자
async fn validate_api_key(request: &Request<Body>) -> Result<(), &'static str> {
    let header = request.headers()
        .get("X-API-Key")
        .ok_or("Missing API key")?;

    let key = header.to_str().map_err(|_| "Invalid API key format")?;

    if key != "secret-key-123" {
        return Err("Invalid API key");
    }

    Ok(())
}

// Ranvier 핸들러 (비즈니스 로직)
#[transition]
async fn business_logic(req: Request) -> Outcome<Response, AppError> {
    // Tower가 이미 API 키를 검증했습니다
    Ok(Response::new("Authenticated!".into()))
}

fn main() {
    // Tower가 인증을 처리 (Schematic에 없음)
    let app = ServiceBuilder::new()
        .layer(RequireAuthorizationLayer::custom(validate_api_key))
        .service(ranvier_handler);

    // Ranvier가 비즈니스 로직을 처리 (Schematic에 있음)
}

use tower::ServiceBuilder;
use tower_http::{cors::CorsLayer, limit::RateLimitLayer};
use std::time::Duration;

// Tower가 인프라를 처리
let app = ServiceBuilder::new()
    .layer(CorsLayer::permissive())  // 인프라: CORS
    .layer(RateLimitLayer::new(100, Duration::from_secs(60)))  // 인프라: 속도 제한
    .service(ranvier_handler);

// Ranvier가 비즈니스 로직을 처리 (시각화됨)
let ranvier_handler = Axon::simple::<AppError>()
    .pipe(authenticate, authorize, audit_log, protected_handler)
    .build();

Tower 레이어 (숨김):
  ├─ CORS
  └─ Rate Limit
      ↓
Ranvier 파이프라인 (시각화됨):
  authenticate → authorize → audit_log → protected_handler

#[transition]
async fn authenticate(req: Request) -> Outcome<AuthContext, AuthError> { /*...*/ }

#[transition]
async fn parse_order(req: &Request) -> Outcome<Order, ValidationError> { /*...*/ }

#[transition]
async fn check_inventory(order: &Order) -> Outcome<(), InventoryError> { /*...*/ }

#[transition]
async fn calculate_tax(order: &Order, auth: &AuthContext) -> Outcome<Tax, TaxError> {
    // 세율은 사용자의 위치에 따라 달라집니다 (auth에서)
    /*...*/
}

#[transition]
async fn apply_discount(order: &Order, auth: &AuthContext) -> Outcome<Discount, ()> {
    // VIP 사용자는 10% 할인
    if auth.roles.contains(&"vip".into()) {
        Outcome::ok(Discount::percent(10))
    } else {
        Outcome::ok(Discount::none())
    }
}

#[transition]
async fn charge_payment(order: &Order, tax: &Tax, discount: &Discount) -> Outcome<PaymentId, PaymentError> { /*...*/ }

#[transition]
async fn create_shipment(order: &Order, payment: &PaymentId) -> Outcome<ShipmentId, ShipmentError> { /*...*/ }

let pipeline = Axon::simple::<AppError>()
    .pipe(authenticate, parse_order)
    .parallel(check_inventory, calculate_tax, apply_discount)  // 병렬 실행
    .pipe(charge_payment, create_shipment)
    .build();

authenticate → parse_order → ┬─ check_inventory ─┐
                              ├─ calculate_tax ────┤→ charge_payment → create_shipment
                              └─ apply_discount ───┘