dependencies {
    implementation("io.github.dancrrdz93:coredomainplatform:1.1.0")
}

// build.gradle.kts
dependencies {
    implementation(libs.core.domain.platform)
}

public data class DomainDependencies(
    val clock: ClockProvider,    // ¿Qué hora es?
    val idProvider: IdProvider,  // Dame un ID único
)

// ❌ Impuro — side-effects directos dentro del dominio
val task = Task(
    id = TaskId(UUID.randomUUID().toString()),   // acoplado a JVM, no compila en iOS
    createdAt = System.currentTimeMillis(),        // resultado distinto en cada ejecución
)

// ✅ Determinista — el dominio no sabe de dónde vienen los valores
val task = Task(
    id = TaskId(deps.idProvider.next()),
    createdAt = deps.clock.nowMillis(),
)

// Android (Application.onCreate) o iOS (AppDelegate)
val domainDeps = DomainDependencies(
    clock = ClockProvider { System.currentTimeMillis() },
    idProvider = IdProvider { UUID.randomUUID().toString() },
)

val testDeps = DomainDependencies(
    clock = ClockProvider { 1_700_000_000_000L },
    idProvider = IdProvider { "fixed-id-123" },
)

// Ahora puedes verificar con exactitud:
val result = createTask(CreateTaskParams("Comprar leche"))
val task = result.getOrNull()!!
assertEquals("fixed-id-123", task.id.value)          // ✅ siempre pasa
assertEquals(1_700_000_000_000L, task.createdAt)     // ✅ siempre pasa

class PlaceOrderUseCase(
    private val deps: DomainDependencies,          // ✅ cross-cutting: clock + id
    private val orderRepository: OrderRepository,  // ✅ específico de esta feature
    private val inventoryGateway: SuspendGateway<...>,
) : SuspendUseCase<PlaceOrderParams, Order> { ... }

data class LoanEligibilityParams(
    val monthlyIncome: Double,
    val currentDebtPercent: Double,
    val creditScore: Int,
    val requestedAmount: Double,
)

data class LoanEligibilityResult(
    val approved: Boolean,
    val maxApprovedAmount: Double,
    val interestRate: Double,
    val reason: String,
)

class EvaluateLoanEligibility : PureUseCase<LoanEligibilityParams, LoanEligibilityResult> {

    override fun invoke(params: LoanEligibilityParams): DomainResult<LoanEligibilityResult> {
        // Validar input
        if (params.monthlyIncome <= 0)
            return domainFailure(DomainError.Validation("monthlyIncome", "debe ser positivo"))
        if (params.creditScore !in 300..850)
            return domainFailure(DomainError.Validation("creditScore", "debe estar entre 300 y 850"))

        // Regla 1: No prestar si el endeudamiento supera el 40%
        if (params.currentDebtPercent > 40.0) {
            return LoanEligibilityResult(
                approved = false,
                maxApprovedAmount = 0.0,
                interestRate = 0.0,
                reason = "Endeudamiento actual supera el 40%",
            ).asSuccess()
        }

        // Regla 2: Determinar tasa de interés según score crediticio
        val interestRate = when {
            params.creditScore >= 750 -> 8.5
            params.creditScore >= 650 -> 12.0
            params.creditScore >= 550 -> 18.5
            else -> return LoanEligibilityResult(
                approved = false,
                maxApprovedAmount = 0.0,
                interestRate = 0.0,
                reason = "Score crediticio insuficiente (mínimo 550)",
            ).asSuccess()
        }

        // Regla 3: Monto máximo = 5x ingreso mensual
        val maxAmount = params.monthlyIncome * 5
        val approved = params.requestedAmount <= maxAmount

        return LoanEligibilityResult(
            approved = approved,
            maxApprovedAmount = maxAmount,
            interestRate = interestRate,
            reason = if (approved) "Aprobado" else "Monto solicitado excede el máximo permitido",
        ).asSuccess()
    }
}

// Uso — síncrono, se puede llamar desde el main thread sin problema:
val result = evaluateLoanEligibility(
    LoanEligibilityParams(
        monthlyIncome = 45_000.0,
        currentDebtPercent = 25.0,
        creditScore = 720,
        requestedAmount = 150_000.0,
    )
)
// → Success(LoanEligibilityResult(approved=true, maxApprovedAmount=225000.0, interestRate=12.0, ...))

data class PlaceOrderParams(
    val cartId: CartId,
    val shippingAddressId: AddressId,
    val paymentMethodId: PaymentMethodId,
)

