// Реализация — «как доставить»
interface MessageSender {
    void send(String message, String recipient);
}

class EmailSender implements MessageSender {
    public void send(String message, String recipient) {
        System.out.println("Email → " + recipient + ": " + message);
    }
}

class SmsSender implements MessageSender {
    public void send(String message, String recipient) {
        System.out.println("SMS → " + recipient + ": " + message);
    }
}

// Абстракция — «что отправить»
abstract class Notification {
    protected MessageSender sender; // мост к реализации

    public Notification(MessageSender sender) {
        this.sender = sender;
    }

    abstract void notify(String recipient, String message);
}

class UrgentNotification extends Notification {
    public UrgentNotification(MessageSender sender) {
        super(sender);
    }

    void notify(String recipient, String message) {
        sender.send("[СРОЧНО] " + message, recipient);
        sender.send("[СРОЧНО] Повторное напоминание: " + message, recipient);
    }
}

class RegularNotification extends Notification {
    public RegularNotification(MessageSender sender) {
        super(sender);
    }

    void notify(String recipient, String message) {
        sender.send(message, recipient);
    }
}

// Использование — любая комбинация
Notification urgentSms = new UrgentNotification(new SmsSender());
urgentSms.notify("+79991234567", "Сервер упал");

Notification regularEmail = new RegularNotification(new EmailSender());
regularEmail.notify("dev@company.com", "Деплой завершён");

// Общий интерфейс
interface OrganizationUnit {
    String getName();
    long getSalary();
}

// Лист — отдельный сотрудник
class Employee implements OrganizationUnit {
    private final String name;
    private final long salary;

    public Employee(String name, long salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() { return name; }
    public long getSalary() { return salary; }
}

// Композит — отдел, содержит другие элементы
class Department implements OrganizationUnit {
    private final String name;
    private final List<OrganizationUnit> units = new ArrayList<>();

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

    public void add(OrganizationUnit unit) {
        units.add(unit);
    }

    public String getName() { return name; }

    public long getSalary() {
        return units.stream()
            .mapToLong(OrganizationUnit::getSalary)
            .sum();
    }
}

// Использование
Department dev = new Department("Разработка");
dev.add(new Employee("Анна", 200_000));
dev.add(new Employee("Борис", 180_000));

Department company = new Department("Компания");
company.add(dev);
company.add(new Employee("CEO Иван", 500_000));

System.out.println(company.getSalary()); // 880000

// Базовый интерфейс
interface DataService {
    String getData(String key);
}

// Базовая реализация
class DatabaseService implements DataService {
    public String getData(String key) {
        return "data_from_db_" + key; // запрос в БД
    }
}

// Абстрактный декоратор
abstract class DataServiceDecorator implements DataService {
    protected final DataService delegate;

    public DataServiceDecorator(DataService delegate) {
        this.delegate = delegate;
    }
}

// Декоратор логирования
class LoggingDecorator extends DataServiceDecorator {
    public LoggingDecorator(DataService delegate) {
        super(delegate);
    }

    public String getData(String key) {
        System.out.println("LOG: запрос ключа " + key);
        String result = delegate.getData(key);
        System.out.println("LOG: получен результат");
        return result;
    }
}

// Декоратор кэширования
class CachingDecorator extends DataServiceDecorator {
    private final Map<String, String> cache = new HashMap<>();

    public CachingDecorator(DataService delegate) {
        super(delegate);
    }

    public String getData(String key) {
        return cache.computeIfAbsent(key, delegate::getData);
    }
}

// Использование — собираем как конструктор
DataService service = new CachingDecorator(
    new LoggingDecorator(
        new DatabaseService()
    )
);

service.getData("user:42"); // лог + БД + кэш
service.getData("user:42"); // кэш (без лога и БД)

public class UserSession {
    private Long userId;
    private String role;

    public UserSession(Long userId, String role) {
        this.userId = userId;
        this.role = role;
    }

    // getters, setters

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        UserSession that = (UserSession) o;
        return Objects.equals(userId, that.userId)
            && Objects.equals(role, that.role);
    }

    @Override
    public int hashCode() {
        return Objects.hash(userId, role);
    }
}

@Service
public class SessionManager {

    private final Set<UserSession> activeSessions = new HashSet<>();

    public void addSession(UserSession session) {
        activeSessions.add(session);
    }

    public void promoteToAdmin(Long userId) {
        activeSessions.stream()
            .filter(s -> s.getUserId().equals(userId))
            .findFirst()
            .ifPresent(s -> s.setRole("ADMIN"));
    }

    public boolean isActive(UserSession session) {
        return activeSessions.contains(session);
    }

    public void removeSession(UserSession session) {
        activeSessions.remove(session);
    }
}

// Сценарий бага:
sessionManager.addSession(new UserSession(1L, "USER"));   // ОК
sessionManager.promoteToAdmin(1L);                         // меняем роль
sessionManager.isActive(new UserSession(1L, "ADMIN"));     // false ?!
// объект внутри Set есть, но достать его нельзя

// Сложная подсистема
class InventoryService {
    boolean checkStock(String productId) {
        return true; // проверка на складе
    }
}

