public sealed interface QueryBuilder permits SelectBuilder, WhereBuilder, OrderBuilder, ExecutableQuery {
    static SelectBuilder select(String... columns) {
        return new FluentQueryBuilder(columns);
    }
}

public sealed interface SelectBuilder extends QueryBuilder permits FluentQueryBuilder {
    WhereBuilder from(String table);
}

public sealed interface WhereBuilder extends QueryBuilder permits FluentQueryBuilder {
    WhereBuilder where(String condition);
    WhereBuilder and(String condition);
    WhereBuilder or(String condition);
    OrderBuilder orderBy(String column);
    ExecutableQuery build();
}

public sealed interface OrderBuilder extends QueryBuilder permits FluentQueryBuilder {
    OrderBuilder thenBy(String column);
    OrderBuilder descending();
    ExecutableQuery build();
}

public sealed interface ExecutableQuery extends QueryBuilder permits FluentQueryBuilder {
    String toSql();
    <T> List<T> execute(Class<T> resultType);
}

final class FluentQueryBuilder implements SelectBuilder, WhereBuilder, OrderBuilder, ExecutableQuery {
    // Implementa funcionalidad
}

// Uso del API fluida
final var query = QueryBuilder.select("id", "name", "email")
    .from("users")
    .where("age > 18")
    .and("status = 'ACTIVE'")
    .orderBy("name")
    .descending()
    .build();

IO.println(query.toSql());
// Output: SELECT id, name, email FROM users WHERE age > 18 AND status = 'ACTIVE' ORDER BY name DESC

public final class ConnectionPool {

    private static final Queue<Connection> pool = new ConcurrentLinkedQueue<>();
    private static final int MAX_CONNECTIONS = 10;

    static {
        // Inicializar pool con conexiones
        for (int i = 0; i < MAX_CONNECTIONS; i++) {
            pool.offer(createConnection());
        }
    }

    private ConnectionPool() {} // No instanciable

    // Método estático que implementa el Loan Pattern
    public static <T> T withConnection(Function<Connection, T> operation) {
        Connection conn = null;
        try {
            conn = acquireConnection();
            return operation.apply(conn);
        } catch (DatabaseException e) {
            throw new RuntimeException("Error executing database operation", e);
        } finally {
            if (conn != null) {
                releaseConnection(conn);
            }
        }
    }

    // Versión para operaciones sin retorno
    public static void withConnection(Consumer<Connection> operation) {
        withConnection(conn -> {
            operation.accept(conn);
            return null;
        });
    }

    // Versión con transacción automática
    public static <T> T withTransaction(Function<Connection, T> operation) {
        return withConnection(conn -> {
            try {
                conn.setAutoCommit(false);
                T result = operation.apply(conn);
                conn.commit();
                return result;
            } catch (Exception e) {
                conn.rollback();
                throw new DatabaseException("Transaction failed", e);
            } finally {
                conn.setAutoCommit(true);
            }
        });
    }

    private static Connection acquireConnection() {
        Connection conn = pool.poll();
        if (conn == null) {
            throw new IllegalStateException("No available connections in pool");
        }
        return conn;
    }

    private static void releaseConnection(Connection conn) {
        pool.offer(conn);
    }

    private static Connection createConnection() {
        // Crear conexión real a la base de datos
        return new Connection();
    }
}

// Uso del Loan Pattern - el cliente nunca gestiona el ciclo de vida
record User(long id, String name, String email) {}

// Operación simple
final List<User> users = ConnectionPool.withConnection(conn ->
    conn.query("SELECT * FROM users WHERE active = true")
       .stream()
       .map(row -> new User(row.getLong("id"), row.getString("name"), row.getString("email")))
       .toList());

// Operación transaccional
ConnectionPool.withTransaction(conn -> {
    conn.execute("UPDATE accounts SET balance = balance - 100 WHERE id = ?", sourceId);
    conn.execute("UPDATE accounts SET balance = balance + 100 WHERE id = ?", targetId);
    conn.execute("INSERT INTO transfers (source, target, amount) VALUES (?, ?, ?)",
                 sourceId, targetId, 100);
    return null;
});

// INCORRECTO: Una clase que responde a múltiples actores
public class Employee {
    public double calculatePay() { /* Lógica de Contabilidad */ }
    public void saveToDatabase() { /* Lógica de TI */ }
    public String generateReport() { /* Lógica de Recursos Humanos */ }
}

