Collaboration and Orchestration - Part 5 of 5

// Handler interface
public interface HttpHandler {
    HttpResponse handle(HttpRequest request);
}

// Abstract base class for middleware
public abstract class Middleware implements HttpHandler {
    protected HttpHandler next;

    public Middleware setNext(HttpHandler next) {
        this.next = next;
        return this;
    }

    protected HttpResponse passToNext(HttpRequest request) {
        if (next != null) {
            return next.handle(request);
        }
        return HttpResponse.notFound("No handler found");
    }
}

// Logging middleware
public class LoggingMiddleware extends Middleware {

    private static final Logger log = Logger.getLogger(LoggingMiddleware.class.getName());

    @Override
    public HttpResponse handle(HttpRequest request) {
        long startTime = System.currentTimeMillis();
        String requestId = UUID.randomUUID().toString().substring(0, 8);

        log.info("[%s] → %s %s".formatted(requestId, request.method(), request.path()));

        HttpResponse response = passToNext(request);

        long duration = System.currentTimeMillis() - startTime;
        log.info("[%s] ← %d (%dms)".formatted(requestId, response.status(), duration));

        return response;
    }
}

// Cache middleware
public class CacheMiddleware extends Middleware {

    private final Cache<String, HttpResponse> cache;
    private final Duration ttl;

    public CacheMiddleware(Cache<String, HttpResponse> cache, Duration ttl) {
        this.cache = cache;
        this.ttl = ttl;
    }

    @Override
    public HttpResponse handle(HttpRequest request) {
        // Only cache GET requests
        if (!"GET".equals(request.method())) {
            return passToNext(request);
        }

        String cacheKey = request.method() + ":" + request.path() + ":" + request.queryString();

        HttpResponse cached = cache.get(cacheKey);
        if (cached != null) {
            return cached.withHeader("X-Cache", "HIT");
        }

        HttpResponse response = passToNext(request);

        if (response.status() == 200) {
            cache.put(cacheKey, response, ttl);
        }

        return response.withHeader("X-Cache", "MISS");
    }
}

// Final controller (ends the chain)
public class ApiController implements HttpHandler {

    private final Map<String, Function<HttpRequest, HttpResponse>> routes;

    public ApiController() {
        this.routes = new HashMap<>();
    }

    public void addRoute(String path, Function<HttpRequest, HttpResponse> handler) {
        routes.put(path, handler);
    }

    @Override
    public HttpResponse handle(HttpRequest request) {
        return routes.getOrDefault(request.path(),
            r -> HttpResponse.notFound("Route not found"))
            .apply(request);
    }
}

// Builder to construct the pipeline
public class MiddlewarePipeline {

    private final List<Middleware> middlewares = new ArrayList<>();
    private HttpHandler finalHandler;

    public MiddlewarePipeline use(Middleware middleware) {
        middlewares.add(middleware);
        return this;
    }

    public MiddlewarePipeline endpoint(HttpHandler handler) {
        this.finalHandler = handler;
        return this;
    }

    public HttpHandler build() {
        if (finalHandler == null) {
            throw new IllegalStateException("Final handler not set");
        }

        HttpHandler current = finalHandler;
        for (int i = middlewares.size() - 1; i >= 0; i--) {
            middlewares.get(i).setNext(current);
            current = middlewares.get(i);
        }

        return current;
    }
}

// Using Chain of Responsibility
final var controller = new ApiController();
controller.addRoute("/api/users", req -> HttpResponse.ok("{\"users\": []}"));
controller.addRoute("/api/products", req -> HttpResponse.ok("{\"products\": []}"));

final var pipeline = new MiddlewarePipeline()
    .use(new LoggingMiddleware())
    .use(new CacheMiddleware(new LRUCache<>(), Duration.ofMinutes(5)))
    .endpoint(controller)
    .build();

HttpResponse response = pipeline.handle(new HttpRequest("GET", "/api/users"));

// Command interface
public interface TextCommand {
    void execute();
    void undo();
    String description();
}

// Receiver - the document on which commands operate
public class TextDocument {
    private final StringBuilder content;
    private final List<TextDocumentListener> listeners = new ArrayList<>();

    public TextDocument() {
        this.content = new StringBuilder();
    }

    public TextDocument(String initialContent) {
        this.content = new StringBuilder(initialContent);
    }

    public void insert(int position, String text) {
        content.insert(position, text);
        notifyListeners();
    }