class PaymentService {
    boolean charge(String userId, BigDecimal amount) {
        return true; // списание средств
    }
}

class ShippingService {
    String createShipment(String orderId, String address) {
        return "TRACK-" + orderId; // создание доставки
    }
}

class NotificationService {
    void sendOrderConfirmation(String userId, String trackingId) {
        System.out.println("Уведомление отправлено: " + trackingId);
    }
}

// Фасад — один метод вместо четырёх
class OrderFacade {
    private final InventoryService inventory = new InventoryService();
    private final PaymentService payment = new PaymentService();
    private final ShippingService shipping = new ShippingService();
    private final NotificationService notification = new NotificationService();

    public String placeOrder(String userId, String productId,
                             BigDecimal amount, String address) {
        if (!inventory.checkStock(productId)) {
            throw new IllegalStateException("Нет на складе");
        }
        if (!payment.charge(userId, amount)) {
            throw new IllegalStateException("Оплата не прошла");
        }
        String trackingId = shipping.createShipment(productId, address);
        notification.sendOrderConfirmation(userId, trackingId);
        return trackingId;
    }
}

// Клиент вызывает один метод
OrderFacade facade = new OrderFacade();
String tracking = facade.placeOrder("user1", "SKU-100",
    new BigDecimal("2999.00"), "Москва, ул. Пушкина");

interface DocumentService {
    String loadDocument(String docId);
}

// Реальный сервис — тяжёлая операция
class RealDocumentService implements DocumentService {
    public String loadDocument(String docId) {
        System.out.println("Загрузка из хранилища: " + docId);
        return "Содержимое документа " + docId;
    }
}

// Прокси — контроль доступа + кэширование
class DocumentServiceProxy implements DocumentService {
    private final RealDocumentService realService = new RealDocumentService();
    private final Map<String, String> cache = new HashMap<>();
    private final Set<String> allowedRoles;

    public DocumentServiceProxy(Set<String> allowedRoles) {
        this.allowedRoles = allowedRoles;
    }

    public String loadDocument(String docId) {
        // 1. Проверка доступа
        String currentRole = SecurityContext.getCurrentRole();
        if (!allowedRoles.contains(currentRole)) {
            throw new SecurityException("Нет доступа");
        }

        // 2. Кэширование
        return cache.computeIfAbsent(docId, realService::loadDocument);
    }
}

// Клиент работает с прокси как с оригиналом
DocumentService service = new DocumentServiceProxy(Set.of("ADMIN", "EDITOR"));
String doc = service.loadDocument("report-2026");

// Событие
record OrderEvent(String orderId, String status) {}

// Подписчик
interface OrderListener {
    void onOrderStatusChanged(OrderEvent event);
}

// Издатель
class OrderService {
    private final List<OrderListener> listeners = new ArrayList<>();

    public void subscribe(OrderListener listener) {
        listeners.add(listener);
    }

    public void changeStatus(String orderId, String newStatus) {
        // бизнес-логика...
        OrderEvent event = new OrderEvent(orderId, newStatus);
        listeners.forEach(l -> l.onOrderStatusChanged(event));
    }
}

// Конкретные подписчики
class WarehouseListener implements OrderListener {
    public void onOrderStatusChanged(OrderEvent event) {
        if ("PAID".equals(event.status())) {
            System.out.println("Склад: начать сборку " + event.orderId());
        }
    }
}

class AnalyticsListener implements OrderListener {
    public void onOrderStatusChanged(OrderEvent event) {
        System.out.println("Аналитика: статус " + event.status());
    }
}

// Использование
OrderService service = new OrderService();
service.subscribe(new WarehouseListener());
service.subscribe(new AnalyticsListener());

service.changeStatus("ORD-42", "PAID");
// Склад: начать сборку ORD-42
// Аналитика: статус PAID

// Команда
interface Command {
    void execute();
    void undo();
}

// Получатель
class TextEditor {
    private StringBuilder text = new StringBuilder();

    public void insert(int pos, String str) {
        text.insert(pos, str);
    }

    public void delete(int pos, int length) {
        text.delete(pos, pos + length);
    }

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

// Конкретная команда
class InsertCommand implements Command {
    private final TextEditor editor;
    private final int position;
    private final String text;

    public InsertCommand(TextEditor editor, int position, String text) {
        this.editor = editor;
        this.position = position;
        this.text = text;
    }

    public void execute() {
        editor.insert(position, text);
    }

    public void undo() {
        editor.delete(position, text.length());
    }
}

// Инвокер с историей
class CommandHistory {
    private final Deque<Command> history = new ArrayDeque<>();

    public void execute(Command cmd) {
        cmd.execute();
        history.push(cmd);
    }

    public void undo() {
        if (!history.isEmpty()) {
            history.pop().undo();
        }
    }
}

// Использование
TextEditor editor = new TextEditor();
CommandHistory history = new CommandHistory();

history.execute(new InsertCommand(editor, 0, "Hello"));
history.execute(new InsertCommand(editor, 5, " World"));
System.out.println(editor.getText()); // Hello World

history.undo();
System.out.println(editor.getText()); // Hello

// Абстрактный класс с шаблонным методом
abstract class ReportGenerator {