// CORRECTO: Cada clase responde a un solo actor
// Aquí se compartó la entidad, pero una implementación más robusta puede tener una entidad por dominio
public record Employee(long id, String name, String department, double hourlyRate) {}

// Responde al departamento de Contabilidad
public interface PayrollCalculator {
    double calculatePay(Employee employee, int hoursWorked);
}

// Responde al departamento de TI
public interface EmployeeRepository {
    void save(Employee employee);
    Optional<Employee> findById(long id);
}

// Responde a Recursos Humanos
public interface EmployeeReportGenerator {
    String generatePerformanceReport(Employee employee);
}

// Abstracción que permite extensión
public interface DiscountStrategy {

    double apply(double originalPrice);
}

public record NoDiscount() implements DiscountStrategy {
    @Override
    public double apply(double originalPrice) {
        return originalPrice;
    }
}

public record PercentageDiscount(double percentage) implements DiscountStrategy {
    public PercentageDiscount {
        if (percentage < 0 || percentage > 100) {
            throw new IllegalArgumentException("Porcentaje debe estar entre 0 y 100");
        }
    }

    @Override
    public double apply(double originalPrice) {
        return originalPrice * (1 - percentage / 100);
    }
}

public record FixedAmountDiscount(double amount) implements DiscountStrategy {
    @Override
    public double apply(double originalPrice) {
        return Math.max(0, originalPrice - amount);
    }
}

public record SeasonalDiscount(String season, double percentage) implements DiscountStrategy {
    @Override
    public double apply(double originalPrice) {
        return originalPrice * (1 - percentage / 100);
    }
}

// La clase Order está CERRADA para modificación
public class OrderProcessor {

    public double calculateTotal(List<LineItem> items, DiscountStrategy discount) {
        final double subtotal = items.stream()
            .mapToDouble(item -> item.price() * item.quantity())
            .sum();

        return discount.apply(subtotal);
    }
}

// Para agregar un nuevo tipo de descuento, NO necesitamos modificar OrderProcessor
// Simplemente creamos una nueva implementación de DiscountStrategy

// INCORRECTO: Violación del LSP
public class Bird {
    public void fly() { IO.println("Volando..."); }
}

public class Penguin extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Los pingüinos no vuelan");
    }
}

// CORRECTO: Jerarquía que respeta LSP usando interfaces segregadas
public sealed interface Bird permits FlyingBird, FlightlessBird {
    String name();
    void eat();
}

public interface FlyingBird extends Bird {
    void fly();
    default int maxAltitude() { return 1000; }
}

public interface FlightlessBird extends Bird {
    void walk();
}

public record Eagle(String name) implements FlyingBird {
    @Override
    public void eat() { IO.println("Cazando presas"); }
    @Override
    public void fly() { IO.println("Volando alto"); }
    @Override
    public int maxAltitude() { return 3000; }
}

public record Penguin(String name) implements FlightlessBird {
    @Override
    public void eat() { IO.println("Comiendo peces"); }
    @Override
    public void walk() { IO.println("Caminando en el hielo"); }
}

// Ahora podemos usar cualquier FlyingBird donde se espere uno
public class BirdSanctuary {
    public void releaseBird(FlyingBird bird) {
        bird.fly(); // Garantizado que funciona para cualquier FlyingBird
    }
}

// INCORRECTO: Interfaz "gorda" que obliga a implementar métodos innecesarios
public interface Worker {
    void work();
    void eat();
    void attendMeeting();
    void writeCode();
    void reviewCode();
}

// CORRECTO: Interfaces segregadas por responsabilidad
public interface Workable {
    void work();
}

public interface Eatable {
    void eat();
}

public interface MeetingAttendee {
    void attendMeeting();
}

public interface Developer extends Workable {
    void writeCode();
    void reviewCode();
}

// Cada clase implementa solo lo que necesita
public class SoftwareEngineer implements Developer, Eatable, MeetingAttendee {
    @Override
    public void work() { writeCode(); }
    @Override
    public void eat() { IO.println("Almorzando"); }
    @Override
    public void attendMeeting() { IO.println("En daily standup"); }
    @Override
    public void writeCode() { IO.println("Programando"); }
    @Override
    public void reviewCode() { IO.println("Revisando PR"); }
}

