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 {
    // Implements functionality
}

// Using the fluent API
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 {
        // Initialize pool with connections
        for (int i = 0; i < MAX_CONNECTIONS; i++) {
            pool.offer(createConnection());
        }
    }

    private ConnectionPool() {} // Not instantiable

    // Static method that implements the 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);
            }
        }
    }

    // Version for operations without return value
    public static void withConnection(Consumer<Connection> operation) {
        withConnection(conn -> {
            operation.accept(conn);
            return null;
        });
    }

    // Version with automatic transaction
    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() {
        // Create real database connection
        return new Connection();
    }
}

// Using the Loan Pattern - the client never manages the lifecycle
record User(long id, String name, String email) {}

// Simple operation
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());

// Transactional operation
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;
});

// INCORRECT: A class that responds to multiple actors
public class Employee {
    public double calculatePay() { /* Accounting logic */ }
    public void saveToDatabase() { /* IT logic */ }
    public String generateReport() { /* Human Resources logic */ }
}

// CORRECT: Each class responds to a single actor
// Here the entity is shared, but a more robust implementation can have an entity per domain
public record Employee(long id, String name, String department, double hourlyRate) {}

// Responds to the Accounting department
public interface PayrollCalculator {
    double calculatePay(Employee employee, int hoursWorked);
}

// Responds to the IT department
public interface EmployeeRepository {
    void save(Employee employee);
    Optional<Employee> findById(long id);
}

// Responds to Human Resources
public interface EmployeeReportGenerator {
    String generatePerformanceReport(Employee employee);
}

// Abstraction that allows extension
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("Percentage must be between 0 and 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);
    }
}

// The Order class is CLOSED for modification
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);
    }
}

// To add a new discount type, we do NOT need to modify OrderProcessor
// We simply create a new implementation of DiscountStrategy

// INCORRECT: LSP violation
public class Bird {
    public void fly() { IO.println("Flying..."); }
}

public class Penguin extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Penguins cannot fly");
    }
}

// CORRECT: Hierarchy that respects LSP using segregated interfaces
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("Hunting prey"); }
    @Override
    public void fly() { IO.println("Flying high"); }
    @Override
    public int maxAltitude() { return 3000; }
}

public record Penguin(String name) implements FlightlessBird {
    @Override
    public void eat() { IO.println("Eating fish"); }
    @Override
    public void walk() { IO.println("Walking on ice"); }
}

// Now we can use any FlyingBird where one is expected
public class BirdSanctuary {
    public void releaseBird(FlyingBird bird) {
        bird.fly(); // Guaranteed to work for any FlyingBird
    }
}

// INCORRECT: "Fat" interface that forces implementing unnecessary methods
public interface Worker {
    void work();
    void eat();
    void attendMeeting();
    void writeCode();
    void reviewCode();
}

// CORRECT: Interfaces segregated by responsibility
public interface Workable {
    void work();
}

public interface Eatable {
    void eat();
}

public interface MeetingAttendee {
    void attendMeeting();
}

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

// Each class implements only what it needs
public class SoftwareEngineer implements Developer, Eatable, MeetingAttendee {
    @Override
    public void work() { writeCode(); }
    @Override
    public void eat() { IO.println("Having lunch"); }
    @Override
    public void attendMeeting() { IO.println("In daily standup"); }
    @Override
    public void writeCode() { IO.println("Programming"); }
    @Override
    public void reviewCode() { IO.println("Reviewing PR"); }
}

public class Robot implements Workable {
    @Override
    public void work() { IO.println("Executing automated task"); }
    // Does not need eat(), attendMeeting(), etc.
}

public class Manager implements Workable, Eatable, MeetingAttendee {
    @Override
    public void work() { attendMeeting(); }
    @Override
    public void eat() { IO.println("Business lunch"); }
    @Override
    public void attendMeeting() { IO.println("Leading meeting"); }
    // Does not need writeCode() or reviewCode()
}

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

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

// Concrete implementations (volatile details)
@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);
    }
}

// High-level module - depends ONLY on abstractions
// Dependency injection 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); }
            );
    }
}

// Configuration - here concrete dependencies are resolved
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)
        );
    }
}

// Abstract products
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);
}

// Abstract factory
public sealed interface UIFactory permits WindowsUIFactory, MacUIFactory {

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

    // Factory method to get the correct factory based on the OS
    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();
        };
    }
}

// Windows implementations
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();
    }
}

// Mac implementations (similar, with different style)
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();
    }
}

// ... concrete Mac implementations ...

