// ── Full anatomy of a cell · 세포의 완전한 해부 구조 ──────

cell EmailValidator {

  // [required] role — natural language, the reason this cell exists · 역할 선언
  role     : "Validate the format and domain of an email address"

  // [optional] tags — metadata for search/classification · 검색·분류용 메타데이터
  tags     : ["validation", "auth", "input"]

  // [optional] lifespan — the cell's lifetime policy · 수명 정책
  lifespan : stateless   // stateless | persistent | session

  // [required] membrane — the I/O contract · 입출력 계약
  membrane {
    accepts: RawEmailInput
    emits  : ValidEmail | InvalidEmail
    rejects: NullInput    // this signal is not let through · 통과 불가
  }

  // [optional] internal state — only valid when lifespan is persistent · 내부 상태
  nucleus {
    cache: Map<String, Bool>
  }

  // [required] signal handler · 신호 핸들러
  on (RawEmailInput input) {
    if isValidFormat(input.address) && domainExists(input.address) {
      emit ValidEmail(address: input.address)
    } else {
      emit InvalidEmail(reason: "Invalid format or domain mismatch")
    }
  }

  // [optional] apoptosis hook · 세포 사멸 훅
  apoptosis {
    clearCache(nucleus.cache)
  }
}

// ── Signal definitions · 신호 정의 ───────────────────────

// 1. Data signal (most common) — carries immutable data · 데이터 신호
signal UserRegistered {
  userId   : UUID
  email    : Email
  createdAt: Timestamp
}

// 2. Error signal — detected by the immune system · 에러 신호
signal DatabaseError extends ErrorSignal {
  code     : Int
  message  : String
  retryable: Bool
}

// 3. Empty signal — its mere existence is the meaning · 빈 신호
signal SessionExpired   // no data, only the fact it occurred · 발생 사실만 전달
signal HealthCheckPing  // health check request · 상태 확인 요청

// 4. Generic signal — used with a genome · 제네릭 신호
signal Paginated<T> {
  items  : List<T>
  total  : Int
  page   : Int
  hasMore: Bool
}

// 5. Priority signal — nervous system decides processing order · 우선순위 신호
signal PaymentFailed priority: critical {
  orderId : UUID
  amount  : Money
  reason  : String
}

// ── Signal flow patterns · 신호 흐름 패턴 ────────────────

// Pattern 1: Pipeline (A → B → C) · 파이프라인
cell Parser {
  membrane { accepts: RawInput; emits: ParsedData }
  on(RawInput raw) { emit ParsedData(parse(raw)) }
}

// Pattern 2: Fan-out (one signal → many cells) · 분기
cell OrderCompleted_EmailNotifier {
  membrane { accepts: OrderCompleted; emits: EmailSent }
  on(OrderCompleted e) { emit EmailSent(to: e.userEmail) }
}

cell OrderCompleted_StockReducer {
  membrane { accepts: OrderCompleted; emits: StockUpdated }
  on(OrderCompleted e) { emit StockUpdated(sku: e.sku) }
}

// Pattern 3: Absorb (stop signal propagation) · 흡수
cell RateLimiter {
  membrane { accepts: ApiRequest; emits: TooManyRequests }
  on(ApiRequest req) {
    if exceeded(req.clientId) {
      absorb   // stop propagation — never reaches the next cell · 전파 중단
      emit TooManyRequests(clientId: req.clientId)
    }
  }
}

// Pattern 4: Query (a special signal that awaits a reply) · 질의
cell UserFinder {
  membrane {
    accepts: FindUser query       // query keyword: awaits a response signal · 응답 신호 대기
    emits  : UserFound | UserNotFound
  }
  on(FindUser q) {
    let user = db.find(q.userId)
    user ? emit UserFound(user) : emit UserNotFound
  }
}

// ── Tissue: authentication pipeline · 인증 파이프라인 ─────