    // Template Method — final, чтобы подклассы не меняли порядок
    public final void generateReport() {
        List<Map<String, Object>> data = fetchData();
        List<Map<String, Object>> processed = processData(data);
        String output = format(processed);
        send(output);
    }

    // Общий шаг
    private List<Map<String, Object>> fetchData() {
        System.out.println("Загрузка из БД...");
        return List.of(Map.of("revenue", 1_000_000));
    }

    // Общий шаг с возможностью расширения
    protected List<Map<String, Object>> processData(
            List<Map<String, Object>> data) {
        return data; // по умолчанию — без обработки
    }

    // Абстрактный шаг — подклассы обязаны реализовать
    protected abstract String format(List<Map<String, Object>> data);

    // Hook — подклассы могут переопределить
    protected void send(String output) {
        System.out.println("Отправка по email: " + output.substring(0, 50));
    }
}

class PdfReportGenerator extends ReportGenerator {
    protected String format(List<Map<String, Object>> data) {
        return "PDF: " + data.toString();
    }
}

class ExcelReportGenerator extends ReportGenerator {
    protected String format(List<Map<String, Object>> data) {
        return "XLSX: " + data.toString();
    }

    @Override
    protected void send(String output) {
        System.out.println("Загрузка в Google Drive: " + output.substring(0, 50));
    }
}

// Использование
new PdfReportGenerator().generateReport();
new ExcelReportGenerator().generateReport();

// Интерфейс состояния
interface OrderState {
    void pay(OrderContext order);
    void ship(OrderContext order);
    void deliver(OrderContext order);
}

// Контекст
class OrderContext {
    private OrderState state;

    public OrderContext() {
        this.state = new NewOrderState();
    }

    public void setState(OrderState state) {
        this.state = state;
        System.out.println("Статус → " + state.getClass().getSimpleName());
    }

    public void pay()     { state.pay(this); }
    public void ship()    { state.ship(this); }
    public void deliver() { state.deliver(this); }
}

class NewOrderState implements OrderState {
    public void pay(OrderContext order) {
        System.out.println("Оплата принята");
        order.setState(new PaidOrderState());
    }
    public void ship(OrderContext order) {
        System.out.println("Нельзя отправить неоплаченный заказ");
    }
    public void deliver(OrderContext order) {
        System.out.println("Заказ ещё не отправлен");
    }
}

class PaidOrderState implements OrderState {
    public void pay(OrderContext order) {
        System.out.println("Уже оплачен");
    }
    public void ship(OrderContext order) {
        System.out.println("Заказ передан курьеру");
        order.setState(new ShippedOrderState());
    }
    public void deliver(OrderContext order) {
        System.out.println("Заказ ещё не отправлен");
    }
}

class ShippedOrderState implements OrderState {
    public void pay(OrderContext order) {
        System.out.println("Уже оплачен");
    }
    public void ship(OrderContext order) {
        System.out.println("Уже в пути");
    }
    public void deliver(OrderContext order) {
        System.out.println("Заказ доставлен!");
        order.setState(new DeliveredOrderState());
    }
}

class DeliveredOrderState implements OrderState {
    public void pay(OrderContext o) { System.out.println("Завершён"); }
    public void ship(OrderContext o) { System.out.println("Завершён"); }
    public void deliver(OrderContext o) { System.out.println("Уже доставлен"); }
}

// Использование
OrderContext order = new OrderContext();
order.pay();     // Оплата принята → PaidOrderState
order.ship();    // Передан курьеру → ShippedOrderState
order.deliver(); // Доставлен! → DeliveredOrderState
order.pay();     // Завершён

// Абстрактный обработчик
abstract class RequestHandler {
    private RequestHandler next;

    public RequestHandler setNext(RequestHandler next) {
        this.next = next;
        return next; // для цепочки вызовов
    }

    public void handle(HttpRequest request) {
        if (next != null) {
            next.handle(request);
        }
    }
}

class AuthenticationHandler extends RequestHandler {
    public void handle(HttpRequest request) {
        if (request.getToken() == null) {
            throw new SecurityException("Нет токена");
        }
        System.out.println("✓ Аутентификация пройдена");
        super.handle(request); // передаём дальше
    }
}

class RateLimitHandler extends RequestHandler {
    private final Map<String, Integer> counters = new ConcurrentHashMap<>();

    public void handle(HttpRequest request) {
        int count = counters.merge(request.getIp(), 1, Integer::sum);
        if (count > 100) {
            throw new RuntimeException("429 Too Many Requests");
        }
        System.out.println("✓ Rate limit OK");
        super.handle(request);
    }
}

class BusinessLogicHandler extends RequestHandler {
    public void handle(HttpRequest request) {
        System.out.println("✓ Бизнес-логика выполнена");
        // конец цепочки
    }
}

// Сборка цепочки
RequestHandler chain = new AuthenticationHandler();
chain.setNext(new RateLimitHandler())
     .setNext(new BusinessLogicHandler());

chain.handle(request);

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