class PlaceOrderUseCase(
    private val deps: DomainDependencies,
    private val cartRepository: CartRepository,
    private val inventoryGateway: SuspendGateway<List<CartItem>, InventoryCheckResult>,
    private val orderRepository: OrderRepository,
    private val taxCalculator: PureUseCase<TaxParams, TaxResult>,
) : SuspendUseCase<PlaceOrderParams, Order> {

    override suspend fun invoke(params: PlaceOrderParams): DomainResult<Order> {
        // 1. Obtener el carrito
        val cart = cartRepository.findById(params.cartId).getOrElse { return domainFailure(it) }
            ?: return domainFailure(DomainError.NotFound("Cart", params.cartId.value))

        if (cart.items.isEmpty())
            return domainFailure(DomainError.Validation("cart", "El carrito está vacío"))

        // 2. Verificar inventario disponible
        val inventoryCheck = inventoryGateway.execute(cart.items).getOrElse { return domainFailure(it) }
        if (!inventoryCheck.allAvailable)
            return domainFailure(DomainError.Conflict(
                detail = "Sin stock: ${inventoryCheck.unavailableItems.joinToString { it.name }}"
            ))

        // 3. Calcular impuestos (lógica pura — PureUseCase)
        val tax = taxCalculator(TaxParams(cart.subtotal, cart.shippingState))
            .getOrElse { return domainFailure(it) }

        // 4. Crear la orden
        val order = Order(
            id = OrderId(deps.idProvider.next()),
            items = cart.items,
            subtotal = cart.subtotal,
            tax = tax.amount,
            total = cart.subtotal + tax.amount,
            status = OrderStatus.CONFIRMED,
            createdAt = deps.clock.nowMillis(),
        )

        // 5. Persistir
        return orderRepository.save(order).map { order }
    }
}

// Uso:
viewModelScope.launch {
    placeOrder(PlaceOrderParams(cartId, addressId, paymentId))
        .onSuccess { order -> navigateToConfirmation(order.id) }
        .onFailure { error ->
            when (error) {
                is DomainError.Conflict -> showOutOfStockDialog(error.detail)
                is DomainError.Validation -> showCartError(error.detail)
                else -> showGenericError(error.message)
            }
        }
}

data class ShipmentFilterParams(
    val status: ShipmentStatus,
    val warehouseId: WarehouseId,
)

class ObserveShipmentsByStatus(
    private val shipmentRepository: ShipmentRepository,
) : FlowUseCase<ShipmentFilterParams, List<Shipment>> {

    override fun invoke(params: ShipmentFilterParams): Flow<DomainResult<List<Shipment>>> {
        return shipmentRepository
            .observeByWarehouseAndStatus(params.warehouseId, params.status)
    }
}

// Uso — en el ViewModel:
init {
    viewModelScope.launch {
        observeShipmentsByStatus(
            ShipmentFilterParams(
                status = ShipmentStatus.IN_TRANSIT,
                warehouseId = currentWarehouseId,
            )
        ).collect { result ->
            result
                .onSuccess { shipments ->
                    _uiState.value = DashboardState.Loaded(
                        shipments = shipments,
                        count = shipments.size,
                    )
                }
                .onFailure { error ->
                    _uiState.value = DashboardState.Error(error.message)
                }
        }
    }
}

class LogoutUseCase(
    private val sessionGateway: CommandGateway<LogoutCommand>,
    private val localCacheGateway: CommandGateway<ClearCacheCommand>,
    private val auditRepository: WriteRepository<AuditEvent>,
    private val deps: DomainDependencies,
) : NoParamsUseCase<Unit> {

    override suspend fun invoke(): DomainResult<Unit> {
        // 1. Invalidar token en el servidor
        sessionGateway.dispatch(LogoutCommand).getOrElse { return domainFailure(it) }

        // 2. Limpiar datos locales sensibles
        localCacheGateway.dispatch(ClearCacheCommand).getOrElse { return domainFailure(it) }

        // 3. Registrar evento de auditoría
        val event = AuditEvent(
            id = AuditEventId(deps.idProvider.next()),
            type = "LOGOUT",
            timestamp = deps.clock.nowMillis(),
        )
        return auditRepository.save(event)
    }
}

// Uso — sin parámetros:
viewModelScope.launch {
    logout()
        .onSuccess { navigateToLogin() }
        .onFailure { error -> showError("No se pudo cerrar sesión: ${error.message}") }
}

class ObservePortfolioValue(
    private val portfolioRepository: PortfolioRepository,
) : NoParamsFlowUseCase<PortfolioSummary> {

    override fun invoke(): Flow<DomainResult<PortfolioSummary>> {
        return portfolioRepository.observeCurrentUserPortfolio()
        // Emite cada vez que cambia un precio o se ejecuta una transacción
    }
}

data class PortfolioSummary(
    val totalValue: Double,
    val dailyChange: Double,
    val dailyChangePercent: Double,
    val holdings: List<Holding>,
)

// Uso — en el ViewModel de la pantalla principal:
init {
    viewModelScope.launch {
        observePortfolioValue()
            .collect { result ->
                result
                    .onSuccess { summary ->
                        _uiState.value = HomeState.Loaded(
                            totalValue = summary.totalValue,
                            changePercent = summary.dailyChangePercent,
                            isPositive = summary.dailyChange >= 0,
                        )
                    }
                    .onFailure { error ->
                        _uiState.value = HomeState.Error(error.message)
                    }
            }
    }
}