tissue AuthPipeline {

  // the tissue's external contract · 외부 계약
  membrane {
    accepts: LoginRequest
    emits  : SessionCreated | AuthDenied
  }

  // linear flow: run in order · 선형 흐름
  flow linear {
    InputSanitizer    // 1. sanitize input · 입력 정제
    → CredentialChecker // 2. check credentials · 자격 확인
    → TokenIssuer       // 3. issue token · 토큰 발급
    → SessionCreator    // 4. create session · 세션 생성
  }

  // conditional branch · 조건부 분기
  when (AuthDenied) {
    AuditLogger     // audit log on failure · 실패 시 감사 로그
    BruteForceGuard // brute-force detection · 브루트포스 감지
  }
}

// ── Parallel tissue · 병렬 조직 ──────────────────────────
tissue OrderNotifications {

  membrane {
    accepts: OrderCompleted
    emits  : AllNotified
  }

  // parallel flow: run together, emit after all complete · 병렬 흐름
  flow parallel {
    EmailNotifier
    SmsNotifier
    PushNotifier
    SlackNotifier
  }

  after all {
    emit AllNotified
  }
}

organ UserOrgan {

  // the organ's external contract · 기관의 외부 계약
  membrane {
    accepts: LoginRequest | RegisterRequest | ProfileUpdateRequest
    emits  : UserEvent    // the organ's external signal type · 외부 신호 타입
  }

  // internal tissue composition · 내부 조직 구성
  tissues {
    AuthPipeline     // authentication · 인증 처리
    RegistrationFlow // sign-up · 회원가입 처리
    ProfileManager   // profile management · 프로필 관리
  }

  // signals the organ exposes (the rest stay isolated) · 외부 공개 신호
  exports {
    UserRegistered
    UserLoggedIn
    UserDeleted
  }

  // organ-level state (shared by all tissues) · 기관 수준 공유 상태
  shared {
    userRepository: UserRepository
    auditLog       : AuditLogger
  }
}

organism ECommerceApp {

  // ① organ list · 기관 목록
  organs {
    UserOrgan
    ProductOrgan
    OrderOrgan
    PaymentOrgan
    NotificationOrgan
  }

  // ② nervous — inter-organ signal routing · 신경계
  nervous EventBus {
    // declare which signal flows to which organ · 신호 흐름 명시
    UserOrgan.UserRegistered    → NotificationOrgan
    OrderOrgan.OrderPlaced       → [PaymentOrgan, ProductOrgan]
    PaymentOrgan.PaymentConfirmed → [OrderOrgan, NotificationOrgan]
    PaymentOrgan.PaymentFailed    → [OrderOrgan, NotificationOrgan]
  }

  // ③ immune — error-handling strategy (block form, canonical EBNF) · 면역계
  immune ErrorPolicy {
    on DatabaseError {
      strategy: retry
      retries : 3
      backoff : exponential
    }
    on NetworkTimeout {
      strategy: fallback
    }
    on UnknownError {
      strategy: isolate
      escalate: true
    }
  }

  // ④ environment configuration · 환경 설정
  environment {
    runtime  : "node:20"
    transport: "redis"    // actual transport layer for nervous · 전송 계층
    scale    : auto        // automatic cell division/scaling · 자동 분열·스케일링
    observe  : "opentelemetry"
  }
}

nervous AppNervousSystem {

  // basic routing · 기본 라우팅
  UserOrgan.UserBanned → OrderOrgan  // simple forward · 단순 전달

  // transform routing — convert then forward · 변환 라우팅
  PaymentOrgan.PaymentConfirmed
    → transform(p) { OrderApproved(orderId: p.orderId) }
    → OrderOrgan

  // conditional routing · 조건부 라우팅
  OrderOrgan.OrderPlaced
    → when (o.amount > 1000000) → FraudDetectionOrgan
    → always                    → PaymentOrgan

  // signal aggregation — fires only when all signals arrive · 신호 집계
  aggregate {
    wait: [PaymentConfirmed, InventoryReserved]
    emit: ReadyToShip
    timeout: 30s → FulfillmentFailed
  }
}