    public String delete(int start, int length) {
        String deleted = content.substring(start, start + length);
        content.delete(start, start + length);
        notifyListeners();
        return deleted;
    }

    public String replace(int start, int end, String newText) {
        String replaced = content.substring(start, end);
        content.replace(start, end, newText);
        notifyListeners();
        return replaced;
    }

    public String getText() {
        return content.toString();
    }

    public int length() {
        return content.length();
    }

    public void addListener(TextDocumentListener listener) {
        listeners.add(listener);
    }

    private void notifyListeners() {
        listeners.forEach(l -> l.onDocumentChanged(this));
    }
}

// Concrete commands
public final class InsertCommand implements TextCommand {
    private final TextDocument document;
    private final int position;
    private final String text;

    public InsertCommand(TextDocument document, int position, String text) {
        this.document = document;
        this.position = position;
        this.text = text;
    }

    @Override
    public void execute() {
        document.insert(position, text);
    }

    @Override
    public void undo() {
        document.delete(position, text.length());
    }

    @Override
    public String description() {
        return "Insert '%s' at position %d".formatted(
            text.length() > 20 ? text.substring(0, 20) + "..." : text,
            position);
    }
}

public final class DeleteCommand implements TextCommand {
    private final TextDocument document;
    private final int start;
    private final int length;
    private String deletedText;

    public DeleteCommand(TextDocument document, int start, int length) {
        this.document = document;
        this.start = start;
        this.length = length;
    }

    @Override
    public void execute() {
        deletedText = document.delete(start, length);
    }

    @Override
    public void undo() {
        document.insert(start, deletedText);
    }

    @Override
    public String description() {
        return "Delete %d characters at position %d".formatted(length, start);
    }
}

// Other commands ...

// Composite command (Macro)
public final class MacroCommand implements TextCommand {
    private final String name;
    private final List<TextCommand> commands;

    public MacroCommand(String name, List<TextCommand> commands) {
        this.name = name;
        this.commands = new ArrayList<>(commands);
    }

    @Override
    public void execute() {
        commands.forEach(TextCommand::execute);
    }

    @Override
    public void undo() {
        // Undo in reverse order
        for (int i = commands.size() - 1; i >= 0; i--) {
            commands.get(i).undo();
        }
    }

    @Override
    public String description() {
        return "Macro '%s' (%d commands)".formatted(name, commands.size());
    }
}

// Invoker - manages history and undo/redo
public class CommandHistory {
    private final Deque<TextCommand> undoStack = new ArrayDeque<>();
    private final Deque<TextCommand> redoStack = new ArrayDeque<>();
    private final int maxHistory;

    public CommandHistory(int maxHistory) {
        this.maxHistory = maxHistory;
    }

    public void execute(TextCommand command) {
        command.execute();
        undoStack.push(command);
        redoStack.clear(); // Clear redo when executing new command

        // Keep history limit
        while (undoStack.size() > maxHistory) {
            undoStack.removeLast();
        }
    }

    public boolean canUndo() {
        return !undoStack.isEmpty();
    }

    public boolean canRedo() {
        return !redoStack.isEmpty();
    }

    public void undo() {
        if (canUndo()) {
            TextCommand command = undoStack.pop();
            command.undo();
            redoStack.push(command);
        }
    }

    public void redo() {
        if (canRedo()) {
            TextCommand command = redoStack.pop();
            command.execute();
            undoStack.push(command);
        }
    }

    public List<String> getUndoHistory() {
        return undoStack.stream().map(TextCommand::description).toList();
    }

    public List<String> getRedoHistory() {
        return redoStack.stream().map(TextCommand::description).toList();
    }
}

// Client - Text editor
public class TextEditor {
    private final TextDocument document;
    private final CommandHistory history;
    private int cursorPosition = 0;

    public TextEditor() {
        this.document = new TextDocument();
        this.history = new CommandHistory(100);
    }

    public void type(String text) {
        history.execute(new InsertCommand(document, cursorPosition, text));
        cursorPosition += text.length();
    }

    public void delete(int length) {
        if (cursorPosition > 0 && length > 0) {
            int deleteStart = Math.max(0, cursorPosition - length);
            int actualLength = cursorPosition - deleteStart;
            history.execute(new DeleteCommand(document, deleteStart, actualLength));
            cursorPosition = deleteStart;
        }
    }