// Extensión que vive en tu capa de datos (NO en ninguno de los dos SDKs)
fun NetworkError.toDomainError(): DomainError = when (this) {
    // ── Transporte ──
    is NetworkError.Connectivity -> DomainError.Infrastructure(
        detail = "Sin conexión a internet",
        cause = diagnostic?.cause,     // ← Throwable? del Data SDK, NO `this`
    )
    is NetworkError.Timeout -> DomainError.Infrastructure(
        detail = "Tiempo de espera agotado",
        cause = diagnostic?.cause,
    )
    is NetworkError.Cancelled -> DomainError.Cancelled(
        detail = "Solicitud cancelada",  // ← Intencional, no falla de infra
    )

    // ── HTTP semántico ──
    is NetworkError.Authentication -> DomainError.Unauthorized("Autenticación requerida")
    is NetworkError.Authorization  -> DomainError.Unauthorized("Acceso denegado")
    is NetworkError.ClientError -> when (statusCode) {
        404  -> DomainError.NotFound("Recurso", diagnostic?.description ?: "")
        409  -> DomainError.Conflict(message)
        422  -> DomainError.Validation("request", diagnostic?.description ?: message)
        else -> DomainError.Infrastructure("Error HTTP $statusCode", diagnostic?.cause)
    }
    is NetworkError.ServerError -> DomainError.Infrastructure(
        detail = "Error del servidor ($statusCode)",
        cause = diagnostic?.cause,
    )

    // ── Procesamiento de datos ──
    is NetworkError.Serialization -> DomainError.Infrastructure(
        detail = "Error al procesar respuesta",
        cause = diagnostic?.cause,
    )
    is NetworkError.ResponseValidation -> DomainError.Infrastructure(
        detail = reason,
        cause = diagnostic?.cause,
    )

    // ── Catch-all ──
    is NetworkError.Unknown -> DomainError.Unknown(
        detail = message,
        cause = diagnostic?.cause,
    )
}

// ❌ Sin DomainError.Cancelled — ambos son Infrastructure
when (error) {
    is DomainError.Infrastructure -> showErrorDialog(error.message)
    // "Solicitud cancelada" muestra un diálogo de error innecesario
}

// ✅ Con DomainError.Cancelled — el ViewModel decide correctamente
when (error) {
    is DomainError.Cancelled -> { /* no-op, el usuario ya se fue */ }
    is DomainError.Infrastructure -> showErrorDialog(error.message)
}

class UserRepositoryImpl(
    private val dataSource: UserRemoteDataSource,      // ← Data SDK
    private val mapper: Mapper<UserDto, User>,          // ← Domain SDK contrato
) : ReadRepository<UserId, User> {                      // ← Domain SDK contrato

    override suspend fun findById(id: UserId): DomainResult<User?> {
        val networkResult = dataSource.getUser(id.value)  // NetworkResult<UserDto>
        return networkResult.fold(
            onSuccess = { dto -> mapper.map(dto).asSuccess() },   // UserDto → User
            onFailure = { error -> domainFailure(error.toDomainError()) }, // NetworkError → DomainError
        )
    }
}

class UserRepositoryWithMeta(
    private val dataSource: UserRemoteDataSource,
    private val mapper: Mapper<UserDto, User>,
) : ReadRepository<UserId, User> {

    // Retorna DomainResultWithMeta para que el ViewModel acceda a metadata
    suspend fun findByIdWithMeta(id: UserId): DomainResultWithMeta<User?> {
        val networkResult = dataSource.getUser(id.value)
        return when (networkResult) {
            is NetworkResult.Success -> DomainResultWithMeta(
                result = mapper.map(networkResult.data).asSuccess(),
                metadata = networkResult.metadata.toDomainMeta(),
            )
            is NetworkResult.Failure -> DomainResultWithMeta(
                result = domainFailure(networkResult.error.toDomainError()),
                // En failure también puedes propagar metadata si la tienes
            )
        }
    }

    // Contrato estándar (sin metadata) sigue disponible
    override suspend fun findById(id: UserId): DomainResult<User?> =
        findByIdWithMeta(id).result
}

// Extensión en tu capa de datos — convierte metadata HTTP → metadata de dominio
fun ResponseMetadata.toDomainMeta(): ResultMetadata = ResultMetadata(
    requestId = requestId,
    durationMs = durationMs,
    attemptCount = attemptCount,
    extra = buildMap {
        headers["X-RateLimit-Remaining"]?.firstOrNull()?.let { put("rateLimitRemaining", it) }
        headers["ETag"]?.firstOrNull()?.let { put("etag", it) }
    },
)

val (result, meta) = userRepo.findByIdWithMeta(userId)
result.fold(
    onSuccess = { user -> showUser(user) },
    onFailure = { error ->
        showError(error.message)
        // El usuario puede reportar el requestId al soporte
        analytics.logError(requestId = meta.requestId, duration = meta.durationMs)
    },
)