public class Robot implements Workable {
    @Override
    public void work() { IO.println("Ejecutando tarea automatizada"); }
    // No necesita eat(), attendMeeting(), etc.
}

public class Manager implements Workable, Eatable, MeetingAttendee {
    @Override
    public void work() { attendMeeting(); }
    @Override
    public void eat() { IO.println("Almuerzo de negocios"); }
    @Override
    public void attendMeeting() { IO.println("Liderando reunión"); }
    // No necesita writeCode() ni reviewCode()
}

// Abstracciones (interfaces estables)
public interface MessageSender {
    void send(String recipient, String message);
}

public interface UserRepository {
    Optional<User> findById(long id);
    void save(User user);
}

// Implementaciones concretas (detalles volátiles)
@RequiredArgsConstructor
public class EmailSender implements MessageSender {
    private final SmtpClient smtpClient;

    @Override
    public void send(String recipient, String message) {
        smtpClient.sendEmail(recipient, "Notificación", message);
    }
}

@RequiredArgsConstructor
public class SmsSender implements MessageSender {
    private final TwilioClient twilioClient;

    @Override
    public void send(String recipient, String message) {
        twilioClient.sendSms(recipient, message);
    }
}

@RequiredArgsConstructor
public class JpaUserRepository implements UserRepository {
    private final EntityManager entityManager;

    @Override
    public Optional<User> findById(long id) {
        return Optional.ofNullable(entityManager.find(User.class, id));
    }

    @Override
    public void save(User user) {
        entityManager.persist(user);
    }
}

// Módulo de alto nivel - depende SOLO de abstracciones
// Inyección de dependencias via constructor
@RequiredArgsConstructor
public class NotificationService {
    private final MessageSender messageSender;
    private final UserRepository userRepository;

    public void notifyUser(long userId, String message) {
        userRepository.findById(userId)
            .ifPresentOrElse(
                user -> messageSender.send(user.contactInfo(), message),
                () -> { throw new UserNotFoundException(userId); }
            );
    }
}

// Configuración - aquí se resuelven las dependencias concretas
public class ApplicationConfig {
    public NotificationService provideNotificationService() {
        final var smtpClient = new SmtpClient("smtp.example.com", 587);
        final var entityManager = createEntityManager();

        return new NotificationService(
            new EmailSender(smtpClient),
            new JpaUserRepository(entityManager)
        );
    }
}

// Productos abstractos
public interface Button {
    void render();
    void onClick(Runnable action);
}

public sealed interface TextField permits WindowsTextField, MacTextField {
    void render();
    String getValue();
    void setValue(String value);
}

public sealed interface Dialog permits WindowsDialog, MacDialog {
    void show(String title, String message);
    boolean confirm(String title, String message);
}

// Fábrica abstracta
public sealed interface UIFactory permits WindowsUIFactory, MacUIFactory {

    Button createButton(String label);
    TextField createTextField(String placeholder);
    Dialog createDialog();

    // Factory method para obtener la fábrica correcta según el SO
    static UIFactory forCurrentPlatform() {
        String os = System.getProperty("os.name").toLowerCase();
        return switch (os) {
            case String s when s.contains("win") -> new WindowsUIFactory();
            case String s when s.contains("mac") -> new MacUIFactory();
        };
    }
}

// Implementaciones Windows
public final class WindowsUIFactory implements UIFactory {
    @Override
    public Button createButton(String label) {
        return new WindowsButton(label);
    }

    @Override
    public TextField createTextField(String placeholder) {
        return new WindowsTextField(placeholder);
    }

    @Override
    public Dialog createDialog() {
        return new WindowsDialog();
    }
}

// Implementaciones Mac (similares, con estilo diferente)
public final class MacUIFactory implements UIFactory {
    @Override
    public Button createButton(String label) {
        return new MacButton(label);
    }

    @Override
    public TextField createTextField(String placeholder) {
        return new MacTextField(placeholder);
    }

    @Override
    public Dialog createDialog() {
        return new MacDialog();
    }
}

// ... implementaciones Mac concretas ...

// Cliente - trabaja solo con abstracciones
public class LoginForm {
    private final Button loginButton;
    private final Button cancelButton;
    private final TextField usernameField;
    private final TextField passwordField;
    private final Dialog errorDialog;

