package com.aydinsude.workbench.explorer;
import java.util.Iterator;
import java.util.List;
// Design Pattern: Iterator
// Zweck: Traversierung einer fachlichen Sammlung kapseln.
public final class IteratorPatternLab {
  public record AuditTrail(List<String> entries) implements Iterable<String> {
    public AuditTrail { entries = List.copyOf(entries); }
    @Override public Iterator<String> iterator() { return entries.iterator(); }
  }
}

package com.aydinsude.workbench.explorer;
// Design Pattern: Memento
// Zweck: Zustand wiederherstellbar sichern, ohne Interna offenzulegen.
public final class MementoPatternLab {
  public static final class Draft {
    private String text=""; public void change(String value){ text=value; }
    public Snapshot snapshot(){ return new Snapshot(text); }
    public void restore(Snapshot snapshot){ text=snapshot.text(); }
    public String text(){ return text; }
  }
  public record Snapshot(String text){}
}

package com.aydinsude.workbench.explorer;
import java.util.concurrent.ConcurrentHashMap;
// Design Pattern: Flyweight
// Zweck: Unveränderliche Produktmetadaten zwischen Positionen teilen.
public final class FlyweightPatternLab {
  public record ProductType(String code,String label){}
  public static final class ProductTypePool {
    private final ConcurrentHashMap<String,ProductType> cache=new ConcurrentHashMap<>();
    public ProductType get(String code){ return cache.computeIfAbsent(code,c->new ProductType(c,"Type "+c)); }
  }
}

package com.aydinsude.workbench.explorer;
// Design Pattern: Interpreter
// Zweck: Kleine fachliche Ausdrücke als Objektbaum auswerten.
public final class InterpreterPatternLab {
  public record Context(int amount, boolean vip){}
  public interface Expression { boolean eval(Context context); }
  public record AmountAtLeast(int value) implements Expression { public boolean eval(Context c){ return c.amount()>=value; } }
  public record And(Expression left,Expression right) implements Expression { public boolean eval(Context c){ return left.eval(c)&&right.eval(c); } }
}

package com.aydinsude.workbench.explorer;
// Design Pattern: Null Object
// Zweck: Optionale Benachrichtigung ohne null-Verzweigungen modellieren.
public final class NullObjectPatternLab {
  public interface Notifier { void send(String message); }
  public enum SilentNotifier implements Notifier { INSTANCE; public void send(String message){} }
}