// ── Contrato en tu capa de dominio (interface del repository) ──
interface OrderRepository : WriteRepository<Order> {
    suspend fun placeOrder(order: Order, operationId: String): DomainResult<Unit>
}

// ── Implementación en tu capa de datos (puente) ──
class OrderRepositoryImpl(
    private val dataSource: OrderRemoteDataSource,
) : OrderRepository {

    override suspend fun placeOrder(order: Order, operationId: String): DomainResult<Unit> {
        val context = RequestContext(
            operationId = operationId,              // ← Viene del use case
            tags = mapOf("orderId" to order.id),    // ← Contexto de negocio
            requiresAuth = true,
        )
        val result = dataSource.createOrder(order.toDto(), context)
        return result.fold(
            onSuccess = { Unit.asSuccess() },
            onFailure = { error -> domainFailure(error.toDomainError()) },
        )
    }

    // save/delete estándar para WriteRepository
    override suspend fun save(entity: Order) = placeOrder(entity, "save-order")
    override suspend fun delete(entity: Order): DomainResult<Unit> { /* ... */ }
}

// ── Use case genera el operationId ──
class PlaceOrderUseCase(
    private val orderRepo: OrderRepository,
    private val deps: DomainDependencies,
) : SuspendUseCase<PlaceOrderInput, Unit> {

    override suspend fun invoke(input: PlaceOrderInput): DomainResult<Unit> {
        val order = Order(id = deps.idProvider.generate(), /* ... */)
        return orderRepo.placeOrder(order, operationId = "place-order")
    }
}

// Mismo OrderRepository, diferentes operationIds
class PlaceOrderUseCase(...)   { orderRepo.placeOrder(order, "place-order") }
class ReorderUseCase(...)      { orderRepo.placeOrder(order, "reorder") }
class AdminCreateOrder(...)    { orderRepo.placeOrder(order, "admin-create-order") }

// ── Contrato del repository (dominio) — habla lenguaje de negocio ──
interface PaymentRepository : Repository {
    suspend fun processPayment(payment: Payment, allowRetry: Boolean = false): DomainResult<PaymentResult>
}

// ── Implementación (puente) — traduce negocio → infraestructura ──
class PaymentRepositoryImpl(
    private val dataSource: PaymentRemoteDataSource,
) : PaymentRepository {

    override suspend fun processPayment(
        payment: Payment,
        allowRetry: Boolean,
    ): DomainResult<PaymentResult> {
        val context = RequestContext(
            operationId = "process-payment",
            retryPolicyOverride = if (!allowRetry) RetryPolicy.None else null,
            requiresAuth = true,
        )
        val result = dataSource.charge(payment.toDto(), context)
        return result.fold(
            onSuccess = { dto -> PaymentResult(dto.transactionId).asSuccess() },
            onFailure = { error -> domainFailure(error.toDomainError()) },
        )
    }
}

// ── Use case — decide la regla de negocio ──
class ProcessPaymentUseCase(
    private val paymentRepo: PaymentRepository,
) : SuspendUseCase<Payment, PaymentResult> {

    override suspend fun invoke(input: Payment): DomainResult<PaymentResult> =
        paymentRepo.processPayment(input, allowRetry = false) // ← NUNCA reintentar pagos
}

// ── Adapter: login ──
class LoginGateway(
    private val session: SessionController,
) : CommandGateway<SessionCredentials> {

    override suspend fun dispatch(input: SessionCredentials): DomainResult<Unit> =
        runDomainCatching { session.startSession(input) }
}

// ── Adapter: logout voluntario ──
// El usuario presiona "Cerrar sesión" — acción voluntaria
class LogoutGateway(
    private val session: SessionController,
) : CommandGateway<Unit> {

    override suspend fun dispatch(input: Unit): DomainResult<Unit> =
        runDomainCatching { session.endSession() }
}

// ── Adapter: force-logout ──
// Diferente de logout: esto se dispara automáticamente cuando:
// - El servidor retorna 401 (token inválido)
// - Se detecta seguridad comprometida
// - El admin revoca la sesión remotamente
class ForceLogoutGateway(
    private val session: SessionController,
) : CommandGateway<Unit> {

    override suspend fun dispatch(input: Unit): DomainResult<Unit> =
        runDomainCatching { session.invalidate() }
}

// ── Adapter: refresh de token ──
// RefreshOutcome es un sealed del Data SDK:
//   Refreshed  → token renovado exitosamente
//   NotNeeded  → token aún válido, no se necesitó renovar
//   Failed     → no se pudo renovar (credenciales expiradas)
class RefreshSessionGateway(
    private val session: SessionController,
) : SuspendGateway<Unit, RefreshOutcome> {

    override suspend fun execute(input: Unit): DomainResult<RefreshOutcome> =
        runDomainCatching { session.refreshSession() }
}

