GoF Behavioral II
& Complete Review

// CUSTOM ITERATOR: date range iterator — no collection stored in memory
public class DateRangeIterator implements Iterator<LocalDate> {
    private LocalDate current;
    private final LocalDate endInclusive;

    public DateRangeIterator(LocalDate start, LocalDate end) {
        this.current      = start;
        this.endInclusive = end;
    }
    @Override
    public boolean hasNext() { return !current.isAfter(endInclusive); }
    @Override
    public LocalDate next() {
        if (!hasNext()) throw new NoSuchElementException();
        LocalDate result = current;
        current = current.plusDays(1);
        return result;
    }
}

// Make it Iterable for enhanced for-loop and Stream support
public class DateRange implements Iterable<LocalDate> {
    private final LocalDate start, end;
    public DateRange(LocalDate start, LocalDate end) { this.start=start; this.end=end; }

    @Override
    public Iterator<LocalDate> iterator() { return new DateRangeIterator(start, end); }

    // Convert to Stream — Spliterator is the Stream-aware iterator
    public Stream<LocalDate> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
}

// Usage: clean as any built-in collection
var range = new DateRange(LocalDate.of(2025, 1, 1), LocalDate.of(2025, 12, 31));
for (LocalDate d : range) { /* process each date */ }
range.stream().filter(LocalDate::isLeapYear).forEach(System.out::println);

// FAIL-FAST vs FAIL-SAFE — the interview distinction
// ─────────────────────────────────────────────────────────────────────────

// FAIL-FAST: ArrayList, HashMap, HashSet, LinkedList
// Uses a modCount field — any structural modification increments modCount.
// Iterator checks modCount on every next() call — mismatch → CME
List<String> list = new ArrayList<>(List.of("a", "b", "c"));
for (String s : list) {
    if (s.equals("b")) list.remove(s); // ❌ ConcurrentModificationException!
}

// CORRECT: use Iterator.remove() — modCount-aware
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().equals("b")) it.remove(); // ✅ safe — iterator updates modCount
}

// ALSO CORRECT in Java 8+: removeIf (uses iterator.remove() internally)
list.removeIf(s -> s.equals("b"));           // ✅ cleanest

// FAIL-SAFE: CopyOnWriteArrayList, ConcurrentHashMap, ConcurrentSkipListMap
// Iterator works on a SNAPSHOT of the collection at iteration start.
// Modifications to the original don't affect ongoing iteration — no CME.
// Trade-off: snapshot takes memory; you might see stale data during iteration.
List<String> cowList = new CopyOnWriteArrayList<>(List.of("a", "b", "c"));
for (String s : cowList) {
    cowList.add("d"); // ✅ no CME — iterator uses snapshot from before this add
}

// STREAM API — Iterator as functional pipeline (lazy evaluation)
// Stream's Spliterator is a parallel-aware Iterator — supports split for parallel execution
List<Order> orders = repo.findAll();

// Lazy pipeline — nothing executes until terminal operation
BigDecimal totalRevenue = orders.stream()               // creates Spliterator
    .filter(o -> o.getStatus() == OrderStatus.DELIVERED)  // lazy intermediate
    .filter(o -> o.getCreatedAt().getYear() == 2025)      // lazy intermediate
    .map(Order::getTotal)                                 // lazy intermediate
    .reduce(BigDecimal.ZERO, BigDecimal::add);            // TERMINAL — triggers all above

// Spring Batch: ItemReader IS an Iterator
// chunk-oriented processing: reader.read() until null, process batch, write batch
@Bean
public JdbcCursorItemReader<Order> orderReader(DataSource ds) {
    return new JdbcCursorItemReaderBuilder<Order>()
        .dataSource(ds)
        .sql("SELECT * FROM orders WHERE status = 'PENDING' ORDER BY created_at")
        .rowMapper(new BeanPropertyRowMapper<>(Order.class))
        .build(); // reads one row at a time — Iterator over DB cursor
}