    public void replaceSelection(int selectionLength, String newText) {
        history.execute(new ReplaceCommand(
            document, cursorPosition, cursorPosition + selectionLength, newText));
        cursorPosition += newText.length();
    }

    public void undo() { history.undo(); }
    public void redo() { history.redo(); }

    public String getText() { return document.getText(); }
}

// Using the Command pattern
final var editor = new TextEditor();

editor.type("Hello ");
editor.type("World");
IO.println(editor.getText()); // "Hello World"

editor.undo();
IO.println(editor.getText()); // "Hello "

editor.redo();
IO.println(editor.getText()); // "Hello World"

editor.type("!");
IO.println(editor.getText()); // "Hello World!"

// Interpretation context
public record FilterContext<T>(T item, Map<String, Object> variables) {

    @SuppressWarnings("unchecked")
    public <V> V getVariable(String name) {
        return (V) variables.get(name);
    }

    public Object getProperty(String propertyName) {
        try {
            var getter = item.getClass().getMethod(propertyName);
            return getter.invoke(item);
        } catch (Exception e) {
            throw new RuntimeException("Cannot access property: " + propertyName, e);
        }
    }
}

// Abstract expression
public sealed interface FilterExpression<T>
        permits PropertyExpression, LiteralExpression, ComparisonExpression,
                AndExpression, OrExpression, NotExpression, InExpression {

    boolean interpret(FilterContext<T> context);
    String toQueryString();
}

// Terminal expressions
public record PropertyExpression<T>(String propertyName) implements FilterExpression<T> {
    @Override
    public boolean interpret(FilterContext<T> context) {
        Object value = context.getProperty(propertyName);
        return value instanceof Boolean b ? b : value != null;
    }

    @Override
    public String toQueryString() {
        return propertyName;
    }

    public Object getValue(FilterContext<T> context) {
        return context.getProperty(propertyName);
    }
}

// Non-terminal expressions - comparisons
public record ComparisonExpression<T>(
    PropertyExpression<T> left,
    ComparisonOperator operator,
    FilterExpression<T> right
) implements FilterExpression<T> {

    public enum ComparisonOperator {
        EQUALS("="), NOT_EQUALS("!="),
        GREATER_THAN(">"), LESS_THAN("<"),
        GREATER_OR_EQUALS(">="), LESS_OR_EQUALS("<="),
        CONTAINS("CONTAINS"), STARTS_WITH("STARTS_WITH");

        private final String symbol;
        ComparisonOperator(String symbol) { this.symbol = symbol; }
        public String symbol() { return symbol; }
    }

    @Override
    public boolean interpret(FilterContext<T> context) {
        Object leftValue = left.getValue(context);
        Object rightValue = right instanceof LiteralExpression<T> lit ?
            lit.value() : right.interpret(context);

        return switch (operator) {
            case EQUALS -> Objects.equals(leftValue, rightValue);
            case NOT_EQUALS -> !Objects.equals(leftValue, rightValue);
            case GREATER_THAN -> compare(leftValue, rightValue) > 0;
            case LESS_THAN -> compare(leftValue, rightValue) < 0;
            case GREATER_OR_EQUALS -> compare(leftValue, rightValue) >= 0;
            case LESS_OR_EQUALS -> compare(leftValue, rightValue) <= 0;
            case CONTAINS -> String.valueOf(leftValue).contains(String.valueOf(rightValue));
            case STARTS_WITH -> String.valueOf(leftValue).startsWith(String.valueOf(rightValue));
        };
    }

    @SuppressWarnings("unchecked")
    private int compare(Object a, Object b) {
        if (a instanceof Comparable c1 && b instanceof Comparable c2) {
            return c1.compareTo(c2);
        }
        throw new IllegalArgumentException("Cannot compare: " + a + " with " + b);
    }

    @Override
    public String toQueryString() {
        return "%s %s %s".formatted(left.toQueryString(), operator.symbol(), right.toQueryString());
    }
}

// Logical expressions
public record AndExpression<T>(FilterExpression<T> left, FilterExpression<T> right)
        implements FilterExpression<T> {

    @Override
    public boolean interpret(FilterContext<T> context) {
        return left.interpret(context) && right.interpret(context);
    }

    @Override
    public String toQueryString() {
        return "(%s AND %s)".formatted(left.toQueryString(), right.toQueryString());
    }
}