immune GlobalPolicy {

  // strategy per error type · 오류 유형별 대응 전략
  on DatabaseError {
    strategy: retry(attempts: 3, backoff: exponential)
    fallback: useCache
    escalate: after 3 failures
  }

  on MemoryExceeded {
    strategy: quarantine   // isolate cell, block signals · 세포 격리
    recover : divide        // split load to new cells · 부하 분산 분열
  }

  on UnhandledSignal {
    strategy: deadLetter   // store undeliverable signals · 처리 불가 신호 보관
    alert   : true
  }

  // Circuit Breaker · 회로 차단기
  circuit {
    threshold  : 5 failures in 60s
    open       : 30s   // break duration · 차단 시간
    halfOpen   : 1 probe  // recovery probe · 회복 탐침
  }
}

// ── Genome: reusable cell template · 재사용 가능한 세포 템플릿 ──

genome CrudCell<Entity, CreateCmd, UpdateCmd> {
  membrane {
    accepts: CreateCmd | UpdateCmd | DeleteCmd<Entity>
    emits  : Created<Entity> | Updated<Entity> | Deleted<Entity>
  }

  on(CreateCmd cmd) { emit Created<Entity>(persist(cmd)) }
  on(UpdateCmd cmd) { emit Updated<Entity>(merge(cmd)) }
  on(DeleteCmd<Entity> cmd) { emit Deleted<Entity>(cmd.id) }
}

// instantiate the genome — create concrete cells · genome 인스턴스화
cell ProductCell from CrudCell<Product, CreateProduct, UpdateProduct>
cell UserCell    from CrudCell<User,    CreateUser,    UpdateUser>

// ── Behavioral genome (used like an interface) · 행동 Genome ──
genome Retryable {
  maxRetries: Int = 3
  backoff   : BackoffStrategy = exponential

  on ErrorSignal {
    if retries < maxRetries { retry }
    else { emit Exhausted }
  }
}

// mix a genome into a cell · 세포에 genome 믹스인
cell PaymentProcessor with Retryable {
  role: "Process payments and auto-retry"
  membrane {
    accepts: ProcessPayment
    emits  : PaymentSuccess | PaymentFailed
  }
  // Retryable's retry logic is injected automatically · 재시도 로직 자동 주입
}

// ── Cell division — horizontal scaling · 세포 분열 ───────
cell ImageProcessor {
  role: "Resize and compress images"
  lifespan: stateless

  // auto-divide under load · 부하에 따라 자동 분열
  divide when (queue.depth > 100) {
    max     : 16         // up to 16 replicas · 최대 16개 복제
    strategy: round-robin
  }

  membrane { accepts: ImageTask; emits: ImageReady }
  on(ImageTask t) { emit ImageReady(process(t)) }
}

// ── Cell mutation — A/B test / feature flag · 세포 변이 ───
cell RecommendationEngine {
  role: "Product recommendation algorithm"

  // mutate the algorithm based on an env variable · 환경 변수에 따라 변이
  mutate when (env.feature.mlRecommend == true) {
    role: "ML-based personalized recommendation"
    membrane { accepts: UserContext; emits: MLRecommendations }
    on(UserContext u) { emit MLRecommendations(mlModel.predict(u)) }
  }

  // default behavior (when the mutate condition is not met) · 기본 동작
  membrane { accepts: UserContext; emits: BasicRecommendations }
  on(UserContext u) { emit BasicRecommendations(rule.apply(u)) }
}

from cellcoding import cell, membrane, signal, emit

# wrap an existing Python function as a cell · 기존 함수를 세포로 래핑
@cell(
    role="Validate user email",
    accepts="RawEmailInput",
    emits=["ValidEmail", "InvalidEmail"]
)
def email_validator(input_signal):
    if is_valid_email(input_signal.address):
        return emit("ValidEmail", address=input_signal.address)
    return emit("InvalidEmail", reason="format error")