// MEDIATOR INTERFACE
public interface ChatMediator {
    void sendMessage(String message, ChatUser sender);
    void sendPrivate(String message, ChatUser sender, ChatUser recipient);
    void register(ChatUser user);
    void unregister(ChatUser user);
}

// CONCRETE MEDIATOR — contains all the routing logic
public class ChatRoom implements ChatMediator {
    private final Map<String, ChatUser> users = new ConcurrentHashMap<>();
    private final List<ChatMessage>     history = new CopyOnWriteArrayList<>();

    @Override
    public void register(ChatUser user) {
        users.put(user.getName(), user);
        broadcast("[System] " + user.getName() + " joined the room", null);
    }

    @Override
    public void sendMessage(String msg, ChatUser sender) {
        // Mediator decides who receives the message — senders don't know about receivers
        history.add(new ChatMessage(sender.getName(), msg, Instant.now()));
        users.values().stream()
            .filter(u -> !u.equals(sender))  // don't echo back to sender
            .filter(ChatUser::isOnline)
            .forEach(u -> u.receive(sender.getName() + ": " + msg));
    }

    @Override
    public void sendPrivate(String msg, ChatUser sender, ChatUser recipient) {
        if (recipient.isOnline()) {
            recipient.receive("[PM from " + sender.getName() + "] " + msg);
        } else {
            sender.receive("[System] " + recipient.getName() + " is offline");
        }
    }

    private void broadcast(String msg, ChatUser exclude) {
        users.values().stream()
            .filter(u -> !u.equals(exclude))
            .forEach(u -> u.receive(msg));
    }

    @Override
    public void unregister(ChatUser u) {
        users.remove(u.getName());
        broadcast("[System] " + u.getName() + " left the room", null);
    }
}

// COLLEAGUE — users talk TO the mediator, not to each other directly
public class ChatUser {
    private final String       name;
    private final ChatMediator mediator; // knows mediator, NOT other users
    private       boolean      online = true;

    public void send(String message) {
        mediator.sendMessage(message, this); // routes through mediator
    }
    public void pm(ChatUser to, String msg) {
        mediator.sendPrivate(msg, this, to); // mediator handles delivery logic
    }
    public void receive(String msg) { System.out.println("[" + name + "] " + msg); }
    // Alice never calls bob.receive() directly — all via ChatRoom mediator
}

// HOW SPRING'S DispatcherServlet IS a Mediator:
//
// Components: HandlerMapping, HandlerAdapter, ViewResolver, ExceptionResolver
// Mediator: DispatcherServlet
//
// Without Mediator: every component would need to know about all others.
// HandlerMapping would need to know about HandlerAdapters.
// HandlerAdapters would need to call ViewResolvers directly.
// → N×N coupling web.
//
// With DispatcherServlet as Mediator:
// 1. DispatcherServlet receives HTTP request
// 2. Asks HandlerMapping: "who handles GET /orders?" → returns handler + interceptors
// 3. Asks HandlerAdapter: "can you execute this handler?" → adapter.handle()
// 4. Adapter returns ModelAndView
// 5. DispatcherServlet asks ViewResolver: "render this view name" → View
// 6. View renders response
// → Each component is M:1 with DispatcherServlet, not M:N with each other.

// SPRING WEBFLUX: WebHandler plays the same Mediator role in reactive stack

// MEMENTO — immutable snapshot of Originator's state (opaque to Caretaker)
public final class OrderDraftMemento {
    // All fields private — Caretaker cannot read them
    private final List<OrderItem> items;
    private final Address        shippingAddress;
    private final String         couponCode;
    private final PaymentMethod  paymentMethod;
    private final Instant        savedAt;