public record OrExpression<T>(FilterExpression<T> left, FilterExpression<T> right)
        implements FilterExpression<T> {

    @Override
    public boolean interpret(FilterContext<T> context) {
        return left.interpret(context) || right.interpret(context);
    }

    @Override
    public String toQueryString() {
        return "(%s OR %s)".formatted(left.toQueryString(), right.toQueryString());
    }
}

// Other implementations

// DSL builder for building expressions
public class FilterBuilder<T> {

    public PropertyBuilder<T> where(String property) {
        return new PropertyBuilder<>(new PropertyExpression<>(property));
    }

    public static class PropertyBuilder<T> {
        private final PropertyExpression<T> property;

        PropertyBuilder(PropertyExpression<T> property) {
            this.property = property;
        }

        public FilterExpression<T> equals(Object value) {
            return new ComparisonExpression<>(property,
                ComparisonExpression.ComparisonOperator.EQUALS,
                new LiteralExpression<>(value));
        }

        public FilterExpression<T> greaterThan(Object value) {
            return new ComparisonExpression<>(property,
                ComparisonExpression.ComparisonOperator.GREATER_THAN,
                new LiteralExpression<>(value));
        }

        public FilterExpression<T> contains(String value) {
            return new ComparisonExpression<>(property,
                ComparisonExpression.ComparisonOperator.CONTAINS,
                new LiteralExpression<>(value));
        }

        public FilterExpression<T> in(Object... values) {
            return new InExpression<>(property, List.of(values));
        }
    }

    public static <T> FilterExpression<T> and(FilterExpression<T> left, FilterExpression<T> right) {
        return new AndExpression<>(left, right);
    }

    public static <T> FilterExpression<T> or(FilterExpression<T> left, FilterExpression<T> right) {
        return new OrExpression<>(left, right);
    }

    public static <T> FilterExpression<T> not(FilterExpression<T> expr) {
        return new NotExpression<>(expr);
    }
}

// Using the Interpreter
public record Product(String name, String category, double price, boolean active) {}

final var filter = new FilterBuilder<Product>();

// Build expression: category = 'Electronics' AND price > 100 AND active = true
final FilterExpression<Product> expression = FilterBuilder.and(
    FilterBuilder.and(
        filter.where("category").equals("Electronics"),
        filter.where("price").greaterThan(100.0)
    ),
    filter.where("active").equals(true)
);

IO.println("Query: " + expression.toQueryString());
// Output: ((category = 'Electronics' AND price > 100.0) AND active = true)

// Filter products
final List<Product> products = List.of(
    new Product("Laptop", "Electronics", 999.99, true),
    new Product("Mouse", "Electronics", 29.99, true),
    new Product("Desk", "Furniture", 199.99, true),
    new Product("Monitor", "Electronics", 299.99, false)
);

final var filtered = products.stream()
    .filter(p -> expression.interpret(new FilterContext<>(p, Map.of())))
    .toList();

IO.println("Filtered: " + filtered);
// Output: [Product[name=Laptop, category=Electronics, price=999.99, active=true]]

// Node structure
public class TreeNode<T> {
    private final T value;
    private TreeNode<T> left;
    private TreeNode<T> right;

    public TreeNode(T value) {
        this.value = value;
    }

    public T value() { return value; }
    public TreeNode<T> left() { return left; }
    public TreeNode<T> right() { return right; }

    public void setLeft(TreeNode<T> left) { this.left = left; }
    public void setRight(TreeNode<T> right) { this.right = right; }
}

// Binary tree with multiple iteration strategies
public class BinaryTree<T> implements Iterable<T> {

    private TreeNode<T> root;

    public enum TraversalOrder { IN_ORDER }

    private TraversalOrder defaultOrder = TraversalOrder.IN_ORDER;

    public void setRoot(TreeNode<T> root) {
        this.root = root;
    }

    public void setDefaultTraversal(TraversalOrder order) {
        this.defaultOrder = order;
    }

    @Override
    public Iterator<T> iterator() {
        return iterator(defaultOrder);
    }

    public Iterator<T> iterator(TraversalOrder order) {
        return switch (order) {
            case IN_ORDER -> new InOrderIterator<>(root);
        };
    }

    public Iterable<T> inOrder() {
        return () -> iterator(TraversalOrder.IN_ORDER);
    }

    // Stream support
    public Stream<T> stream() {
        return stream(defaultOrder);
    }