    public LoginForm(UIFactory factory) {
        this.usernameField = factory.createTextField("Usuario");
        this.passwordField = factory.createTextField("Contraseña");
        this.loginButton = factory.createButton("Iniciar Sesión");
        this.cancelButton = factory.createButton("Cancelar");
        this.errorDialog = factory.createDialog();
    }

    public void render() {
        usernameField.render();
        passwordField.render();
        loginButton.render();
        cancelButton.render();
    }

    public void login() {
        loginButton.onClick(() -> {
            if (authenticate(usernameField.getValue(), passwordField.getValue())) {
                IO.println("Login exitoso");
            } else {
                errorDialog.show("Error", "Credenciales inválidas");
            }
        });
    }

    private boolean authenticate(String user, String pass) {
        return user != null && pass != null && !user.isEmpty();
    }
}

// Uso
final var factory = UIFactory.forCurrentPlatform();
final var loginForm = new LoginForm(factory);
loginForm.render();

public record HttpRequest(
    String method,
    String url,
    Map<String, String> headers,
    Map<String, String> queryParams,
    byte[] body,
    Duration timeout,
    boolean followRedirects
) {
    // Constructor compacto para validación
    public HttpRequest {
        Objects.requireNonNull(method, "HTTP method is required");
        Objects.requireNonNull(url, "URL is required");
        headers = headers != null ? Map.copyOf(headers) : Map.of();
        queryParams = queryParams != null ? Map.copyOf(queryParams) : Map.of();
        body = body != null ? body.clone() : new byte[0];
        timeout = timeout != null ? timeout : Duration.ofSeconds(30);
    }

    public static Builder get(String url) {
        return new Builder("GET", url);
    }

    public static Builder post(String url) {
        return new Builder("POST", url);
    }

    public static Builder put(String url) {
        return new Builder("PUT", url);
    }

    public static Builder delete(String url) {
        return new Builder("DELETE", url);
    }

    public static final class Builder {
        private final String method;
        private final String url;
        private final Map<String, String> headers = new LinkedHashMap<>();
        private final Map<String, String> queryParams = new LinkedHashMap<>();
        private byte[] body;
        private Duration timeout;
        private boolean followRedirects = true;

        private Builder(String method, String url) {
            this.method = method;
            this.url = url;
        }

        public Builder header(String name, String value) {
            headers.put(name, value);
            return this;
        }

        public Builder contentType(String contentType) {
            return header("Content-Type", contentType);
        }

        public Builder accept(String mediaType) {
            return header("Accept", mediaType);
        }

        public Builder authorization(String token) {
            return header("Authorization", "Bearer " + token);
        }

        public Builder queryParam(String name, String value) {
            queryParams.put(name, value);
            return this;
        }

        public Builder body(byte[] body) {
            this.body = body;
            return this;
        }

        public Builder body(String body) {
            return body(body.getBytes(StandardCharsets.UTF_8));
        }

        public Builder jsonBody(Object obj) {
            // Asumiendo un ObjectMapper disponible
            try {
                return contentType("application/json")
                    .body(new ObjectMapper().writeValueAsBytes(obj));
            } catch (JsonProcessingException e) {
                throw new IllegalArgumentException("Cannot serialize to JSON", e);
            }
        }

        public Builder timeout(Duration timeout) {
            this.timeout = timeout;
            return this;
        }

        public Builder noFollowRedirects() {
            this.followRedirects = false;
            return this;
        }

        public HttpRequest build() {
            return new HttpRequest(method, url, headers, queryParams, body, timeout, followRedirects);
        }

        // Método conveniente para ejecutar directamente
        public HttpResponse execute() {
            return HttpClient.send(build());
        }
    }
}

// Uso del Builder
final var request = HttpRequest.post("https://api.example.com/users")
    .contentType("application/json")
    .accept("application/json")
    .authorization("eyJhbGciOiJIUzI1NiIs...")
    .queryParam("version", "v2")
    .jsonBody(new CreateUserDto("John", "john@example.com"))
    .timeout(Duration.ofSeconds(10))
    .build();

// O ejecutar directamente
final var response = HttpRequest.get("https://api.example.com/users")
    .queryParam("page", "1")
    .queryParam("limit", "20")
    .execute();

public interface Notification {
    void send(String recipient, String message);
    String getType();
}

public record EmailNotification(String smtpServer) implements Notification {
    @Override
    public void send(String recipient, String message) {
        IO.println("📧 Enviando email a " + recipient + ": " + message);
        // Lógica de envío SMTP
    }