// ── Adapter: estado de sesión (StateFlow → FlowGateway) ──
// Convierte SessionState (Active/Idle/Expired) → Boolean (logged in / not)
class SessionStateGateway(
    private val session: SessionController,
) : NoParamsFlowGateway<Boolean> {

    override fun observe(): Flow<DomainResult<Boolean>> =
        session.state.map { state ->
            (state is SessionState.Active).asSuccess()
        }
}

// ── Adapter: eventos de sesión para analytics ──
// Cada evento (Started, Refreshed, Ended, etc.) se emite como DomainResult
class SessionEventsGateway(
    private val session: SessionController,
) : NoParamsFlowGateway<SessionEvent> {

    override fun observe(): Flow<DomainResult<SessionEvent>> =
        session.events.map { event -> event.asSuccess() }
}

// ── LogoutUseCase — encadena logout + limpiar caché ──
class LogoutUseCase(
    private val logout: LogoutGateway,
    private val clearCache: ClearCacheGateway, // otro gateway tuyo
) : SuspendUseCase<Unit, Unit> {

    override suspend fun invoke(input: Unit): DomainResult<Unit> =
        logout.dispatch(Unit).flatMap { clearCache.dispatch(Unit) }
}

// ── ObserveSessionUseCase — el ViewModel observa si hay sesión activa ──
class ObserveSessionUseCase(
    private val sessionState: SessionStateGateway,
) : NoParamsFlowUseCase<Boolean> {

    override fun invoke(): Flow<DomainResult<Boolean>> =
        sessionState.observe()
}

fun provideMultiApiDependencies(): AppDependencies {
    // ── Configuraciones por API ── cada una con reglas diferentes
    val ordersConfig = NetworkConfig(
        baseUrl = "https://orders.api.example.com",
        connectTimeout = 10_000L,
        retryPolicy = RetryPolicy.ExponentialBackoff(maxRetries = 3),
    )
    val inventoryConfig = NetworkConfig(
        baseUrl = "https://inventory.api.example.com",
        connectTimeout = 5_000L,
        retryPolicy = RetryPolicy.FixedDelay(maxRetries = 2, delay = 1_000L),
    )
    val paymentsConfig = NetworkConfig(
        baseUrl = "https://payments.api.example.com",
        connectTimeout = 30_000L,
        retryPolicy = RetryPolicy.None, // ← Pagos: NUNCA reintentar por defecto
    )

    // ── Executors independientes por API ──
    // Cada executor tiene su propio engine, config y observers
    val ordersExecutor = DefaultSafeRequestExecutor(
        engine = KtorHttpEngine.create(ordersConfig),
        config = ordersConfig,
        classifier = KtorErrorClassifier(),
        observers = listOf(loggingObserver, metricsObserver),
    )
    val inventoryExecutor = DefaultSafeRequestExecutor(
        engine = KtorHttpEngine.create(inventoryConfig),
        config = inventoryConfig,
        classifier = KtorErrorClassifier(),
    )
    val paymentsExecutor = DefaultSafeRequestExecutor(
        engine = KtorHttpEngine.create(paymentsConfig, bankTrustPolicy), // ← TrustPolicy (ver Gap 9)
        config = paymentsConfig,
        classifier = KtorErrorClassifier(),
    )

    // ── DataSources ── cada uno usa su executor correspondiente
    val orderDataSource = OrderRemoteDataSource(ordersExecutor)
    val inventoryDataSource = InventoryRemoteDataSource(inventoryExecutor)
    val paymentDataSource = PaymentRemoteDataSource(paymentsExecutor)

    // ── Repositories/Gateways (puente) ──
    val orderRepo = OrderRepositoryImpl(orderDataSource)
    val inventoryGateway = InventoryGatewayImpl(inventoryDataSource)
    val paymentRepo = PaymentRepositoryImpl(paymentDataSource)

    // ── Use case orquesta las 3 APIs ──
    val placeOrder = PlaceOrderUseCase(orderRepo, inventoryGateway, paymentRepo, domainDeps)

    return AppDependencies(placeOrder, /* ... */)
}

// ── Gateway reactivo (dominio) ──
interface RateLimitGateway : NoParamsFlowGateway<Int> // Remaining count

// ── Implementación (puente) — doble rol ──
class RateLimitGatewayImpl : RateLimitGateway, ResponseInterceptor {
    private val _remaining = MutableStateFlow(Int.MAX_VALUE)

    // Rol 1: ResponseInterceptor del Data SDK — intercepta cada respuesta HTTP
    override suspend fun intercept(response: InterceptedResponse): InterceptedResponse {
        response.headers["X-RateLimit-Remaining"]?.firstOrNull()?.toIntOrNull()?.let {
            _remaining.value = it
        }
        return response // Siempre retorna la respuesta sin modificar
    }

    // Rol 2: NoParamsFlowGateway del Domain SDK — expone al dominio
    override fun observe(): Flow<DomainResult<Int>> =
        _remaining.map { it.asSuccess() }
}

// 1. Crear la instancia
val rateLimitGateway = RateLimitGatewayImpl()