    public Stream<T> stream(TraversalOrder order) {
        return StreamSupport.stream(
            Spliterators.spliteratorUnknownSize(iterator(order), Spliterator.ORDERED),
            false
        );
    }
}

// In-Order iterator (left -> root -> right)
class InOrderIterator<T> implements Iterator<T> {
    private final Deque<TreeNode<T>> stack = new ArrayDeque<>();

    InOrderIterator(TreeNode<T> root) {
        pushLeft(root);
    }

    private void pushLeft(TreeNode<T> node) {
        while (node != null) {
            stack.push(node);
            node = node.left();
        }
    }

    @Override
    public boolean hasNext() {
        return !stack.isEmpty();
    }

    @Override
    public T next() {
        if (!hasNext()) throw new NoSuchElementException();
        TreeNode<T> current = stack.pop();
        pushLeft(current.right());
        return current.value();
    }
}

// Using the Iterator pattern
final var tree = new BinaryTree<Integer>();
//        4
//       / \
//      2   6
//     / \ / \
//    1  3 5  7

final var root = new TreeNode<>(4);
root.setLeft(new TreeNode<>(2));
root.setRight(new TreeNode<>(6));
root.left().setLeft(new TreeNode<>(1));
root.left().setRight(new TreeNode<>(3));
root.right().setLeft(new TreeNode<>(5));
root.right().setRight(new TreeNode<>(7));
tree.setRoot(root);

// Different ways to iterate
IO.println("In-Order: " + tree.stream(TraversalOrder.IN_ORDER).toList());
// [1, 2, 3, 4, 5, 6, 7]

// Using for-each
for (Integer value : tree.inOrder()) {
    System.out.print(value + " ");
}

// Using Streams for functional operations
int sum = tree.stream()
    .filter(n -> n % 2 == 0)
    .mapToInt(Integer::intValue)
    .sum();

// Mediator interface
public interface ChatMediator {
    void sendMessage(String message, User sender);
    void sendPrivateMessage(String message, User sender, User recipient);
    void addUser(User user);
    void removeUser(User user);
    List<User> getOnlineUsers();
}

// Colleague interface (user)
public abstract class User {
    protected final String id;
    protected final String name;
    protected ChatMediator mediator;
    protected boolean online;

    protected User(String id, String name) {
        this.id = id;
        this.name = name;
        this.online = false;
    }

    public String id() { return id; }
    public String name() { return name; }
    public boolean isOnline() { return online; }

    public void join(ChatMediator mediator) {
        this.mediator = mediator;
        this.online = true;
        mediator.addUser(this);
    }

    public void leave() {
        if (mediator != null) {
            mediator.removeUser(this);
            this.online = false;
        }
    }

    public abstract void send(String message);
    public abstract void sendPrivate(String message, User recipient);
    public abstract void receive(String message, User sender);
    public abstract void receivePrivate(String message, User sender);
}

// Concrete user implementation
public class ChatUser extends User {
    private final List<ChatMessage> messageHistory = new ArrayList<>();

    public record ChatMessage(String content, String senderId, Instant timestamp, boolean isPrivate) {}

    public ChatUser(String id, String name) {
        super(id, name);
    }

    @Override
    public void send(String message) {
        if (mediator != null && online) {
            IO.println("[" + name + "] sends: " + message);
            mediator.sendMessage(message, this);
        }
    }

    @Override
    public void sendPrivate(String message, User recipient) {
        if (mediator != null && online) {
            IO.println("[" + name + "] whispers to [" + recipient.name() + "]: " + message);
            mediator.sendPrivateMessage(message, this, recipient);
        }
    }

    @Override
    public void receive(String message, User sender) {
        var chatMessage = new ChatMessage(message, sender.id(), Instant.now(), false);
        messageHistory.add(chatMessage);
        IO.println("  [" + name + "] received from [" + sender.name() + "]: " + message);
    }

    @Override
    public void receivePrivate(String message, User sender) {
        var chatMessage = new ChatMessage(message, sender.id(), Instant.now(), true);
        messageHistory.add(chatMessage);
        IO.println("  [" + name + "] received private from [" + sender.name() + "]: " + message);
    }

    public List<ChatMessage> getHistory() {
        return Collections.unmodifiableList(messageHistory);
    }
}

// Mediator implementation
public class ChatRoom implements ChatMediator {
    private final String roomId;
    private final String roomName;
    private final Set<User> users = ConcurrentHashMap.newKeySet();
    private final List<BroadcastMessage> broadcastHistory = new ArrayList<>();
    private final Map<String, List<String>> blockedUsers = new ConcurrentHashMap<>();