    @Override
    public String getType() { return "EMAIL"; }
}

public record SmsNotification(String apiKey) implements Notification {
    @Override
    public void send(String recipient, String message) {
        IO.println("📱 Enviando SMS a " + recipient + ": " + message);
        // Lógica de envío SMS via API
    }

    @Override
    public String getType() { return "SMS"; }
}

public record PushNotification(String firebaseToken) implements Notification {
    @Override
    public void send(String recipient, String message) {
        IO.println("🔔 Enviando push a " + recipient + ": " + message);
        // Lógica de notificación push
    }

    @Override
    public String getType() { return "PUSH"; }
}

// Clase abstracta con Factory Method
public abstract class NotificationService {

    // Factory Method - las subclases deciden qué crear
    protected abstract Notification createNotification();

    // Template method que usa el factory method
    public final void notifyUser(User user, String message) {
        Notification notification = createNotification();

        // Lógica común: logging, validación, etc.
        IO.println("Preparando notificación tipo: " + notification.getType());

        if (user.hasOptedIn(notification.getType())) {
            notification.send(user.getContact(notification.getType()), message);
            logNotification(user, notification.getType(), message);
        } else {
            IO.println("Usuario no ha aceptado " + notification.getType());
        }
    }

    private void logNotification(User user, String type, String message) {
        IO.println("LOG: Notificación " + type + " enviada a " + user.name());
    }
}

// Implementaciones concretas del Factory Method
@RequiredArgsConstructor
public class EmailNotificationService extends NotificationService {
    private final String smtpServer;

    @Override
    protected Notification createNotification() {
        return new EmailNotification(smtpServer);
    }
}

@RequiredArgsConstructor
public class SmsNotificationService extends NotificationService {
    private final String apiKey;

    @Override
    protected Notification createNotification() {
        return new SmsNotification(apiKey);
    }
}

@RequiredArgsConstructor
public class PushNotificationService extends NotificationService {
    private final String firebaseToken;

    @Override
    protected Notification createNotification() {
        return new PushNotification(firebaseToken);
    }
}

// Uso con polimorfismo
public class NotificationManager {
    private final Map<String, NotificationService> services;

    public NotificationManager() {
        this.services = Map.of(
            "EMAIL", new EmailNotificationService("smtp.example.com"),
            "SMS", new SmsNotificationService("twilio-api-key"),
            "PUSH", new PushNotificationService("firebase-token")
        );
    }

    public void broadcast(User user, String message) {
        services.values().forEach(service -> service.notifyUser(user, message));
    }

    public void notify(User user, String message, String preferredChannel) {
        services.getOrDefault(preferredChannel, services.get("EMAIL"))
                .notifyUser(user, message);
    }
}

// Clase base para documentos
class DocumentTemplate {
  constructor(title, content, author) {
    this.title = title;
    this.content = content;
    this.author = author;
    this.createdAt = new Date();
  }

  clone() {
    return new DocumentTemplate(
      this.title,
      this.content,
      this.author
    );
  }

  display() {
    console.log(`Título: ${this.title}`);
    console.log(`Autor: ${this.author}`);
    console.log(`Contenido: ${this.content}`);
  }
}

// Usando Proxy para crear un sistema de prototipos dinámico
class PrototypeRegistry {
  constructor() {
    this.prototypes = new Map();
  }

  register(name, prototype) {
    this.prototypes.set(name, prototype);
  }

  create(name, overrides = {}) {
    const prototype = this.prototypes.get(name);
    if (!prototype) {
      throw new Error(`Prototipo "${name}" no encontrado`);
    }

    // Crear un proxy que permite clonar y personalizar el prototipo
    const cloned = prototype.clone();

    // Proxy para interceptar y personalizar propiedades
    return new Proxy(cloned, {
      get(target, prop) {
        // Si la propiedad está en overrides, devolverla
        if (prop in overrides) {
          return overrides[prop];
        }
        // De lo contrario, devolver la propiedad del objeto clonado
        return target[prop];
      },

      set(target, prop, value) {
        // Permitir modificar propiedades
        target[prop] = value;
        return true;
      },

      has(target, prop) {
        // Verificar si la propiedad existe en overrides o en el target
        return prop in overrides || prop in target;
      },

      ownKeys(target) {
        // Combinar las claves del target y de overrides
        const targetKeys = Reflect.ownKeys(target);
        const overrideKeys = Object.keys(overrides);
        return [...new Set([...targetKeys, ...overrideKeys])];
      },

      getOwnPropertyDescriptor(target, prop) {
        if (prop in overrides) {
          return {
            enumerable: true,
            configurable: true,
            value: overrides[prop]
          };
        }
        return Reflect.getOwnPropertyDescriptor(target, prop);
      }
    });
  }
}