    // Package-private constructor — only OrderDraft (Originator) in same package can create
    package OrderDraftMemento(List<OrderItem> items, Address addr,
                               String coupon, PaymentMethod pm) {
        this.items          = List.copyOf(items); // defensive copy — immutable snapshot
        this.shippingAddress = addr;
        this.couponCode      = coupon;
        this.paymentMethod   = pm;
        this.savedAt         = Instant.now();
    }
    // Only Originator can access these via package-private getters
    List<OrderItem> getItems()          { return items; }
    Address         getShippingAddress() { return shippingAddress; }
    String          getCouponCode()      { return couponCode; }
    PaymentMethod   getPaymentMethod()  { return paymentMethod; }
    public Instant  getSavedAt()        { return savedAt; } // public — Caretaker can show timestamp
}

// ORIGINATOR — creates and restores from mementos
public class OrderDraft {
    private List<OrderItem> items          = new ArrayList<>();
    private Address        shippingAddress;
    private String         couponCode;
    private PaymentMethod  paymentMethod;

    public void addItem(OrderItem item)           { items.add(item); }
    public void setAddress(Address addr)          { this.shippingAddress = addr; }
    public void applyCoupon(String code)          { this.couponCode = code; }
    public void setPaymentMethod(PaymentMethod pm){ this.paymentMethod = pm; }

    // SAVE: create a memento (snapshot of current state)
    public OrderDraftMemento save() {
        return new OrderDraftMemento(items, shippingAddress, couponCode, paymentMethod);
    }

    // RESTORE: bring back a previous state from a memento
    public void restore(OrderDraftMemento memento) {
        this.items          = new ArrayList<>(memento.getItems());
        this.shippingAddress = memento.getShippingAddress();
        this.couponCode      = memento.getCouponCode();
        this.paymentMethod   = memento.getPaymentMethod();
    }
}

// CARETAKER — stores mementos, never inspects their content
@Service
public class OrderDraftHistory {
    private final Deque<OrderDraftMemento> history = new ArrayDeque<>();
    private static final int MAX_SNAPSHOTS = 10;

    public void save(OrderDraft draft) {
        history.push(draft.save()); // save current state
        if (history.size() > MAX_SNAPSHOTS) history.removeLast(); // cap history
    }

    public void undo(OrderDraft draft) {
        if (history.isEmpty()) return;
        draft.restore(history.pop()); // restore previous state
    }

    // Caretaker can see metadata (savedAt) but not content
    public List<Instant> getHistoryTimestamps() {
        return history.stream().map(OrderDraftMemento::getSavedAt).toList();
    }
}

// SPRING BATCH: uses Memento pattern for checkpoint/restart
// ExecutionContext IS the Memento:
//   - Stores progress state: {"current.line.count": 5000, "last.id": "abc123"}
//   - Persisted to DB after every chunk commit
//   - On restart: Spring reads ExecutionContext, passes to reader — reader resumes from checkpoint
//   - This IS Memento: JobExecution (Caretaker) stores ExecutionContext (Memento)
//     for the Step (Originator) to restore from on restart

@Component
public class CheckpointingItemReader extends AbstractItemStreamItemReader {
    private int currentIndex = 0;

    @Override
    public void open(ExecutionContext ctx) {
        // RESTORE from memento if restarting
        if (ctx.containsKey("reader.index")) {
            currentIndex = ctx.getInt("reader.index"); // restore from checkpoint
            log.info("Resuming from checkpoint: index={}", currentIndex);
        }
    }

    @Override
    public void update(ExecutionContext ctx) {
        // SAVE: take snapshot of current progress after each chunk
        ctx.putInt("reader.index", currentIndex); // caretaker (Spring) persists this
    }

    @Override
    public Order read() {
        return currentIndex < data.size() ? data.get(currentIndex++) : null;
    }
}

// ELEMENT INTERFACE — accept is the hook for double dispatch
public interface OrderElement {
    void accept(OrderVisitor visitor);
}