// 2. Registrar como ResponseInterceptor en el executor
val executor = DefaultSafeRequestExecutor(
    engine = engine,
    config = config,
    classifier = KtorErrorClassifier(),
    responseInterceptors = listOf(rateLimitGateway), // ← intercepta respuestas HTTP
)

// 3. Inyectar como Gateway en el use case
val checkRateLimit = ObserveRateLimitUseCase(rateLimitGateway) // ← expone al dominio

// ── TrustPolicy — se configura una vez en el wiring ──
val bankTrustPolicy = DefaultTrustPolicy(
    pins = listOf(
        CertificatePin(
            hostname = "payments.api.example.com",
            sha256 = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", // SHA-256 del cert actual
        ),
        CertificatePin(
            hostname = "payments.api.example.com",
            sha256 = "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB=", // Pin de respaldo
            // Necesitas 2+ pins para que la app siga funcionando durante rotación de cert
        ),
    ),
)

// ── Pasar al crear el engine ──
val secureEngine = KtorHttpEngine.create(
    config = paymentsConfig,
    trustPolicy = bankTrustPolicy,    // ← Pinning activo
)
val secureExecutor = DefaultSafeRequestExecutor(
    engine = secureEngine,
    config = paymentsConfig,
    classifier = KtorErrorClassifier(),
)

// ── LoggingObserver (Data SDK) — solo en debug ──
// Imprime logs detallados de cada request. El headerSanitizer evita
// loguear tokens de Authorization en texto plano.
val loggingObserver = LoggingObserver(
    logger = { tag, msg -> println("[$tag] $msg") },
    tag = "HTTP",
    headerSanitizer = { key, value ->
        if (key.equals("Authorization", ignoreCase = true)) "***" else value
    },
)

// ── Observer custom: reporte a Crashlytics ──
// Solo reporta errores relevantes — no loguea requests exitosos.
val crashlyticsObserver = object : NetworkEventObserver {
    override fun onRequestStarted(url: String, method: String) {
        // No-op: no reportamos requests exitosos a Crashlytics
    }
    override fun onResponseReceived(url: String, statusCode: Int, durationMs: Long) {
        // Solo reportamos errores de servidor (5xx)
        if (statusCode >= 500) {
            crashlytics.log("Server error: $url → $statusCode (${durationMs}ms)")
        }
    }
    override fun onRetryScheduled(url: String, attempt: Int, delayMs: Long) {
        // Útil para detectar APIs inestables
        crashlytics.log("Retry #$attempt for $url in ${delayMs}ms")
    }
    override fun onRequestFailed(url: String, error: NetworkError) {
        // Reporta la excepción original (Throwable), no el NetworkError
        crashlytics.recordError(error.diagnostic?.cause ?: Exception(error.message))
    }
}

val executor = DefaultSafeRequestExecutor(
    engine = KtorHttpEngine.create(config),
    config = config,
    classifier = KtorErrorClassifier(),
    observers = listOf(loggingObserver, crashlyticsObserver), // ← ambos activos
)

// Extensión en tu capa de datos (NO en ninguno de los SDKs)
fun WebSocketError.toDomainError(): DomainError = when (this) {
    // ── Conexión ──
    is WebSocketError.ConnectionFailed -> DomainError.Infrastructure(
        detail = "No se pudo conectar al servidor",
        cause = diagnostic?.cause,
    )
    is WebSocketError.ConnectionLost -> DomainError.Infrastructure(
        detail = "Conexión perdida",
        cause = diagnostic?.cause,
    )
    is WebSocketError.Timeout -> DomainError.Infrastructure(
        detail = "Timeout al conectar",
        cause = diagnostic?.cause,
    )

    // ── Protocolo ──
    is WebSocketError.ProtocolError -> DomainError.Infrastructure(
        detail = "Error de protocolo: $message",
        cause = diagnostic?.cause,
    )
    is WebSocketError.ClosedByServer -> DomainError.Infrastructure(
        detail = "Servidor cerró la conexión (código: $code)",
        cause = diagnostic?.cause,
    )

    // ── Seguridad ──
    is WebSocketError.Authentication -> DomainError.Unauthorized(
        detail = "Autenticación requerida para WebSocket",
    )

    // ── Procesamiento ──
    is WebSocketError.Serialization -> DomainError.Infrastructure(
        detail = "Error al procesar mensaje del stream",
        cause = diagnostic?.cause,
    )

    // ── Catch-all ──
    is WebSocketError.Unknown -> DomainError.Unknown(
        detail = message,
        cause = diagnostic?.cause,
    )
}