package com.aydinsude.workbench.explorer;
import java.util.ArrayDeque;
// Design Pattern: Object Pool
// Zweck: Begrenzte teure Ressourcen kontrolliert wiederverwenden.
public final class ObjectPoolPatternLab {
  public static final class Pool<T>{
    private final ArrayDeque<T> free=new ArrayDeque<>();
    public Pool(java.util.Collection<T> resources){ free.addAll(resources); }
    public synchronized T borrow(){ if(free.isEmpty()) throw new IllegalStateException("pool exhausted"); return free.removeFirst(); }
    public synchronized void release(T value){ free.addLast(value); }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.Map;
// Design Pattern: Registry
// Zweck: Parser über einen expliziten Format-Schlüssel auswählen.
public final class RegistryPatternLab {
  public interface Parser { String parse(String input); }
  public record ParserRegistry(Map<String,Parser> parsers){
    public ParserRegistry { parsers=Map.copyOf(parsers); }
    public Parser resolve(String format){ var p=parsers.get(format); if(p==null) throw new IllegalArgumentException(format); return p; }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.ArrayList;
import java.util.List;
// Design Pattern: Unit of Work
// Zweck: Mehrere lokale Änderungen gemeinsam bestätigen.
public final class UnitOfWorkPatternLab {
  public static final class UnitOfWork {
    private final List<Runnable> changes=new ArrayList<>();
    public void register(Runnable change){ changes.add(change); }
    public void commit(){ changes.forEach(Runnable::run); changes.clear(); }
  }
}

package com.aydinsude.workbench.explorer;
import java.time.Instant;
// Design Pattern: Domain Event
// Zweck: Eine abgeschlossene fachliche Tatsache explizit transportieren.
public final class DomainEventPatternLab {
  public sealed interface DomainEvent permits OrderApproved {}
  public record OrderApproved(String orderId, Instant occurredAt) implements DomainEvent {}
}

package com.aydinsude.workbench.explorer;
import java.util.ArrayList;
import java.util.List;
// Enterprise Pattern: Transactional Outbox
// Zweck: Zustandsänderung und spätere Nachricht atomar vorbereiten.
public final class TransactionalOutboxPatternLab {
  public record OutboxMessage(String id,String type,String payload){}
  public static final class Transaction {
    private final List<OutboxMessage> outbox=new ArrayList<>();
    public void saveOrderAndEvent(String orderId){ outbox.add(new OutboxMessage(orderId,"OrderSaved",orderId)); }
    public List<OutboxMessage> pending(){ return List.copyOf(outbox); }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.ArrayDeque;
import java.util.Deque;
// Enterprise Pattern: Saga
// Zweck: Lokale Transaktionen mit expliziten Kompensationen koordinieren.
public final class SagaPatternLab {
  public interface Step { void execute(); void compensate(); }
  public static void run(java.util.List<Step> steps) {
    Deque<Step> completed = new ArrayDeque<>();
    try { for (Step step : steps) { step.execute(); completed.push(step); } }
    catch (RuntimeException failure) { completed.forEach(Step::compensate); throw failure; }
  }
}

package com.aydinsude.workbench.explorer;
// Enterprise Pattern: Process Manager
// Zweck: Einen langlebigen fachlichen Ablauf explizit steuern.
public final class ProcessManagerPatternLab {
  public enum State { STARTED, PAYMENT_CONFIRMED, COMPLETED, FAILED }
  public static final class OrderProcess {
    private State state = State.STARTED;
    public void paymentConfirmed() { require(State.STARTED); state = State.PAYMENT_CONFIRMED; }
    public void shipmentConfirmed() { require(State.PAYMENT_CONFIRMED); state = State.COMPLETED; }
    private void require(State expected) { if (state != expected) throw new IllegalStateException(state.name()); }
    public State state() { return state; }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.function.Supplier;
// Resilience Pattern: Circuit Breaker
// Zweck: Wiederholte Aufrufe eines gestörten Systems begrenzen.
public final class CircuitBreakerPatternLab {
  public enum State { CLOSED, OPEN }
  public static final class Breaker {
    private final int threshold; private int failures; private State state = State.CLOSED;
    public Breaker(int threshold) { this.threshold = threshold; }
    public <T> T call(Supplier<T> action) {
      if (state == State.OPEN) throw new IllegalStateException("circuit open");
      try { T value = action.get(); failures = 0; return value; }
      catch (RuntimeException ex) { if (++failures >= threshold) state = State.OPEN; throw ex; }
    }
    public State state() { return state; }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.function.Predicate;
import java.util.function.Supplier;
// Resilience Pattern: Retry
// Zweck: Nur temporäre Fehler mit klarer Obergrenze wiederholen.
public final class RetryPatternLab {
  public static <T> T execute(int maxAttempts, Supplier<T> action, Predicate<RuntimeException> retryable) {
    RuntimeException last = null;
    for (int attempt = 1; attempt <= maxAttempts; attempt++) {
      try { return action.get(); }
      catch (RuntimeException ex) { last = ex; if (!retryable.test(ex)) throw ex; }
    }
    throw last;
  }
}

package com.aydinsude.workbench.explorer;
import java.util.concurrent.Semaphore;
import java.util.function.Supplier;
// Resilience Pattern: Bulkhead
// Zweck: Parallelitätskapazität pro Funktionsbereich isolieren.
public final class BulkheadPatternLab {
  public static final class Partition {
    private final Semaphore permits;
    public Partition(int capacity) { permits = new Semaphore(capacity); }
    public <T> T execute(Supplier<T> action) {
      if (!permits.tryAcquire()) throw new IllegalStateException("bulkhead full");
      try { return action.get(); } finally { permits.release(); }
    }
  }
}

package com.aydinsude.workbench.explorer;
import java.time.Clock;
import java.time.Instant;
// Resilience Pattern: Rate Limiter
// Zweck: Eine feste Zahl von Aufrufen pro Zeitfenster zulassen.
public final class RateLimiterPatternLab {
  public static final class FixedWindow {
    private final int limit; private final long seconds; private final Clock clock;
    private Instant windowStart; private int used;
    public FixedWindow(int limit, long seconds, Clock clock) { this.limit=limit; this.seconds=seconds; this.clock=clock; this.windowStart=clock.instant(); }
    public synchronized boolean allow() {
      Instant now=clock.instant(); if(now.isAfter(windowStart.plusSeconds(seconds))){windowStart=now;used=0;}
      return used < limit && ++used > 0;
    }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
// Performance Pattern: Cache Aside
// Zweck: Daten bei Cache-Miss aus einer Quelle laden.
public final class CacheAsidePatternLab {
  public static final class Cache<K,V> {
    private final Map<K,V> values = new HashMap<>();
    public V get(K key, Function<K,V> loader) { return values.computeIfAbsent(key, loader); }
    public void invalidate(K key) { values.remove(key); }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.Map;
// Architecture Pattern: CQRS
// Zweck: Änderungs- und Lesemodell bewusst trennen.
public final class CqrsPatternLab {
  public record RenameCustomer(String customerId, String newName) {}
  public interface CommandHandler { void handle(RenameCustomer command); }
  public interface CustomerView { Map<String,String> find(String customerId); }
}

package com.aydinsude.workbench.explorer;
import java.util.List;
// Architecture Pattern: Event Sourcing
// Zweck: Kontostand aus unveränderlichen Ereignissen rekonstruieren.
public final class EventSourcingPatternLab {
  public sealed interface Event permits Deposited, Withdrawn { int amount(); }
  public record Deposited(int amount) implements Event {}
  public record Withdrawn(int amount) implements Event {}
  public static int balance(List<Event> events) {
    return events.stream().mapToInt(e -> e instanceof Deposited ? e.amount() : -e.amount()).sum();
  }
}

package com.aydinsude.workbench.explorer;
import java.util.HashMap;
import java.util.Map;
// Architecture Pattern: Materialized View
// Zweck: Vorberechnete Umsatzsummen für schnelle Abfragen halten.
public final class MaterializedViewPatternLab {
  public static final class RevenueView {
    private final Map<String,Integer> totals = new HashMap<>();
    public void onSale(String region, int amount) { totals.merge(region, amount, Integer::sum); }
    public int revenue(String region) { return totals.getOrDefault(region, 0); }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.Map;
// Architecture Pattern: API Gateway
// Zweck: Externe Requests kontrolliert an interne Services weiterleiten.
public final class ApiGatewayPatternLab {
  public interface Route { String handle(String body); }
  public static final class Gateway {
    private final Map<String, Route> routes;
    public Gateway(Map<String, Route> routes) { this.routes = Map.copyOf(routes); }
    public String dispatch(String path, String body) {
      Route route = routes.get(path);
      if (route == null) throw new IllegalArgumentException("unknown route: " + path);
      return route.handle(body);
    }
  }
}

package com.aydinsude.workbench.explorer;
// Architecture Pattern: Backend for Frontend (BFF)
// Zweck: Eine clientspezifische Sicht auf mehrere Backend-Dienste liefern.
public final class BackendForFrontendPatternLab {
  public interface CustomerPort { String customerName(String id); }
  public interface OrderPort { int openOrders(String customerId); }
  public record MobileDashboard(String name, int openOrders) {}
  public static final class MobileBff {
    private final CustomerPort customers; private final OrderPort orders;
    public MobileBff(CustomerPort customers, OrderPort orders) { this.customers=customers; this.orders=orders; }
    public MobileDashboard dashboard(String id) { return new MobileDashboard(customers.customerName(id), orders.openOrders(id)); }
  }
}

package com.aydinsude.workbench.explorer;
// Architecture Pattern: Service Mesh
// Zweck: Fachcode von Transport- und Netzwerkpolitik entkoppeln.
public final class ServiceMeshPatternLab {
  public interface OrderClient { String load(String orderId); }
  public static final class OrderApplication {
    private final OrderClient client;
    public OrderApplication(OrderClient client) { this.client = client; }
    public String show(String orderId) { return client.load(orderId); }
  }
  // mTLS, Retry und Telemetrie liegen bewusst außerhalb dieser Klasse im Mesh.
}

package com.aydinsude.workbench.explorer;
// DDD Pattern: Anti-Corruption Layer
// Zweck: Ein Legacy-Modell in ein eigenes Domänenmodell übersetzen.
public final class AntiCorruptionLayerPatternLab {
  public record LegacyCustomer(String no, String statusCode) {}
  public enum CustomerState { ACTIVE, BLOCKED }
  public record Customer(String id, CustomerState state) {}
  public static Customer translate(LegacyCustomer legacy) {
    CustomerState state = switch (legacy.statusCode()) { case "A" -> CustomerState.ACTIVE; case "S" -> CustomerState.BLOCKED; default -> throw new IllegalArgumentException("status"); };
    return new Customer(legacy.no(), state);
  }
}

package com.aydinsude.workbench.explorer;
import java.util.function.Predicate;
// Modernization Pattern: Strangler Fig
// Zweck: Aufrufe schrittweise vom Legacy- zum Neusystem verlagern.
public final class StranglerFigPatternLab {
  public interface CustomerService { String load(String id); }
  public static final class RoutingFacade implements CustomerService {
    private final CustomerService legacy, modern; private final Predicate<String> useModern;
    public RoutingFacade(CustomerService legacy, CustomerService modern, Predicate<String> useModern) { this.legacy=legacy; this.modern=modern; this.useModern=useModern; }
    public String load(String id) { return useModern.test(id) ? modern.load(id) : legacy.load(id); }
  }
}

package com.aydinsude.workbench.explorer;
// Modernization Pattern: Branch by Abstraction
// Zweck: Alte und neue Implementierung hinter einem stabilen Vertrag parallel halten.
public final class BranchByAbstractionPatternLab {
  public interface TaxCalculator { int tax(int net); }
  public static final class LegacyTax implements TaxCalculator { public int tax(int net) { return net * 20 / 100; } }
  public static final class PreciseTax implements TaxCalculator { public int tax(int net) { return Math.round(net * 0.20f); } }
  public static final class Checkout { private final TaxCalculator taxes; public Checkout(TaxCalculator taxes){this.taxes=taxes;} public int gross(int net){return net+taxes.tax(net);} }
}

package com.aydinsude.workbench.explorer;
// Delivery Pattern: Feature Toggle
// Zweck: Neues Verhalten kontrolliert und reversibel aktivieren.
public final class FeatureTogglePatternLab {
  public interface Toggle { boolean enabled(String feature, String subject); }
  public static final class PricingService {
    private final Toggle toggles;
    public PricingService(Toggle toggles) { this.toggles = toggles; }
    public int price(String customerId, int base) { return toggles.enabled("new-pricing", customerId) ? base - base/10 : base; }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
// Messaging Pattern: Idempotent Consumer
// Zweck: Duplikate anhand einer stabilen Message-ID abweisen.
public final class IdempotentConsumerPatternLab {
  public static final class Consumer {
    private final Set<String> processed = ConcurrentHashMap.newKeySet();
    public boolean consume(String messageId, Runnable action) {
      if (!processed.add(messageId)) return false;
      try { action.run(); return true; } catch (RuntimeException ex) { processed.remove(messageId); throw ex; }
    }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.concurrent.BlockingQueue;
// Messaging Pattern: Competing Consumers
// Zweck: Unabhängige Arbeit auf mehrere gleichartige Worker verteilen.
public final class CompetingConsumersPatternLab {
  public static final class Worker implements Runnable {
    private final BlockingQueue<Runnable> queue;
    public Worker(BlockingQueue<Runnable> queue) { this.queue = queue; }
    public void run() { try { while (!Thread.currentThread().isInterrupted()) queue.take().run(); } catch (InterruptedException ex) { Thread.currentThread().interrupt(); } }
  }
}

package com.aydinsude.workbench.explorer;
// Messaging Pattern: Dead Letter Channel
// Zweck: Nicht verarbeitbare Nachrichten mit Fehlerkontext isolieren.
public final class DeadLetterChannelPatternLab {
  public record Message(String id, String payload) {}
  public record DeadLetter(Message message, String reason) {}
  public interface DeadLetterPort { void store(DeadLetter letter); }
  public static void handle(Message message, java.util.function.Consumer<Message> handler, DeadLetterPort deadLetters) {
    try { handler.accept(message); } catch (RuntimeException ex) { deadLetters.store(new DeadLetter(message, ex.getMessage())); }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.Map;
// Messaging Pattern: Message Router
// Zweck: Nachrichten anhand eines stabilen Schlüssels an einen Kanal leiten.
public final class MessageRouterPatternLab {
  public interface Channel { void send(String payload); }
  public static final class Router {
    private final Map<String, Channel> routes;
    public Router(Map<String, Channel> routes){ this.routes=Map.copyOf(routes); }
    public void route(String type, String payload){
      Channel channel=routes.get(type);
      if(channel==null) throw new IllegalArgumentException("unknown type: "+type);
      channel.send(payload);
    }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.List;
import java.util.function.Predicate;
// Messaging Pattern: Content-Based Router
// Zweck: Das Ziel aus fachlichen Eigenschaften der Nachricht bestimmen.
public final class ContentBasedRouterPatternLab {
  public record Rule(Predicate<String> matches, java.util.function.Consumer<String> target) {}
  public static final class Router {
    private final List<Rule> rules;
    public Router(List<Rule> rules){ this.rules=List.copyOf(rules); }
    public void route(String payload){
      rules.stream().filter(r->r.matches().test(payload)).findFirst()
          .orElseThrow(() -> new IllegalStateException("no route"))
          .target().accept(payload);
    }
  }
}

package com.aydinsude.workbench.explorer;
// Messaging Pattern: Message Translator
// Zweck: Ein externes Nachrichtenmodell in ein internes Fachmodell übersetzen.
public final class MessageTranslatorPatternLab {
  public record PartnerOrder(String orderNo, long totalCents) {}
  public record OrderPlaced(String orderId, java.math.BigDecimal total) {}
  public static OrderPlaced translate(PartnerOrder source){
    return new OrderPlaced(source.orderNo(), java.math.BigDecimal.valueOf(source.totalCents(),2));
  }
}

package com.aydinsude.workbench.explorer;
import java.util.List;
// Messaging Pattern: Splitter
// Zweck: Eine Sammelnachricht in korrelierte Teilnachrichten zerlegen.
public final class SplitterPatternLab {
  public record Batch(String batchId, List<String> items) {}
  public record Part(String batchId, int index, int total, String value) {}
  public static List<Part> split(Batch batch){
    return java.util.stream.IntStream.range(0,batch.items().size())
      .mapToObj(i->new Part(batch.batchId(),i,batch.items().size(),batch.items().get(i))).toList();
  }
}

package com.aydinsude.workbench.explorer;
import java.util.*;
// Messaging Pattern: Aggregator
// Zweck: Korrelierte Teilresultate kontrolliert zu einem Ergebnis zusammenführen.
public final class AggregatorPatternLab {
  public static final class Aggregator {
    private final Map<String,List<String>> parts=new HashMap<>();
    public Optional<List<String>> add(String correlationId, int expected, String value){
      List<String> values=parts.computeIfAbsent(correlationId,k->new ArrayList<>()); values.add(value);
      if(values.size()<expected) return Optional.empty();
      parts.remove(correlationId); return Optional.of(List.copyOf(values));
    }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.*;
// Messaging Pattern: Resequencer
// Zweck: Nachrichten anhand einer Sequenznummer geordnet freigeben.
public final class ResequencerPatternLab {
  public static final class Buffer {
    private final NavigableMap<Long,String> pending=new TreeMap<>(); private long next=1;
    public List<String> accept(long sequence,String payload){
      pending.putIfAbsent(sequence,payload); List<String> ready=new ArrayList<>();
      while(pending.containsKey(next)) ready.add(pending.remove(next++));
      return List.copyOf(ready);
    }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
// Messaging Pattern: Claim Check
// Zweck: Große Payload extern speichern und nur eine Referenz transportieren.
public final class ClaimCheckPatternLab {
  public static final class Store {
    private final Map<String,byte[]> data=new ConcurrentHashMap<>();
    public String put(byte[] value){ String id=java.util.UUID.randomUUID().toString(); data.put(id,value.clone()); return id; }
    public byte[] take(String id){ byte[] value=data.remove(id); if(value==null) throw new IllegalArgumentException("missing claim"); return value.clone(); }
  }
}

package com.aydinsude.workbench.explorer;
// Messaging Pattern: Wire Tap
// Zweck: Eine Nachricht zusätzlich beobachten, ohne den Hauptkanal zu verändern.
public final class WireTapPatternLab {
  public interface Channel { void send(String message); }
  public static final class TappedChannel implements Channel {
    private final Channel primary, tap;
    public TappedChannel(Channel primary, Channel tap){this.primary=primary;this.tap=tap;}
    public void send(String message){ tap.send(message); primary.send(message); }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.concurrent.ConcurrentHashMap;
// Messaging Pattern: Inbox
// Zweck: Empfang und Verarbeitungsstatus dauerhaft nachvollziehbar machen.
public final class InboxPatternLab {
  public enum Status { RECEIVED, DONE }
  public static final class Inbox {
    private final ConcurrentHashMap<String,Status> entries=new ConcurrentHashMap<>();
    public boolean reserve(String id){ return entries.putIfAbsent(id,Status.RECEIVED)==null; }
    public void complete(String id){ entries.computeIfPresent(id,(k,v)->Status.DONE); }
  }
}

package com.aydinsude.workbench.explorer;
import java.time.Duration;
import java.util.Optional;
// Messaging Pattern: Polling Consumer
// Zweck: Nachrichten mit kontrolliertem Takt und explizitem Backpressure abrufen.
public final class PollingConsumerPatternLab {
  public interface Source { Optional<String> poll(Duration timeout); }
  public static final class Consumer {
    private final Source source; private final java.util.function.Consumer<String> handler;
    public Consumer(Source source, java.util.function.Consumer<String> handler){this.source=source;this.handler=handler;}
    public boolean runOnce(){ return source.poll(Duration.ofSeconds(1)).map(m->{handler.accept(m); return true;}).orElse(false); }
  }
}

package com.aydinsude.workbench.explorer;
// Architecture Pattern: Layered Architecture
// Zweck: Abhängigkeiten von außen nach innen klar begrenzen.
public final class LayeredArchitecturePatternLab {
  public record Order(String id) {}
  public interface OrderRepository { void save(Order order); }
  public static final class PlaceOrderService {
    private final OrderRepository repository;
    public PlaceOrderService(OrderRepository repository){ this.repository=repository; }
    public void place(String id){ repository.save(new Order(id)); }
  }
}

package com.aydinsude.workbench.explorer;
// Architecture Pattern: Hexagonal Architecture (Ports and Adapters)
// Zweck: Der Fachkern kennt nur Ports, nicht die technische Umsetzung.
public final class HexagonalArchitecturePatternLab {
  public interface PaymentPort { boolean charge(String account, long cents); }
  public static final class CheckoutUseCase {
    private final PaymentPort payment;
    public CheckoutUseCase(PaymentPort payment){ this.payment=payment; }
    public boolean checkout(String account,long cents){ return payment.charge(account,cents); }
  }
}

package com.aydinsude.workbench.explorer;
// Architecture Pattern: Clean Architecture
// Zweck: Use Cases bleiben unabhängig von technischen Details.
public final class CleanArchitecturePatternLab {
  public record Request(String customerId) {}
  public record Response(boolean eligible) {}
  public interface CustomerFacts { int scoreOf(String customerId); }
  public static final class CheckEligibility {
    private final CustomerFacts facts;
    public CheckEligibility(CustomerFacts facts){ this.facts=facts; }
    public Response execute(Request request){ return new Response(facts.scoreOf(request.customerId()) >= 700); }
  }
}

package com.aydinsude.workbench.explorer;
// Architecture Pattern: Onion Architecture
// Zweck: Domänenregeln bilden den innersten unabhängigen Kern.
public final class OnionArchitecturePatternLab {
  public record Money(long cents) {
    public Money { if(cents < 0) throw new IllegalArgumentException("negative"); }
  }
  public static final class Invoice {
    private final Money total;
    public Invoice(Money total){ this.total=total; }
    public boolean requiresApproval(){ return total.cents() > 100_000; }
  }
}

package com.aydinsude.workbench.explorer;
// Architecture Pattern: Modular Monolith
// Zweck: Fachmodule bleiben intern gekapselt, obwohl gemeinsam deployt wird.
public final class ModularMonolithPatternLab {
  public interface BillingApi { void issueInvoice(String orderId); }
  public static final class OrderModule {
    private final BillingApi billing;
    public OrderModule(BillingApi billing){ this.billing=billing; }
    public void complete(String orderId){ billing.issueInvoice(orderId); }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.List;
// Architecture Pattern: Microkernel / Plugin Architecture
// Zweck: Erweiterungen werden über stabile Plugin-Verträge eingebunden.
public final class MicrokernelPatternLab {
  public interface Plugin { boolean supports(String type); String execute(String input); }
  public static final class Kernel {
    private final List<Plugin> plugins;
    public Kernel(List<Plugin> plugins){ this.plugins=List.copyOf(plugins); }
    public String run(String type,String input){
      return plugins.stream().filter(p->p.supports(type)).findFirst()
        .orElseThrow(() -> new IllegalArgumentException("no plugin")).execute(input);
    }
  }
}

package com.aydinsude.workbench.explorer;
// Enterprise Pattern: Service Layer
// Zweck: Einen Use Case als stabile Anwendungsoperation anbieten.
public final class ServiceLayerPatternLab {
  public interface AccountRepository { boolean exists(String id); void close(String id); }
  public static final class AccountService {
    private final AccountRepository repository;
    public AccountService(AccountRepository repository){ this.repository=repository; }
    public void closeAccount(String id){
      if(!repository.exists(id)) throw new IllegalArgumentException("unknown account");
      repository.close(id);
    }
  }
}

package com.aydinsude.workbench.explorer;
// Data Source Pattern: Active Record
// Zweck: Einfaches Datenobjekt und Persistenzoperation eng koppeln.
public final class ActiveRecordPatternLab {
  public interface Store { void upsert(String id,String name); }
  public static final class CustomerRecord {
    private final String id; private String name;
    public CustomerRecord(String id,String name){ this.id=id; this.name=name; }
    public void rename(String name){ this.name=name; }
    public void save(Store store){ store.upsert(id,name); }
  }
}

package com.aydinsude.workbench.explorer;
// Data Source Pattern: Data Mapper
// Zweck: Persistenzdarstellung und Domänenmodell explizit übersetzen.
public final class DataMapperPatternLab {
  public record CustomerRow(String id,String displayName) {}
  public record Customer(String id,String name) {}
  public static final class Mapper {
    public Customer toDomain(CustomerRow row){ return new Customer(row.id(),row.displayName()); }
    public CustomerRow toRow(Customer customer){ return new CustomerRow(customer.id(),customer.name()); }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
// Data Source Pattern: Identity Map
// Zweck: Pro Arbeitseinheit existiert je Identität genau eine Objektinstanz.
public final class IdentityMapPatternLab {
  public static final class IdentityMap<T> {
    private final Map<String,T> entries=new HashMap<>();
    public T get(String id, Function<String,T> loader){ return entries.computeIfAbsent(id,loader); }
    public void clear(){ entries.clear(); }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.Objects;
import java.util.function.Supplier;
// Data Source Pattern: Lazy Load
// Zweck: Teure Daten erst beim ersten tatsächlichen Zugriff laden.
public final class LazyLoadPatternLab {
  public static final class LazyValue<T> {
    private Supplier<T> supplier; private T value;
    public LazyValue(Supplier<T> supplier){ this.supplier=Objects.requireNonNull(supplier); }
    public synchronized T get(){
      if(supplier != null){ value=supplier.get(); supplier=null; }
      return value;
    }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.ArrayList;
import java.util.List;
// Data Source Pattern: Query Object
// Zweck: Suchkriterien typisiert und zusammensetzbar kapseln.
public final class QueryObjectPatternLab {
  public record Criterion(String field,String operator,Object value) {}
  public static final class CustomerQuery {
    private final List<Criterion> criteria=new ArrayList<>();
    public CustomerQuery active(){ criteria.add(new Criterion("status","=","ACTIVE")); return this; }
    public CustomerQuery minScore(int score){ criteria.add(new Criterion("score",">=",score)); return this; }
    public List<Criterion> criteria(){ return List.copyOf(criteria); }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.List;
// Data Source Pattern: Table Data Gateway
// Zweck: Tabellenzugriffe an einer technischen Grenze bündeln.
public final class TableDataGatewayPatternLab {
  public record CustomerRow(String id,String name) {}
  public interface CustomerTableGateway {
    CustomerRow findById(String id);
    List<CustomerRow> findActive();
    void insert(CustomerRow row);
  }
}

package com.aydinsude.workbench.explorer;
// Data Source Pattern: Row Data Gateway
// Zweck: Eine Tabellenzeile samt Persistenzoperationen kapseln.
public final class RowDataGatewayPatternLab {
  public interface Store { void update(String id,String name); }
  public static final class CustomerRowGateway {
    private final String id; private String name;
    public CustomerRowGateway(String id,String name){ this.id=id; this.name=name; }
    public void rename(String value){ name=value; }
    public void update(Store store){ store.update(id,name); }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.Map;
// Data Source Pattern: Metadata Mapping
// Zweck: Wiederkehrende Feldzuordnungen deklarativ beschreiben.
public final class MetadataMappingPatternLab {
  public record FieldMapping(String column,String property,Class<?> type) {}
  public record EntityMapping(String table,Map<String,FieldMapping> fields) {
    public EntityMapping { fields=Map.copyOf(fields); }
  }
}

package com.aydinsude.workbench.explorer;
// Data Source Pattern: Embedded Value
// Zweck: Zusammengehörige Spalten als unveränderlichen Fachwert modellieren.
public final class EmbeddedValuePatternLab {
  public record Address(String street,String city,String postalCode) {
    public Address {
      if(street.isBlank() || city.isBlank() || postalCode.isBlank())
        throw new IllegalArgumentException("incomplete address");
    }
  }
  public record CustomerRow(String id,Address address) {}
}

package com.aydinsude.workbench.explorer;
// Data Source Pattern: Serialized LOB
// Zweck: Versionierten Snapshot als unteilbares Dokument speichern.
public final class SerializedLobPatternLab {
  public record Snapshot(int schemaVersion,String json) {
    public Snapshot {
      if(schemaVersion < 1) throw new IllegalArgumentException("schemaVersion");
      if(json == null || json.isBlank()) throw new IllegalArgumentException("json");
    }
  }
  public interface SnapshotStore { void save(String aggregateId,Snapshot snapshot); }
}

package com.aydinsude.workbench.explorer;
// Data Source Pattern: Single Table Inheritance
// Zweck: Eine kleine Hierarchie mit Diskriminator in einer Tabelle abbilden.
public final class SingleTableInheritancePatternLab {
  public sealed interface Payment permits CardPayment,BankPayment {}
  public record CardPayment(String maskedCard) implements Payment {}
  public record BankPayment(String iban) implements Payment {}
  public record PaymentRow(String type,String card,String iban) {}
}

package com.aydinsude.workbench.explorer;
// Data Source Pattern: Class Table Inheritance
// Zweck: Gemeinsame und subtypeigene Persistenzdaten trennen.
public final class ClassTableInheritancePatternLab {
  public record PaymentBaseRow(String id,String type,long cents) {}
  public record CardPaymentRow(String id,String maskedCard) {}
  public record BankPaymentRow(String id,String iban) {}
  public record CardPayment(String id,long cents,String maskedCard) {}
}

package com.aydinsude.workbench.explorer;
// Data Source Pattern: Concrete Table Inheritance
// Zweck: Konkrete Subtypen unabhängig und vollständig persistieren.
public final class ConcreteTableInheritancePatternLab {
  public record CardPaymentRow(String id,long cents,String maskedCard) {}
  public record BankPaymentRow(String id,long cents,String iban) {}
  public interface PaymentReader {
    CardPaymentRow card(String id);
    BankPaymentRow bank(String id);
  }
}

package com.aydinsude.workbench.explorer;
// Enterprise Pattern: Transaction Script
// Zweck: Einen vollständigen Use Case in einer klaren Transaktionsgrenze koordinieren.
public final class TransactionScriptPatternLab {
  public interface Orders { Order load(String id); void save(Order order); }
  public record Order(String id, boolean paid) { Order pay(){ if(paid) throw new IllegalStateException("already paid"); return new Order(id,true); } }
  public static final class PayOrder {
    private final Orders orders; public PayOrder(Orders orders){this.orders=orders;}
    public void execute(String id){ var order=orders.load(id); orders.save(order.pay()); }
  }
}

package com.aydinsude.workbench.explorer;
// Domain Model Pattern
// Zweck: Fachregeln und Invarianten im Modell statt in technischen Services halten.
public final class DomainModelPatternLab {
  public static final class Account {
    private long balance; public Account(long balance){ if(balance<0) throw new IllegalArgumentException(); this.balance=balance; }
    public void withdraw(long amount){ if(amount<=0 || amount>balance) throw new IllegalArgumentException("invalid withdrawal"); balance-=amount; }
    public long balance(){ return balance; }
  }
}

package com.aydinsude.workbench.explorer;
import java.util.ArrayList; import java.util.List;
// DDD Pattern: Aggregate
// Zweck: Änderungen und Invarianten über eine einzige Aggregate Root kontrollieren.
public final class AggregatePatternLab {
  public static final class Order {
    private final String id; private final List<String> items=new ArrayList<>(); private boolean submitted;
    public Order(String id){this.id=id;} public void add(String item){ if(submitted) throw new IllegalStateException(); items.add(item); }
    public void submit(){ if(items.isEmpty()) throw new IllegalStateException("empty"); submitted=true; }
    public String id(){return id;}
  }
}

package com.aydinsude.workbench.explorer;
import java.util.Objects;
// DDD Pattern: Entity
// Zweck: Gleichheit und Lebenszyklus über stabile Identität definieren.
public final class EntityPatternLab {
  public static final class Customer {
    private final String id; private String name; public Customer(String id,String name){this.id=id;this.name=name;}
    public void rename(String value){name=value;} public String name(){return name;}
    public boolean equals(Object o){return o instanceof Customer c && id.equals(c.id);}
    public int hashCode(){return Objects.hash(id);}
  }
}

package com.aydinsude.workbench.explorer;
import java.util.Currency;
// DDD Pattern: Value Object
// Zweck: Fachwerte unveränderlich, validiert und mit Wertgleichheit modellieren.
public final class ValueObjectPatternLab {
  public record Money(long minorUnits, Currency currency) {
    public Money { if(currency==null) throw new IllegalArgumentException("currency"); }
    public Money add(Money other){ if(!currency.equals(other.currency)) throw new IllegalArgumentException("currency mismatch"); return new Money(minorUnits+other.minorUnits,currency); }
  }
}

package com.aydinsude.workbench.explorer;
// DDD Pattern: Domain Service
// Zweck: Fachlogik ausdrücken, die keiner einzelnen Entity natürlich gehört.
public final class DomainServicePatternLab {
  public record Route(int kilometers, boolean international) {}
  public static final class ShippingPrice {
    public long calculate(Route route){ return route.kilometers()*12L + (route.international()?2500:0); }
  }
}

package com.aydinsude.workbench.explorer;
// DDD Pattern: Application Service
// Zweck: Use Case, Domäne und technische Ports in einer Transaktionsgrenze koordinieren.
public final class ApplicationServicePatternLab {
  public interface Repository { Ticket load(String id); void save(Ticket ticket); }
  public interface Events { void publish(String event); }
  public record Ticket(String id, boolean closed){ Ticket close(){return new Ticket(id,true);} }
  public static final class CloseTicket {
    private final Repository repo; private final Events events; public CloseTicket(Repository r,Events e){repo=r;events=e;}
    public void execute(String id){var t=repo.load(id).close(); repo.save(t); events.publish("TicketClosed:"+id);}
  }
}

package com.aydinsude.workbench.explorer;
// DDD Pattern: Policy
// Zweck: Austauschbare fachliche Entscheidung explizit und testbar machen.
public final class PolicyPatternLab {
  public record Claim(long cents,int riskScore) {}
  public record Decision(boolean approved,String reason) {}
  public interface ApprovalPolicy { Decision decide(Claim claim); }
  public static final class StandardApproval implements ApprovalPolicy {
    public Decision decide(Claim c){ return c.cents()<=100_000 && c.riskScore()<70 ? new Decision(true,"auto") : new Decision(false,"manual review"); }
  }
}

package com.aydinsude.workbench.explorer;
// DDD Pattern: Module
// Zweck: Zusammengehörige Fachlogik hinter einer kleinen öffentlichen Oberfläche bündeln.
public final class ModulePatternLab {
  public interface BillingModule { Invoice issue(String orderId,long cents); }
  public record Invoice(String orderId,long cents,String status) {}
  static final class DefaultBillingModule implements BillingModule {
    public Invoice issue(String orderId,long cents){ if(cents<=0) throw new IllegalArgumentException(); return new Invoice(orderId,cents,"ISSUED"); }
  }
}

package com.aydinsude.workbench.explorer;
import java.time.Instant;
// Integration Pattern: Published Language
// Zweck: Einen expliziten, versionierten und systemübergreifenden Vertrag definieren.
public final class PublishedLanguagePatternLab {
  public record OrderAcceptedV1(String eventId,String orderId,long totalMinor,String currency,Instant occurredAt) {}
  public interface ContractValidator { void validate(OrderAcceptedV1 event); }
}

package com.aydinsude.workbench.explorer;
import java.time.Instant;
// Integration Pattern: Event Notification
// Zweck: Eine Zustandsänderung knapp signalisieren, ohne das gesamte Fachobjekt zu übertragen.
public final class EventNotificationPatternLab {
  public record CustomerChanged(String customerId, Instant occurredAt) {}
  public interface Publisher { void publish(CustomerChanged event); }
  public static final class CustomerService {
    private final Publisher publisher; public CustomerService(Publisher p){publisher=p;}
    public void rename(String id,String name){ if(name.isBlank()) throw new IllegalArgumentException(); publisher.publish(new CustomerChanged(id,Instant.now())); }
  }
}

package com.aydinsude.workbench.explorer;
import java.time.Instant;
// Integration Pattern: Event-Carried State Transfer
// Zweck: Empfänger mit ausreichendem Zustand versorgen und synchrone Nachladeaufrufe vermeiden.
public final class EventCarriedStateTransferPatternLab {
  public record CustomerSnapshotV1(String id,String name,String segment,long version,Instant occurredAt) {}
  public interface Consumer { void apply(CustomerSnapshotV1 event); }
}

package com.aydinsude.workbench.explorer;
import java.util.UUID;
// Messaging Pattern: Request-Reply
// Zweck: Asynchrone Anfrage und Antwort über eine stabile Korrelation verbinden.
public final class RequestReplyPatternLab {
  public record Request(String correlationId,String customerId) { public static Request of(String id){return new Request(UUID.randomUUID().toString(),id);} }
  public record Reply(String correlationId,boolean eligible,String reason) {}
  public interface Gateway { Reply request(Request request); }
}

package com.aydinsude.workbench.explorer;
// Messaging Pattern: Correlation Identifier
// Zweck: Nachrichten eines fachlichen Ablaufs eindeutig zusammenführen.
public final class CorrelationIdentifierPatternLab {
  public record Message(String messageId,String correlationId,String payload) {}
  public static boolean belongsTogether(Message left,Message right){ return left.correlationId().equals(right.correlationId()); }
}

package com.aydinsude.workbench.explorer;
// Messaging Pattern: Return Address
// Zweck: Den Rückkanal unabhängig vom sendenden Transport explizit bestimmen.
public final class ReturnAddressPatternLab {
  public record Envelope(String correlationId,String replyTo,String payload) {
    public Envelope { if(replyTo==null || replyTo.isBlank()) throw new IllegalArgumentException("replyTo"); }
  }
  public interface Sender { void send(String destination,String payload); }
  public static void reply(Envelope request,String body,Sender sender){ sender.send(request.replyTo(),body); }
}

package com.aydinsude.workbench.explorer;
// Integration Pattern: Normalizer
// Zweck: Unterschiedliche externe Nachrichten in ein stabiles internes Modell übersetzen.
public final class NormalizerPatternLab {
  public record CanonicalOrder(String id,long totalMinor,String currency) {}
  public sealed interface Input permits CsvOrder,JsonOrder {}
  public record CsvOrder(String id,String cents,String currency) implements Input {}
  public record JsonOrder(String orderId,long totalMinor,String currency) implements Input {}
  public static CanonicalOrder normalize(Input in){
    return switch(in){ case CsvOrder c -> new CanonicalOrder(c.id(),Long.parseLong(c.cents()),c.currency()); case JsonOrder j -> new CanonicalOrder(j.orderId(),j.totalMinor(),j.currency()); };
  }
}

package com.aydinsude.workbench.explorer;
// Integration Pattern: Canonical Data Model
// Zweck: Punkt-zu-Punkt-Übersetzungen durch einen gemeinsamen Integrationsvertrag reduzieren.
public final class CanonicalDataModelPatternLab {
  public record Party(String id,String displayName) {}
  public record Money(long minor,String currency) {}
  public record CanonicalInvoice(String id,Party buyer,Money total,String status) {}
}

package com.aydinsude.workbench.explorer;
import java.time.Duration;
// Distributed Systems Pattern: Distributed Lock
// Zweck: Eine kritische Operation über Prozessgrenzen hinweg exklusiv ausführen.
public final class DistributedLockPatternLab {
  public interface LockPort { boolean tryAcquire(String key,Duration lease); void release(String key); }
  public static final class SettlementJob {
    private final LockPort locks; public SettlementJob(LockPort locks){this.locks=locks;}
    public boolean run(String day){ if(!locks.tryAcquire("settlement:"+day,Duration.ofMinutes(5))) return false; try { return true; } finally { locks.release("settlement:"+day); } }
  }
}

package com.aydinsude.workbench.explorer;
// Distributed Systems Pattern: Leader Election
// Zweck: Eine von mehreren Instanzen kontrolliert koordinierende Hintergrundarbeit.
public final class LeaderElectionPatternLab {
  public interface Election { boolean isLeader(String instanceId); }
  public static final class Scheduler {
    private final String instanceId; private final Election election; public Scheduler(String id,Election e){instanceId=id;election=e;}
    public boolean tick(){ return election.isLeader(instanceId); }
  }
}

package com.aydinsude.workbench.explorer;
// Cloud Pattern: Sidecar
// Zweck: Technische Querschnittsfunktionen unabhängig vom Fachprozess bereitstellen.
public final class SidecarPatternLab {
  public interface LocalTelemetrySidecar { void emit(String metric,long value); }
  public static final class OrderApplication {
    private final LocalTelemetrySidecar telemetry; public OrderApplication(LocalTelemetrySidecar t){telemetry=t;}
    public void accept(String orderId){ telemetry.emit("orders.accepted",1); }
  }
}