// CONCRETE ELEMENTS — stable hierarchy, rarely changes
public class OrderItem implements OrderElement {
    private final String     sku;
    private final BigDecimal unitPrice;
    private final int        quantity;
    private final String     category; // electronics, food, clothing...

    @Override
    public void accept(OrderVisitor visitor) {
        visitor.visit(this); // dispatch to visitor.visit(OrderItem) — double dispatch
    }
    // getters...
}

public class ShippingCharge implements OrderElement {
    private final BigDecimal amount;
    private final String     method; // STANDARD, EXPRESS, SAME_DAY

    @Override
    public void accept(OrderVisitor visitor) { visitor.visit(this); }
}

public class Discount implements OrderElement {
    private final BigDecimal amount;
    private final String     type; // COUPON, LOYALTY, SEASONAL

    @Override
    public void accept(OrderVisitor visitor) { visitor.visit(this); }
}

// VISITOR INTERFACE — one visit method per element type
public interface OrderVisitor {
    void visit(OrderItem      item);
    void visit(ShippingCharge charge);
    void visit(Discount       discount);
}

// VISITOR 1: Tax calculator — new operation, zero changes to elements
public class TaxCalculatorVisitor implements OrderVisitor {
    private BigDecimal totalTax = BigDecimal.ZERO;

    @Override
    public void visit(OrderItem item) {
        // Tax rules vary by category
        BigDecimal rate = switch (item.getCategory()) {
            case "electronics" -> BigDecimal.valueOf(0.18); // 18% GST
            case "food"        -> BigDecimal.valueOf(0.05); // 5%
            case "clothing"    -> BigDecimal.valueOf(0.12); // 12%
            default           -> BigDecimal.valueOf(0.0);
        };
        totalTax = totalTax.add(item.getUnitPrice()
            .multiply(BigDecimal.valueOf(item.getQuantity()))
            .multiply(rate));
    }
    @Override
    public void visit(ShippingCharge charge) { /* shipping not taxed */ }
    @Override
    public void visit(Discount discount) { /* discounts reduce taxable base — simplified */ }

    public BigDecimal getTotalTax() { return totalTax; }
}

// VISITOR 2: JSON export — completely different operation, zero element changes
public class JsonExportVisitor implements OrderVisitor {
    private final StringBuilder json = new StringBuilder("[");
    private       boolean        first = true;

    @Override
    public void visit(OrderItem item) {
        comma();
        json.append(String.format("""
            {"type":"item","sku":"%s","price":%s,"qty":%d,"category":"%s"}""",
            item.getSku(), item.getUnitPrice(), item.getQuantity(), item.getCategory()));
    }
    @Override
    public void visit(ShippingCharge c) {
        comma(); json.append(String.format("""{"type":"shipping","amount":%s}""", c.getAmount()));
    }
    @Override
    public void visit(Discount d) {
        comma(); json.append(String.format("""{"type":"discount","amount":%s}""", d.getAmount()));
    }
    public String getJson() { return json.append("]").toString(); }
    private void comma() { if (!first) json.append(","); first = false; }
}

// Usage: same element hierarchy, two completely different operations
Order order = /* ... */;
List<OrderElement> elements = order.getElements(); // items + shipping + discounts

TaxCalculatorVisitor taxVisitor = new TaxCalculatorVisitor();
elements.forEach(e -> e.accept(taxVisitor));
BigDecimal tax = taxVisitor.getTotalTax(); // result of visiting all elements

JsonExportVisitor jsonVisitor = new JsonExportVisitor();
elements.forEach(e -> e.accept(jsonVisitor));
String json = jsonVisitor.getJson(); // completely different result, same elements

// ABSTRACT EXPRESSION — base of the expression hierarchy
public interface RuleExpression {
    boolean interpret(RuleContext context);
    String  describe();
}

// TERMINAL EXPRESSIONS — leaf nodes (no children)