fun SecurityError.toDomainError(): DomainError = when (this) {
    is SecurityError.TokenExpired -> DomainError.Unauthorized(
        detail = "Sesión expirada",
    )
    is SecurityError.TokenRefreshFailed -> DomainError.Unauthorized(
        detail = "No se pudo renovar la sesión",
    )
    is SecurityError.InvalidCredentials -> DomainError.Unauthorized(
        detail = "Credenciales inválidas",
    )
    is SecurityError.SecureStorageFailure -> DomainError.Infrastructure(
        detail = "Error de almacenamiento seguro",
        cause = diagnostic?.cause,
    )
    is SecurityError.CertificatePinningFailure -> DomainError.Infrastructure(
        detail = "Certificado no confiable para $host",
        cause = diagnostic?.cause,
    )
    is SecurityError.Unknown -> DomainError.Unknown(
        detail = message,
        cause = diagnostic?.cause,
    )
}

class LoginGateway(
    private val session: SessionController,
) : CommandGateway<SessionCredentials> {

    override suspend fun dispatch(input: SessionCredentials): DomainResult<Unit> =
        runDomainCatching(
            errorMapper = { throwable ->
                // Si el Data SDK lanza SecurityError como excepción
                (throwable as? SecurityError)?.toDomainError()
                    ?: DomainError.Unknown(cause = throwable)
            }
        ) {
            session.startSession(input)
        }
}

class DomainStreamingConnectionAdapter<Dto, T>(
    private val wsConnection: WebSocketConnection,
    private val deserialize: (WebSocketFrame) -> Dto?,
    private val mapper: Mapper<Dto, T>,
    private val errorMapper: (WebSocketError) -> DomainError = { it.toDomainError() },
) : StreamingConnection<T> {

    // Mapea WebSocketState → ConnectionState
    override val state: StateFlow<ConnectionState> =
        wsConnection.state.map { wsState ->
            when (wsState) {
                is WebSocketState.Connecting -> ConnectionState.Connecting(wsState.attempt)
                is WebSocketState.Connected -> ConnectionState.Connected
                is WebSocketState.Disconnected -> ConnectionState.Disconnected(
                    error = wsState.error?.let(errorMapper),
                )
            }
        }.stateIn(/* scope */)

    // Mapea WebSocketFrame → DomainResult<T>
    override val incoming: Flow<DomainResult<T>> =
        wsConnection.incoming.mapNotNull { frame ->
            try {
                val dto = deserialize(frame) ?: return@mapNotNull null
                mapper.map(dto).asSuccess()
            } catch (e: Exception) {
                domainFailure(DomainError.Infrastructure("Error deserializando frame", e))
            }
        }

    override suspend fun close() {
        wsConnection.close()
    }
}

// ── Contrato en el dominio ──
interface PriceStreamGateway : StreamingGateway<String, PriceTick>

// ── Implementación en la capa de datos ──
class PriceStreamGatewayImpl(
    private val dataSource: PriceStreamDataSource,
    private val mapper: Mapper<PriceTickDto, PriceTick>,
) : PriceStreamGateway {

    override fun connect(input: String): StreamingConnection<PriceTick> =
        DomainStreamingConnectionAdapter(
            wsConnection = dataSource.connect(input),
            deserialize = { frame ->
                when (frame) {
                    is WebSocketFrame.Text -> Json.decodeFromString(frame.text)
                    else -> null
                }
            },
            mapper = mapper,
        )
}

class PriceViewModel(
    private val priceStream: PriceStreamGateway,
) : ViewModel() {

    private var connection: StreamingConnection<PriceTick>? = null

    fun startObserving(symbol: String) {
        connection = priceStream.connect(symbol)

        // Observar estado de conexión
        viewModelScope.launch {
            connection!!.state.collect { state ->
                when (state) {
                    is ConnectionState.Connecting -> _uiState.value = UiState.Reconnecting(state.attempt)
                    is ConnectionState.Connected -> _uiState.value = UiState.Connected
                    is ConnectionState.Disconnected -> _uiState.value = UiState.Disconnected(state.error?.message)
                }
            }
        }

        // Observar precios
        viewModelScope.launch {
            connection!!.incoming.collect { result ->
                result.fold(
                    onSuccess = { tick -> _price.value = tick },
                    onFailure = { error -> _lastError.value = error.message },
                )
            }
        }
    }

    override fun onCleared() {
        viewModelScope.launch { connection?.close() }
    }
}

// ── Contrato en el dominio ──
interface ChatGateway : BidirectionalStreamingGateway<String, ChatMessage, ChatMessage>

// ── Uso en el ViewModel ──
val chatConnection = chatGateway.connect("room-42")

// Recibir mensajes
chatConnection.incoming.collect { result ->
    result.onSuccess { msg -> addToChat(msg) }
}

// Enviar mensajes
chatConnection.send(ChatMessage(text = "Hola!")).onFailure { error ->
    showError("No se pudo enviar: ${error.message}")
}

// settings.gradle.kts
include(":coredomainplatform")
project(":coredomainplatform").projectDir = file("ruta/a/coredomainplatform")

// build.gradle.kts de tu módulo app/feature
kotlin {
    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation(project(":coredomainplatform"))
            }
        }
    }
}

// En el paquete de dominio de tu feature (NO en este SDK)
package com.myapp.feature.task.model

import com.domain.core.model.AggregateRoot
import com.domain.core.model.EntityId