// Uso del sistema de prototipos con Proxy
const registry = new PrototypeRegistry();

// Registrar prototipos base
const blogPostTemplate = new DocumentTemplate(
  "Título del Post",
  "Contenido por defecto...",
  "Autor Anónimo"
);

const reportTemplate = new DocumentTemplate(
  "Reporte",
  "Este es un reporte estándar.",
  "Sistema"
);

registry.register("blog-post", blogPostTemplate);
registry.register("report", reportTemplate);

// Crear instancias personalizadas usando el proxy
const post1 = registry.create("blog-post", {
  title: "Introducción a Design Patterns",
  content: "Los patrones de diseño son soluciones reutilizables...",
  author: "Juan Pérez"
});

const post2 = registry.create("blog-post", {
  title: "JavaScript Avanzado",
  content: "JavaScript ofrece características poderosas...",
  author: "María García"
});

const report1 = registry.create("report", {
  title: "Reporte Mensual",
  content: "Resumen de actividades del mes..."
});

// Los objetos proxyados mantienen las propiedades del prototipo
// pero pueden ser personalizados
post1.display();
// Título: Introducción a Design Patterns
// Autor: Juan Pérez
// Contenido: Los patrones de diseño son soluciones reutilizables...

post2.display();
// Título: JavaScript Avanzado
// Autor: María García
// Contenido: JavaScript ofrece características poderosas...

// El proxy permite acceso dinámico a propiedades
console.log(post1.createdAt); // Fecha de creación del prototipo
console.log(post1.title);      // "Introducción a Design Patterns" (del override)

// También se pueden modificar propiedades después de la creación
post1.title = "Nuevo Título";
console.log(post1.title); // "Nuevo Título"

public final class AppConfiguration {

    // Holder pattern - thread-safe y lazy initialization
    private static final class Holder {
        private static final AppConfiguration INSTANCE = new AppConfiguration();
    }

    private final Map<String, String> properties;
    private final Instant loadedAt;

    private AppConfiguration() {
        this.properties = loadProperties();
        this.loadedAt = Instant.now();
        IO.println("Configuración cargada a las " + loadedAt);
    }

    public static AppConfiguration getInstance() {
        return Holder.INSTANCE;
    }

    // Otros métodos
}

// Alternativa moderna usando enum (inherentemente thread-safe)
public enum DatabaseConfig {
    INSTANCE;

    private final String url;
    private final String username;
    private final int maxPoolSize;

    DatabaseConfig() {
        final var config = AppConfiguration.getInstance();
        this.url = config.get("database.url", "jdbc:postgresql://localhost:5432/mydb");
        this.username = config.get("database.username", "admin");
        this.maxPoolSize = config.getInt("database.pool.maxSize", 10);
    }

    public String url() { return url; }
    public String username() { return username; }
    public int maxPoolSize() { return maxPoolSize; }
}

// Alternativa moderna usando LazyConstants - Preview API en Java 26
final class EventManager {
    private final LazyConstant<EventManager> manager
        = LazyConstant.of(() -> new EventManager());

    CompletionStage<ProcessResult> processAsync(T event, Set<EventListeners> listeners) {
        return manager.get().parallelProcess(event, listeners).combine();
    }

    // Otros métodos
}

// Uso
final var config = AppConfiguration.getInstance();
final String apiUrl = config.get("api.base.url", "https://api.example.com");
final int timeout = config.getInt("api.timeout.seconds", 30);
final boolean debugMode = config.getBoolean("app.debug", false);

final var dbConfig = DatabaseConfig.INSTANCE;
IO.println("Conectando a: " + dbConfig.url());

final var futureResult = EventManager.processAsync(new DummyEvent(), List.of());
futureResult.thenAccept(result -> IO.println(result));

// Interfaz objetivo que nuestro sistema espera
public interface PaymentProcessor {
    PaymentResult process(PaymentRequest request);
    PaymentStatus checkStatus(String transactionId);
    RefundResult refund(String transactionId, Money amount);
}