    public record BroadcastMessage(String content, String senderId, Instant timestamp) {}

    public ChatRoom(String roomId, String roomName) {
        this.roomId = roomId;
        this.roomName = roomName;
    }

    @Override
    public void sendMessage(String message, User sender) {
        broadcastHistory.add(new BroadcastMessage(message, sender.id(), Instant.now()));

        // The mediator coordinates who receives the message
        users.stream()
            .filter(user -> !user.equals(sender))
            .filter(User::isOnline)
            .filter(user -> !isBlocked(sender.id(), user.id()))
            .forEach(user -> user.receive(message, sender));
    }

    @Override
    public void sendPrivateMessage(String message, User sender, User recipient) {
        if (users.contains(recipient) && recipient.isOnline() && !isBlocked(sender.id(), recipient.id())) {
            recipient.receivePrivate(message, sender);
        }
    }

    @Override
    public void addUser(User user) {
        users.add(user);
        // Notify other users
        sendSystemMessage(user.name() + " has joined the chat");
    }

    @Override
    public void removeUser(User user) {
        users.remove(user);
        sendSystemMessage(user.name() + " has left the chat");
    }

    @Override
    public List<User> getOnlineUsers() {
        return users.stream().filter(User::isOnline).toList();
    }

    public void blockUser(String blockerId, String blockedId) {
        blockedUsers.computeIfAbsent(blockerId, k -> new ArrayList<>()).add(blockedId);
    }

    private boolean isBlocked(String senderId, String recipientId) {
        return blockedUsers.getOrDefault(recipientId, List.of()).contains(senderId);
    }

    private void sendSystemMessage(String message) {
        users.stream()
            .filter(User::isOnline)
            .forEach(user -> IO.println("  [SYSTEM -> " + user.name() + "]: " + message));
    }
}

// Using the Mediator pattern
var chatRoom = new ChatRoom("room-1", "General");

var alice = new ChatUser("1", "Alice");
var bob = new ChatUser("2", "Bob");
var charlie = new ChatUser("3", "Charlie");

// Users join through the mediator
alice.join(chatRoom);
bob.join(chatRoom);
charlie.join(chatRoom);

// Mediated communication
alice.send("Hello everyone!");
// [Alice] sends: Hello everyone!
//   [Bob] received from [Alice]: Hello everyone!
//   [Charlie] received from [Alice]: Hello everyone!

bob.sendPrivate("Hi Alice, how are you?", alice);
// [Bob] whispers to [Alice]: Hi Alice, how are you?
//   [Alice] received private from [Bob]: Hi Alice, how are you?

// Block user
chatRoom.blockUser("Charlie", "Bob");
bob.send("This message will not reach Charlie");

alice.leave();
// [SYSTEM -> Bob]: Alice has left the chat
// [SYSTEM -> Charlie]: Alice has left the chat

// Memento - stores state
public final class EditorMemento {
    private final String content;
    private final int cursorPosition;
    private final Set<Integer> breakpoints;
    private final Instant savedAt;
    private final String description;

    // Package-private constructor - only Originator can create mementos
    EditorMemento(String content, int cursorPosition, Set<Integer> breakpoints, String description) {
        this.content = content;
        this.cursorPosition = cursorPosition;
        this.breakpoints = Set.copyOf(breakpoints);
        this.savedAt = Instant.now();
        this.description = description;
    }

    // Limited public interface for the Caretaker
    public Instant savedAt() { return savedAt; }
    public String description() { return description; }

    // Package-private methods for the Originator
    String content() { return content; }
    int cursorPosition() { return cursorPosition; }
    Set<Integer> breakpoints() { return breakpoints; }
}

// Originator - the editor
public class CodeEditor {
    private StringBuilder content;
    private int cursorPosition;
    private final Set<Integer> breakpoints;
    private String filename;

    public CodeEditor() {
        this.content = new StringBuilder();
        this.cursorPosition = 0;
        this.breakpoints = new HashSet<>();
    }

    public void newFile(String filename) {
        this.filename = filename;
        this.content = new StringBuilder();
        this.cursorPosition = 0;
        this.breakpoints.clear();
    }

    public void type(String text) {
        content.insert(cursorPosition, text);
        cursorPosition += text.length();
    }