@JvmInline
value class TaskId(override val value: String) : EntityId<String>

data class Task(
    override val id: TaskId,
    val title: String,
    val completed: Boolean,
    val createdAt: Long,
) : AggregateRoot<TaskId>

package com.myapp.feature.task.repository

import com.domain.core.repository.ReadRepository
import com.domain.core.repository.WriteRepository
import com.myapp.feature.task.model.Task
import com.myapp.feature.task.model.TaskId

interface TaskRepository : ReadRepository<TaskId, Task>, WriteRepository<Task>

package com.myapp.feature.task.validation

import com.domain.core.validation.notBlankValidator
import com.domain.core.validation.maxLengthValidator
import com.domain.core.validation.andThen

val taskTitleValidator = notBlankValidator("title")
    .andThen(maxLengthValidator("title", 200))

package com.myapp.feature.task.policy

import com.domain.core.error.DomainError
import com.domain.core.policy.DomainPolicy
import com.domain.core.result.asSuccess
import com.domain.core.result.domainFailure
import com.myapp.feature.task.model.Task

val canCompleteTask = DomainPolicy<Task> { task ->
    if (task.title.isNotBlank()) Unit.asSuccess()
    else domainFailure(DomainError.Conflict(detail = "No se puede completar una tarea sin título"))
}

package com.myapp.feature.task.usecase

import com.domain.core.di.DomainDependencies
import com.domain.core.error.DomainError
import com.domain.core.result.DomainResult
import com.domain.core.result.asSuccess
import com.domain.core.result.domainFailure
import com.domain.core.result.flatMap
import com.domain.core.usecase.SuspendUseCase
import com.myapp.feature.task.model.Task
import com.myapp.feature.task.model.TaskId
import com.myapp.feature.task.repository.TaskRepository
import com.myapp.feature.task.validation.taskTitleValidator

data class CreateTaskParams(val title: String)

class CreateTaskUseCase(
    private val deps: DomainDependencies,
    private val repository: TaskRepository,
) : SuspendUseCase<CreateTaskParams, Task> {

    override suspend fun invoke(params: CreateTaskParams): DomainResult<Task> {
        // 1. Validar
        val validation = taskTitleValidator.validate(params.title)
        if (validation.isFailure) return validation as DomainResult<Task>

        // 2. Construir entidad
        val task = Task(
            id = TaskId(deps.idProvider.next()),
            title = params.title,
            completed = false,
            createdAt = deps.clock.nowMillis(),
        )

        // 3. Persistir y retornar
        return repository.save(task).flatMap { task.asSuccess() }
    }
}

package com.myapp.feature.task.di

import com.domain.core.di.DomainDependencies
import com.domain.core.di.DomainModule
import com.domain.core.usecase.SuspendUseCase
import com.myapp.feature.task.model.Task
import com.myapp.feature.task.repository.TaskRepository
import com.myapp.feature.task.usecase.CreateTaskParams
import com.myapp.feature.task.usecase.CreateTaskUseCase

interface TaskDomainModule : DomainModule {
    val createTask: SuspendUseCase<CreateTaskParams, Task>
}

class TaskDomainModuleImpl(
    deps: DomainDependencies,
    taskRepository: TaskRepository,
) : TaskDomainModule {
    override val createTask = CreateTaskUseCase(deps, taskRepository)
}

// Capa de app — wiring. Este es el ÚNICO lugar donde los tipos concretos se encuentran.
val domainDeps = DomainDependencies(
    clock = ClockProvider { System.currentTimeMillis() },
    idProvider = IdProvider { UUID.randomUUID().toString() },
)

val taskRepository: TaskRepository = TaskRepositoryImpl(database.taskDao())

val taskModule: TaskDomainModule = TaskDomainModuleImpl(
    deps = domainDeps,
    taskRepository = taskRepository,
)

class CreateTaskUseCaseTest {

    private val testDeps = DomainDependencies(
        clock = ClockProvider { 1_700_000_000_000L },
        idProvider = IdProvider { "task-001" },
    )

    private val fakeRepo = object : TaskRepository {
        override suspend fun findById(id: TaskId) = null.asSuccess()
        override suspend fun save(entity: Task) = Unit.asSuccess()
        override suspend fun delete(entity: Task) = Unit.asSuccess()
    }

    private val useCase = CreateTaskUseCase(testDeps, fakeRepo)

    @Test
    fun `crea tarea con id y timestamp inyectados`() = runTest {
        val result = useCase(CreateTaskParams("Comprar víveres"))
        val task = result.shouldBeSuccess()

        assertEquals("task-001", task.id.value)
        assertEquals(1_700_000_000_000L, task.createdAt)
        assertEquals("Comprar víveres", task.title)
        assertFalse(task.completed)
    }

    @Test
    fun `rechaza título vacío`() = runTest {
        val result = useCase(CreateTaskParams("   "))
        result.shouldFailWith<DomainError.Validation>()
    }
}