public record PaymentRequest(
    String customerId,
    Money amount,
    CardInfo card,
    String description
) {}

public record PaymentResult(
    String transactionId,
    PaymentStatus status,
    Instant processedAt,
    String message
) {}

public enum PaymentStatus { PENDING, COMPLETED, FAILED, REFUNDED }

// Librería externa con interfaz incompatible (no podemos modificarla)
public class StripeClient {
    public StripeCharge createCharge(String apiKey, StripeChargeRequest request) {
        // Implementación de Stripe
        return new StripeCharge();
    }

    public StripeCharge retrieveCharge(String apiKey, String chargeId) {
        return new StripeCharge();
    }

    public StripeRefund createRefund(String apiKey, String chargeId, long amountCents) {
        return new StripeRefund();
    }
}

public class StripeChargeRequest {
    private long amount;
    private String currency;
    private String source;
    private String description;
    // getters, setters...
}

// Adaptador de objeto - adapta StripeClient a PaymentProcessor
public class StripePaymentAdapter implements PaymentProcessor {

    private final StripeClient stripeClient;
    private final String apiKey;

    public StripePaymentAdapter(String apiKey) {
        this.stripeClient = new StripeClient();
        this.apiKey = apiKey;
    }

    @Override
    public PaymentResult process(PaymentRequest request) {
        // Convertir nuestro request al formato de Stripe
        var stripeRequest = new StripeChargeRequest();
        stripeRequest.setAmount(request.amount().toCents());
        stripeRequest.setCurrency(request.amount().currency());
        stripeRequest.setSource(createStripeToken(request.card()));
        stripeRequest.setDescription(request.description());

        try {
            StripeCharge charge = stripeClient.createCharge(apiKey, stripeRequest);

            // Convertir respuesta de Stripe a nuestro formato
            return new PaymentResult(
                charge.getId(),
                mapStripeStatus(charge.getStatus()),
                Instant.ofEpochSecond(charge.getCreated()),
                charge.getOutcomeMessage()
            );
        } catch (StripeException e) {
            return new PaymentResult(
                null,
                PaymentStatus.FAILED,
                Instant.now(),
                e.getMessage()
            );
        }
    }

    @Override
    public PaymentStatus checkStatus(String transactionId) {
        StripeCharge charge = stripeClient.retrieveCharge(apiKey, transactionId);
        return mapStripeStatus(charge.getStatus());
    }

    @Override
    public RefundResult refund(String transactionId, Money amount) {
        StripeRefund refund = stripeClient.createRefund(apiKey, transactionId, amount.toCents());
        return new RefundResult(refund.getId(), refund.getStatus().equals("succeeded"));
    }

    private PaymentStatus mapStripeStatus(String stripeStatus) {
        return switch (stripeStatus) {
            case "succeeded" -> PaymentStatus.COMPLETED;
            case "pending" -> PaymentStatus.PENDING;
            case "refunded" -> PaymentStatus.REFUNDED;
            default -> PaymentStatus.FAILED;
        };
    }

    private String createStripeToken(CardInfo card) {
        // Crear token de tarjeta para Stripe
        return "tok_" + card.number().substring(card.number().length() - 4);
    }
}

// Uso - el cliente trabaja con la interfaz unificada
public class CheckoutService {
    private final PaymentProcessor paymentProcessor;

    public CheckoutService(PaymentProcessor paymentProcessor) {
        this.paymentProcessor = paymentProcessor;
    }

    public OrderConfirmation checkout(Cart cart, CardInfo card) {
        var request = new PaymentRequest(
            cart.customerId(),
            cart.total(),
            card,
            "Order #" + cart.id()
        );

        PaymentResult result = paymentProcessor.process(request);

        return switch (result.status()) {
            case COMPLETED -> new OrderConfirmation(cart.id(), result.transactionId(), true);
            case PENDING -> throw new PaymentPendingException(result.transactionId());
            default -> throw new PaymentFailedException(result.message());
        };
    }
}

// Configuración - elegir adaptador según configuración
PaymentProcessor processor = switch (config.get("payment.provider")) {
    case "stripe" -> new StripePaymentAdapter(config.get("stripe.api.key"));
    case "paypal" -> new PayPalPaymentAdapter(config.get("paypal.client.id"), config.get("paypal.secret"));
    default -> throw new IllegalStateException("Unknown payment provider");
};