// Client - works only with abstractions
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("Username");
        this.passwordField = factory.createTextField("Password");
        this.loginButton = factory.createButton("Sign In");
        this.cancelButton = factory.createButton("Cancel");
        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 successful");
            } else {
                errorDialog.show("Error", "Invalid credentials");
            }
        });
    }

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

// Usage
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
) {
    // Compact constructor for validation
    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) {
            // Assuming an ObjectMapper is available
            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);
        }

        // Convenient method to execute directly
        public HttpResponse execute() {
            return HttpClient.send(build());
        }
    }
}

// Using the 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();

// Or execute directly
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("📧 Sending email to " + recipient + ": " + message);
        // SMTP sending logic
    }

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

public record SmsNotification(String apiKey) implements Notification {
    @Override
    public void send(String recipient, String message) {
        IO.println("📱 Sending SMS to " + recipient + ": " + message);
        // SMS sending logic 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("🔔 Sending push to " + recipient + ": " + message);
        // Push notification logic
    }

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

// Abstract class with Factory Method
public abstract class NotificationService {

    // Factory Method - subclasses decide what to create
    protected abstract Notification createNotification();

    // Template method that uses the factory method
    public final void notifyUser(User user, String message) {
        Notification notification = createNotification();

        // Common logic: logging, validation, 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("User has not opted in for " + notification.getType());
        }
    }

    private void logNotification(User user, String type, String message) {
        IO.println("LOG: " + type + " notification sent to " + user.name());
    }
}

// Concrete implementations of the 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);
    }
}

// Usage with polymorphism
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);
    }
}

// Base class for documents
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(`Title: ${this.title}`);
    console.log(`Author: ${this.author}`);
    console.log(`Content: ${this.content}`);
  }
}

// Using Proxy to create a dynamic prototype system
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(`Prototype "${name}" not found`);
    }

    // Create a proxy that allows cloning and customizing the prototype
    const cloned = prototype.clone();

    // Proxy to intercept and customize properties
    return new Proxy(cloned, {
      get(target, prop) {
        // If the property is in overrides, return it
        if (prop in overrides) {
          return overrides[prop];
        }
        // Otherwise, return the property from the cloned object
        return target[prop];
      },

      set(target, prop, value) {
        // Allow modifying properties
        target[prop] = value;
        return true;
      },

      has(target, prop) {
        // Check if the property exists in overrides or in the target
        return prop in overrides || prop in target;
      },

      ownKeys(target) {
        // Combine the keys from target and 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);
      }
    });
  }
}

// Using the prototype system with Proxy
const registry = new PrototypeRegistry();

// Register base prototypes
const blogPostTemplate = new DocumentTemplate(
  "Post Title",
  "Default content...",
  "Anonymous Author"
);

const reportTemplate = new DocumentTemplate(
  "Report",
  "This is a standard report.",
  "System"
);

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

// Create customized instances using the proxy
const post1 = registry.create("blog-post", {
  title: "Introduction to Design Patterns",
  content: "Design patterns are reusable solutions...",
  author: "John Doe"
});

const post2 = registry.create("blog-post", {
  title: "Advanced JavaScript",
  content: "JavaScript offers powerful features...",
  author: "Jane Smith"
});

const report1 = registry.create("report", {
  title: "Monthly Report",
  content: "Summary of monthly activities..."
});

// Proxied objects maintain the prototype's properties
// but can be customized
post1.display();
// Title: Introduction to Design Patterns
// Author: John Doe
// Content: Design patterns are reusable solutions...

post2.display();
// Title: Advanced JavaScript
// Author: Jane Smith
// Content: JavaScript offers powerful features...

// The proxy allows dynamic property access
console.log(post1.createdAt); // Prototype creation date
console.log(post1.title);      // "Introduction to Design Patterns" (from override)

// Properties can also be modified after creation
post1.title = "New Title";
console.log(post1.title); // "New Title"

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("Configuration loaded at " + loadedAt);
    }

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

    // Other methods
}

// Modern alternative using enum (inherently 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; }
}

// Modern alternative using LazyConstants - Preview API in 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();
    }

    // Other methods
}

// Usage
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));

// Target interface that our system expects
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 }

// External library with incompatible interface (we cannot modify it)
public class StripeClient {
    public StripeCharge createCharge(String apiKey, StripeChargeRequest request) {
        // Stripe implementation
        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...
}

// Object adapter - adapts StripeClient to 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) {
        // Convert our request to Stripe format
        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);

            // Convert Stripe response to our format
            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) {
        // Create card token for Stripe
        return "tok_" + card.number().substring(card.number().length() - 4);
    }
}

// Usage - the client works with the unified interface
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());
        };
    }
}

// Configuration - choose adapter based on configuration
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");
};