    public void delete(int count) {
        int start = Math.max(0, cursorPosition - count);
        content.delete(start, cursorPosition);
        cursorPosition = start;
    }

    public void moveCursor(int position) {
        this.cursorPosition = Math.max(0, Math.min(position, content.length()));
    }

    public void toggleBreakpoint(int line) {
        if (breakpoints.contains(line)) {
            breakpoints.remove(line);
        } else {
            breakpoints.add(line);
        }
    }

    public String getContent() {
        return content.toString();
    }

    // Create memento
    public EditorMemento save(String description) {
        return new EditorMemento(
            content.toString(),
            cursorPosition,
            breakpoints,
            description
        );
    }

    // Restore from memento
    public void restore(EditorMemento memento) {
        this.content = new StringBuilder(memento.content());
        this.cursorPosition = memento.cursorPosition();
        this.breakpoints.clear();
        this.breakpoints.addAll(memento.breakpoints());
    }

    public void displayStatus() {
        IO.println("=== Editor Status ===");
        IO.println("File: " + filename);
        IO.println("Content: " + content);
        IO.println("Cursor: " + cursorPosition);
        IO.println("Breakpoints: " + breakpoints);
        IO.println("====================");
    }
}

// Caretaker - manages memento history
public class EditorHistory {
    private final Deque<EditorMemento> history = new ArrayDeque<>();
    private final Deque<EditorMemento> redoStack = new ArrayDeque<>();
    private final int maxSnapshots;

    public EditorHistory(int maxSnapshots) {
        this.maxSnapshots = maxSnapshots;
    }

    public void save(EditorMemento memento) {
        history.push(memento);
        redoStack.clear();

        while (history.size() > maxSnapshots) {
            history.removeLast();
        }
    }

    public Optional<EditorMemento> undo() {
        if (history.size() > 1) {
            EditorMemento current = history.pop();
            redoStack.push(current);
            return Optional.of(history.peek());
        }
        return Optional.empty();
    }

    public Optional<EditorMemento> redo() {
        if (!redoStack.isEmpty()) {
            EditorMemento memento = redoStack.pop();
            history.push(memento);
            return Optional.of(memento);
        }
        return Optional.empty();
    }

    public List<String> getSnapshotDescriptions() {
        return history.stream()
            .map(m -> "[%s] %s".formatted(
                m.savedAt().toString().substring(11, 19),
                m.description()))
            .toList();
    }

    public Optional<EditorMemento> getSnapshot(int index) {
        return history.stream().skip(index).findFirst();
    }
}

// Facade to simplify usage
public class EditorWithHistory {
    private final CodeEditor editor;
    private final EditorHistory history;

    public EditorWithHistory() {
        this.editor = new CodeEditor();
        this.history = new EditorHistory(50);
    }

    public void newFile(String filename) {
        editor.newFile(filename);
        saveSnapshot("New file: " + filename);
    }

    public void type(String text) {
        editor.type(text);
        saveSnapshot("Typed: " + truncate(text, 20));
    }

    public void delete(int count) {
        editor.delete(count);
        saveSnapshot("Deleted " + count + " chars");
    }

    public void undo() {
        history.undo().ifPresent(memento -> {
            editor.restore(memento);
            IO.println("Undo: " + memento.description());
        });
    }

    public void redo() {
        history.redo().ifPresent(memento -> {
            editor.restore(memento);
            IO.println("Redo: " + memento.description());
        });
    }

    public void showHistory() {
        IO.println("=== Snapshot History ===");
        history.getSnapshotDescriptions().forEach(System.out::println);
    }

    private void saveSnapshot(String description) {
        history.save(editor.save(description));
    }

    private String truncate(String s, int maxLen) {
        return s.length() > maxLen ? s.substring(0, maxLen) + "..." : s;
    }

    public String getContent() { return editor.getContent(); }
    public void displayStatus() { editor.displayStatus(); }
}

// Using the Memento pattern
var editor = new EditorWithHistory();

editor.newFile("Main.java");
editor.type("public class Main {\n");
editor.type("    public static void main(String[] args) {\n");
editor.type("        IO.println(\"Hello\");\n");
editor.type("    }\n");
editor.type("}");

IO.println(editor.getContent());

editor.showHistory();

// Undo changes
editor.undo();
editor.undo();
IO.println("After 2 undos:\n" + editor.getContent());

// Redo
editor.redo();
IO.println("After redo:\n" + editor.getContent());