class PaginatedIterator<T> implements Iterator<T> {
    private final Function<Integer, List<T>> pageFetcher;
    private final int pageSize;
    private List<T> currentPage;
    private int pageIndex = 0;
    private int itemIndex = 0;

    public PaginatedIterator(Function<Integer, List<T>> pageFetcher,
                              int pageSize) {
        this.pageFetcher = pageFetcher;
        this.pageSize = pageSize;
        this.currentPage = pageFetcher.apply(0);
    }

    public boolean hasNext() {
        if (itemIndex < currentPage.size()) return true;
        if (currentPage.size() < pageSize) return false; // последняя страница

        // Подгружаем следующую страницу
        pageIndex++;
        currentPage = pageFetcher.apply(pageIndex);
        itemIndex = 0;
        return !currentPage.isEmpty();
    }

    public T next() {
        if (!hasNext()) throw new NoSuchElementException();
        return currentPage.get(itemIndex++);
    }
}

// Использование — клиент не знает про пагинацию
Iterator<User> users = new PaginatedIterator<>(
    page -> userRepository.findAll(PageRequest.of(page, 50)).getContent(),
    50
);

while (users.hasNext()) {
    User user = users.next(); // подгрузка происходит автоматически
    process(user);
}

// Медиатор
interface ChatRoom {
    void sendMessage(String message, User sender);
    void addUser(User user);
}

class GroupChatRoom implements ChatRoom {
    private final List<User> users = new ArrayList<>();

    public void addUser(User user) {
        users.add(user);
        user.setChatRoom(this);
    }

    public void sendMessage(String message, User sender) {
        users.stream()
            .filter(u -> u != sender)
            .forEach(u -> u.receive(message, sender.getName()));
    }
}

// Коллега
class User {
    private final String name;
    private ChatRoom chatRoom;

    public User(String name) {
        this.name = name;
    }

    public void setChatRoom(ChatRoom room) {
        this.chatRoom = room;
    }

    public void send(String message) {
        chatRoom.sendMessage(message, this);
    }

    public void receive(String message, String from) {
        System.out.println(name + " получил от " + from + ": " + message);
    }

    public String getName() { return name; }
}

// Использование
ChatRoom room = new GroupChatRoom();
User alice = new User("Alice");
User bob = new User("Bob");
User carol = new User("Carol");

room.addUser(alice);
room.addUser(bob);
room.addUser(carol);

alice.send("Привет всем!");
// Bob получил от Alice: Привет всем!
// Carol получил от Alice: Привет всем!

// Memento — снимок состояния (immutable)
record ConfigMemento(
    Map<String, String> properties,
    LocalDateTime timestamp
) {
    public ConfigMemento {
        properties = Map.copyOf(properties); // защитная копия
    }
}

// Originator — объект, чьё состояние сохраняем
class ServerConfig {
    private final Map<String, String> properties = new HashMap<>();

    public void set(String key, String value) {
        properties.put(key, value);
    }

    public String get(String key) {
        return properties.get(key);
    }

    public ConfigMemento save() {
        return new ConfigMemento(properties, LocalDateTime.now());
    }

    public void restore(ConfigMemento memento) {
        properties.clear();
        properties.putAll(memento.properties());
    }
}

// Caretaker — хранит историю снимков
class ConfigHistory {
    private final Deque<ConfigMemento> snapshots = new ArrayDeque<>();

    public void backup(ServerConfig config) {
        snapshots.push(config.save());
    }

    public void undo(ServerConfig config) {
        if (!snapshots.isEmpty()) {
            config.restore(snapshots.pop());
        }
    }
}

// Использование
ServerConfig config = new ServerConfig();
ConfigHistory history = new ConfigHistory();

config.set("maxThreads", "200");
history.backup(config);

config.set("maxThreads", "500");
config.set("timeout", "30s");
history.backup(config);

config.set("maxThreads", "1"); // ой, ошибка
history.undo(config);

System.out.println(config.get("maxThreads")); // 500

// Visitor
interface DocumentVisitor {
    void visit(Invoice invoice);
    void visit(Contract contract);
    void visit(Report report);
}

// Элементы
interface Document {
    void accept(DocumentVisitor visitor);
}

class Invoice implements Document {
    private final BigDecimal amount;
    public Invoice(BigDecimal amount) { this.amount = amount; }
    public BigDecimal getAmount() { return amount; }

    public void accept(DocumentVisitor visitor) {
        visitor.visit(this); // double dispatch
    }
}

class Contract implements Document {
    private final LocalDate expiryDate;
    public Contract(LocalDate expiryDate) { this.expiryDate = expiryDate; }
    public LocalDate getExpiryDate() { return expiryDate; }

    public void accept(DocumentVisitor visitor) {
        visitor.visit(this);
    }
}

class Report implements Document {
    private final int pageCount;
    public Report(int pageCount) { this.pageCount = pageCount; }
    public int getPageCount() { return pageCount; }

    public void accept(DocumentVisitor visitor) {
        visitor.visit(this);
    }
}

// Конкретный visitor — новая операция без изменения документов
class ExportVisitor implements DocumentVisitor {
    public void visit(Invoice invoice) {
        System.out.println("Экспорт счёта: " + invoice.getAmount() + " ₽");
    }
    public void visit(Contract contract) {
        System.out.println("Экспорт договора до " + contract.getExpiryDate());
    }
    public void visit(Report report) {
        System.out.println("Экспорт отчёта: " + report.getPageCount() + " стр.");
    }
}

// Использование
List<Document> docs = List.of(
    new Invoice(new BigDecimal("150000")),
    new Contract(LocalDate.of(2027, 1, 1)),
    new Report(42)
);

DocumentVisitor exporter = new ExportVisitor();
docs.forEach(doc -> doc.accept(exporter));

// Абстрактное выражение
interface Expression {
    boolean interpret(Map<String, String> context);
}

// Терминальное выражение — проверка одного поля
class Equals implements Expression {
    private final String key;
    private final String value;

    public Equals(String key, String value) {
        this.key = key;
        this.value = value;
    }

    public boolean interpret(Map<String, String> context) {
        return value.equals(context.get(key));
    }
}

class GreaterThan implements Expression {
    private final String key;
    private final int threshold;

    public GreaterThan(String key, int threshold) {
        this.key = key;
        this.threshold = threshold;
    }

    public boolean interpret(Map<String, String> context) {
        return Integer.parseInt(context.getOrDefault(key, "0")) > threshold;
    }
}

// Нетерминальные выражения — комбинаторы
class And implements Expression {
    private final Expression left, right;

    public And(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    public boolean interpret(Map<String, String> context) {
        return left.interpret(context) && right.interpret(context);
    }
}

class Or implements Expression {
    private final Expression left, right;

    public Or(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    public boolean interpret(Map<String, String> context) {
        return left.interpret(context) || right.interpret(context);
    }
}

// Использование: возраст > 18 AND город = Москва
Expression rule = new And(
    new GreaterThan("age", 18),
    new Equals("city", "Москва")
);

Map<String, String> user1 = Map.of("age", "25", "city", "Москва");
Map<String, String> user2 = Map.of("age", "16", "city", "Москва");

System.out.println(rule.interpret(user1)); // true
System.out.println(rule.interpret(user2)); // false