// Terminal: check cart total against a threshold
public class AmountGreaterThan implements RuleExpression {
    private final BigDecimal threshold;
    public AmountGreaterThan(BigDecimal t) { this.threshold = t; }

    @Override
    public boolean interpret(RuleContext ctx) {
        return ctx.getCartTotal().compareTo(threshold) > 0;
    }
    @Override
    public String describe() { return "AMOUNT > " + threshold; }
}

// Terminal: check customer tier
public class CustomerTierEquals implements RuleExpression {
    private final String tier;
    public CustomerTierEquals(String t) { this.tier = t; }

    @Override
    public boolean interpret(RuleContext ctx) {
        return tier.equals(ctx.getCustomerTier());
    }
    @Override
    public String describe() { return "TIER = " + tier; }
}

// Terminal: check category
public class CategoryContains implements RuleExpression {
    private final String category;
    @Override
    public boolean interpret(RuleContext ctx) {
        return ctx.getCategories().contains(category);
    }
    @Override public String describe() { return "CATEGORY = " + category; }
}

// NON-TERMINAL EXPRESSIONS — composites with children

// AND: both children must be true
public class AndExpression implements RuleExpression {
    private final RuleExpression left, right;
    public AndExpression(RuleExpression l, RuleExpression r) { left=l; right=r; }

    @Override
    public boolean interpret(RuleContext ctx) {
        return left.interpret(ctx) && right.interpret(ctx);
    }
    @Override public String describe() { return "(" + left.describe() + " AND " + right.describe() + ")"; }
}

// OR: either child can be true
public class OrExpression implements RuleExpression {
    private final RuleExpression left, right;
    public OrExpression(RuleExpression l, RuleExpression r) { left=l; right=r; }

    @Override
    public boolean interpret(RuleContext ctx) {
        return left.interpret(ctx) || right.interpret(ctx);
    }
    @Override public String describe() { return "(" + left.describe() + " OR " + right.describe() + ")"; }
}

// NOT
public class NotExpression implements RuleExpression {
    private final RuleExpression inner;
    @Override
    public boolean interpret(RuleContext ctx) { return !inner.interpret(ctx); }
    @Override public String describe() { return "NOT(" + inner.describe() + ")"; }
}

// BUILD AND EVALUATE rule expressions
// "(AMOUNT > 5000 AND TIER = GOLD) OR CATEGORY = electronics"
RuleExpression rule = new OrExpression(
    new AndExpression(
        new AmountGreaterThan(BigDecimal.valueOf(5000)),
        new CustomerTierEquals("GOLD")
    ),
    new CategoryContains("electronics")
);
System.out.println(rule.describe()); // prints the expression tree
System.out.println(rule.interpret(ctx)); // true/false evaluation

// SPRING SpEL — the production-grade Interpreter for Spring:
ExpressionParser parser = new SpelExpressionParser();

// 1. Simple math / conditional
Expression expr = parser.parseExpression("2 + 2 == 4 ? 'yes' : 'no'");
String result = (String) expr.getValue(); // "yes"

// 2. Bean property access
Expression orderExpr = parser.parseExpression("order.total > 1000");
StandardEvaluationContext ctx = new StandardEvaluationContext();
ctx.setVariable("order", myOrder);
boolean isHighValue = (Boolean) orderExpr.getValue(ctx);

// 3. @Value injection — Interpreter evaluates at bean initialization
@Value("#{systemProperties['user.home'] + '/logs'}")
private String logDir; // SpEL interpreted at startup

// 4. @PreAuthorize — security expression interpreter
@PreAuthorize("hasRole('ADMIN') and #userId == authentication.principal.id")
public User getUserDetails(@PathVariable UUID userId) { ... }
// SpEL evaluates the expression on every call — double dispatch under the hood

// 5. Spring Cache @Cacheable key generation
@Cacheable(value = "orders", key = "#customerId + '_' + #status")
public List findOrders(UUID customerId, OrderStatus status) { ... }