外观模式：把五个子系统收成一个入口，以及它和适配器、中介者到底差在哪

/** 下单：没有外观时，每个调用点都要自己把这条链路拼一遍 */
OrderResult placeOrder(String userId, String sku, int qty, long amountFen) {
    InventoryService inventory = new InventoryService();
    CouponService coupon = new CouponService();
    PayService pay = new PayService();
    NotifyService notify = new NotifyService();

    if (!inventory.lock(sku, qty)) {
        throw new IllegalStateException("库存不足");
    }
    long discount = coupon.calcDiscount(userId, amountFen);
    long payable = amountFen - discount;
    if (!pay.pay(userId, payable)) {
        inventory.release(sku, qty);          // 补偿逻辑在每个调用点重复一遍
        coupon.refund(userId, discount);
        throw new IllegalStateException("支付失败");
    }
    notify.send(userId, "下单成功");
    return OrderResult.ok(payable);
}

/** 子系统 1：库存 */
class InventoryService {
    boolean lock(String sku, int qty) {
        System.out.println("  [库存] 锁定 " + sku + " × " + qty);
        return true;                                    // 真实场景这里会查库
    }

    void release(String sku, int qty) {
        System.out.println("  [库存] 释放 " + sku + " × " + qty);
    }
}

/** 子系统 2：优惠券 */
class CouponService {
    long calcDiscount(String userId, long amountFen) {
        long discount = amountFen >= 10000 ? 800 : 0;    // 满 100 元减 8 元（单位：分）
        System.out.println("  [优惠券] 抵扣 " + discount + " 分");
        return discount;
    }

    void refund(String userId, long discount) {
        System.out.println("  [优惠券] 退回抵扣 " + discount + " 分");
    }
}

/** 子系统 3：支付 */
class PayService {
    boolean pay(String userId, long amountFen) {
        System.out.println("  [支付] 扣款 " + amountFen + " 分");
        return true;
    }

    void refund(String userId, long amountFen) {
        System.out.println("  [支付] 退款 " + amountFen + " 分");
    }
}

/** 子系统 4：通知 */
class NotifyService {
    void send(String userId, String msg) {
        System.out.println("  [通知] " + userId + " ← " + msg);
    }
}

/** 结果对象：外观的返回值应该是一个「业务结果」，而不是一堆子系统的返回值 */
class OrderResult {
    final boolean success;
    final long payable;
    final String reason;

    private OrderResult(boolean success, long payable, String reason) {
        this.success = success;
        this.payable = payable;
        this.reason = reason;
    }

    static OrderResult ok(long payable) {
        return new OrderResult(true, payable, "OK");
    }

    static OrderResult fail(String reason) {
        return new OrderResult(false, 0L, reason);
    }

    @Override
    public String toString() {
        return success ? ("成功，实付 " + payable + " 分") : ("失败：" + reason);
    }
}

/** 外观：把「下单」这条链路收成一个方法 */
class OrderFacade {
    private final InventoryService inventory = new InventoryService();
    private final CouponService coupon = new CouponService();
    private final PayService pay = new PayService();
    private final NotifyService notify = new NotifyService();

    OrderResult placeOrder(String userId, String sku, int qty, long amountFen) {
        if (!inventory.lock(sku, qty)) {
            return OrderResult.fail("库存不足");
        }
        long discount = coupon.calcDiscount(userId, amountFen);
        long payable = amountFen - discount;

        if (!pay.pay(userId, payable)) {
            inventory.release(sku, qty);                 // 补偿逻辑只写在这里一处
            coupon.refund(userId, discount);
            return OrderResult.fail("支付失败");
        }
        notify.send(userId, "下单成功，实付 " + payable + " 分");
        return OrderResult.ok(payable);
    }
}

public class FacadeDemo {
    public static void main(String[] args) {
        OrderFacade facade = new OrderFacade();

        // 调用方：一行完成下单，内部 4 个子系统 + 补偿逻辑全都藏起来了
        System.out.println("下单：" + facade.placeOrder("u-1001", "SKU-9", 2, 12000L));
    }
}

  [库存] 锁定 SKU-9 × 2
  [优惠券] 抵扣 800 分
  [支付] 扣款 11200 分
  [通知] u-1001 ← 下单成功，实付 11200 分
下单：成功，实付 11200 分

// ✗ 反例：一个「万能外观」包住所有子系统的所有方法
class SystemFacade {
    void placeOrder()  { /* ... */ }
    void refund()      { /* ... */ }
    void addCoupon()   { /* ... */ }
    void queryStock()  { /* ... */ }
    void exportStock() { /* ... */ }
    void sendSms()     { /* ... */ }
    // …… 二十个方法，谁都往里加
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PayService {
    // 只认识门面：LoggerFactory，不认识任何具体日志实现
    private static final Logger log = LoggerFactory.getLogger(PayService.class);

    public void pay(String userId, long amountFen) {
        log.info("扣款成功 userId={} amount={}", userId, amountFen);
    }
}

/** 下单门面：只关心「下单」这条链路（完整实现见第三节） */
class OrderFacade {
    private final InventoryService inventory = new InventoryService();
    private final CouponService coupon = new CouponService();
    private final PayService pay = new PayService();
    private final NotifyService notify = new NotifyService();

    OrderResult placeOrder(String userId, String sku, int qty, long amountFen) {
        // 完整实现见第三节
        throw new UnsupportedOperationException("完整实现见第三节");
    }
}

/** 退款门面：只关心「退款」这条链路，复用同样的子系统 */
class RefundFacade {
    private final InventoryService inventory = new InventoryService();
    private final PayService pay = new PayService();
    private final NotifyService notify = new NotifyService();

    void refund(String userId, String orderNo, String sku, int qty, long amountFen) {
        pay.refund(userId, amountFen);
        inventory.release(sku, qty);
        notify.send(userId, "订单 " + orderNo + " 已退款");
    }
}