// === サブシステム群 ===
 
class Projector {
  on(): void { console.log("Projector: ON"); }
  off(): void { console.log("Projector: OFF"); }
  setInput(src: string): void { console.log(`Projector: Input set to ${src}`); }
  setResolution(res: string): void { console.log(`Projector: Resolution ${res}`); }
}
 
class AudioSystem {
  on(): void { console.log("Audio: ON"); }
  off(): void { console.log("Audio: OFF"); }
  setVolume(v: number): void { console.log(`Audio: Volume ${v}`); }
  setSurround(): void { console.log("Audio: Surround mode enabled"); }
  setStereo(): void { console.log("Audio: Stereo mode enabled"); }
}
 
class StreamingPlayer {
  on(): void { console.log("Player: ON"); }
  off(): void { console.log("Player: OFF"); }
  play(movie: string): void { console.log(`Player: Playing "${movie}"`); }
  pause(): void { console.log("Player: Paused"); }
  stop(): void { console.log("Player: Stopped"); }
}
 
class Lights {
  on(): void { console.log("Lights: ON (100%)"); }
  off(): void { console.log("Lights: OFF"); }
  dim(level: number): void { console.log(`Lights: Dimmed to ${level}%`); }
}
 
class Screen {
  down(): void { console.log("Screen: Lowered"); }
  up(): void { console.log("Screen: Raised"); }
}
 
// === Facade ===
 
class HomeTheaterFacade {
  constructor(
    private projector: Projector,
    private audio: AudioSystem,
    private player: StreamingPlayer,
    private lights: Lights,
    private screen: Screen,
  ) {}
 
  /** 映画鑑賞モード: 6つのサブシステムを正しい順序で操作 */
  watchMovie(movie: string): void {
    console.log("=== Setting up movie mode ===");
    this.lights.dim(10);
    this.screen.down();
    this.projector.on();
    this.projector.setInput("HDMI1");
    this.projector.setResolution("4K");
    this.audio.on();
    this.audio.setSurround();
    this.audio.setVolume(50);
    this.player.on();
    this.player.play(movie);
    console.log("=== Enjoy your movie! ===");
  }
 
  /** 映画終了: 全サブシステムを正しい順序でシャットダウン */
  endMovie(): void {
    console.log("=== Shutting down ===");
    this.player.stop();
    this.player.off();
    this.audio.off();
    this.projector.off();
    this.screen.up();
    this.lights.on();
    console.log("=== Done ===");
  }
 
  /** 音楽モード: 映像不要、ステレオ音声 */
  listenToMusic(): void {
    console.log("=== Setting up music mode ===");
    this.lights.dim(40);
    this.audio.on();
    this.audio.setStereo();
    this.audio.setVolume(30);
  }
}
 
// === 使用例 ===
 
const theater = new HomeTheaterFacade(
  new Projector(),
  new AudioSystem(),
  new StreamingPlayer(),
  new Lights(),
  new Screen(),
);
 
// クライアントは 1 メソッドを呼ぶだけ
theater.watchMovie("Inception");
// 出力:
// === Setting up movie mode ===
// Lights: Dimmed to 10%
// Screen: Lowered
// Projector: ON
// Projector: Input set to HDMI1
// Projector: Resolution 4K
// Audio: ON
// Audio: Surround mode enabled
// Audio: Volume 50
// Player: ON
// Player: Playing "Inception"
// === Enjoy your movie! ===
 
theater.endMovie();

// === サブシステム群 ===
 
interface DeployResult {
  version: string;
  url: string;
  timestamp: Date;
}
 
class GitService {
  pull(branch: string): void {
    console.log(`Git: Pulling ${branch}`);
  }
  tag(version: string): void {
    console.log(`Git: Tagged ${version}`);
  }
  getLatestCommit(): string {
    return "abc1234";
  }
}
 
class BuildService {
  install(): void {
    console.log("Build: Installing dependencies");
  }
  lint(): void {
    console.log("Build: Linting code");
  }
  test(): void {
    console.log("Build: Running tests");
  }
  build(): string {
    console.log("Build: Creating production build");
    return "dist/app.tar.gz";
  }
}
 
class DeployService {
  upload(artifact: string, env: string): string {
    console.log(`Deploy: Uploading ${artifact} to ${env}`);
    return `https://${env}.example.com`;
  }
  activate(version: string): void {
    console.log(`Deploy: Activating version ${version}`);
  }
  healthCheck(url: string): boolean {
    console.log(`Deploy: Health check on ${url}`);
    return true;
  }
  rollback(version: string): void {
    console.log(`Deploy: Rolling back to ${version}`);
  }
}
 
class NotifyService {
  sendSlack(channel: string, msg: string): void {
    console.log(`Slack [${channel}]: ${msg}`);
  }
  sendEmail(to: string, subject: string): void {
    console.log(`Email to ${to}: ${subject}`);
  }
}
 
// === Facade ===
 
class DeployFacade {
  constructor(
    private git: GitService,
    private build: BuildService,
    private deploy: DeployService,
    private notify: NotifyService,
  ) {}
 
  /** 本番リリース: 全ステップを自動実行 */
  async release(version: string): Promise<DeployResult> {
    try {
      // 1. ソースコード取得
      this.git.pull("main");
 
      // 2. ビルドパイプライン
      this.build.install();
      this.build.lint();
      this.build.test();
      const artifact = this.build.build();
 
      // 3. デプロイ
      const url = this.deploy.upload(artifact, "production");
      this.deploy.activate(version);
 
      // 4. ヘルスチェック
      const healthy = this.deploy.healthCheck(url);
      if (!healthy) {
        this.deploy.rollback(version);
        throw new Error(`Health check failed for ${version}`);
      }
 
      // 5. 完了処理
      this.git.tag(version);
      this.notify.sendSlack("#deploys", `v${version} deployed to ${url}`);
      this.notify.sendEmail("team@example.com", `Release v${version} complete`);
 
      return { version, url, timestamp: new Date() };
    } catch (error) {
      this.notify.sendSlack("#alerts", `Deploy v${version} FAILED: ${error}`);
      throw error;
    }
  }
 
  /** ステージング環境へのデプロイ（テスト・通知なし） */
  async deployToStaging(branch: string): Promise<string> {
    this.git.pull(branch);
    this.build.install();
    const artifact = this.build.build();
    return this.deploy.upload(artifact, "staging");
  }
}
 
// === 使用例 ===
 
const pipeline = new DeployFacade(
  new GitService(),
  new BuildService(),
  new DeployService(),
  new NotifyService(),
);
 
await pipeline.release("1.2.0");

from dataclasses import dataclass
from typing import Any
import json
import csv
import io
 
 
# === サブシステム群 ===
 
class DataLoader:
    """様々な形式のデータを読み込む"""
    def load_csv(self, path: str) -> list[dict]:
        print(f"DataLoader: Loading CSV from {path}")
        # 実際の実装では csv.DictReader を使用
        return [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]
 
    def load_json(self, path: str) -> list[dict]:
        print(f"DataLoader: Loading JSON from {path}")
        return [{"name": "Charlie", "score": 85}]
 
    def load_database(self, query: str) -> list[dict]:
        print(f"DataLoader: Executing query: {query}")
        return [{"id": 1, "value": 100}]
 
 
class DataCleaner:
    """データのクレンジング・正規化"""
    def remove_nulls(self, data: list[dict]) -> list[dict]:
        print(f"DataCleaner: Removing nulls from {len(data)} records")
        return [row for row in data if all(v is not None for v in row.values())]
 
    def normalize(self, data: list[dict], columns: list[str]) -> list[dict]:
        print(f"DataCleaner: Normalizing columns {columns}")
        return data  # 実際は正規化処理
 
    def deduplicate(self, data: list[dict], key: str) -> list[dict]:
        print(f"DataCleaner: Deduplicating by {key}")
        seen = set()
        result = []
        for row in data:
            if row[key] not in seen:
                seen.add(row[key])
                result.append(row)
        return result
 
 
class DataAnalyzer:
    """統計分析・集計"""
    def aggregate(self, data: list[dict], column: str) -> dict:
        print(f"DataAnalyzer: Aggregating column '{column}'")
        values = [row.get(column, 0) for row in data]
        return {
            "count": len(values),
            "sum": sum(values),
            "avg": sum(values) / max(len(values), 1),
            "min": min(values, default=0),
            "max": max(values, default=0),
        }
 
    def group_by(self, data: list[dict], key: str) -> dict[str, list[dict]]:
        print(f"DataAnalyzer: Grouping by '{key}'")
        groups: dict[str, list[dict]] = {}
        for row in data:
            k = str(row.get(key, "unknown"))
            groups.setdefault(k, []).append(row)
        return groups
 
 
class ReportGenerator:
    """レポート生成"""
    def generate_summary(self, stats: dict) -> str:
        print("ReportGenerator: Generating summary report")
        return json.dumps(stats, indent=2)
 
    def generate_csv(self, data: list[dict]) -> str:
        print("ReportGenerator: Generating CSV report")
        if not data:
            return ""
        output = io.StringIO()
        writer = csv.DictWriter(output, fieldnames=data[0].keys())
        writer.writeheader()
        writer.writerows(data)
        return output.getvalue()
 
 
# === Facade ===
 
@dataclass
class AnalysisResult:
    raw_count: int
    clean_count: int
    stats: dict
    report: str
 
 
class DataPipelineFacade:
    """データ分析パイプラインの統一インタフェース"""
 
    def __init__(
        self,
        loader: DataLoader,
        cleaner: DataCleaner,
        analyzer: DataAnalyzer,
        reporter: ReportGenerator,
    ):
        self._loader = loader
        self._cleaner = cleaner
        self._analyzer = analyzer
        self._reporter = reporter
 
    def analyze_csv(
        self,
        path: str,
        target_column: str,
        dedup_key: str | None = None,
    ) -> AnalysisResult:
        """CSV ファイルを読み込み、クレンジング・分析・レポート生成を一括実行"""
        # 1. データ読み込み
        data = self._loader.load_csv(path)
        raw_count = len(data)
 
        # 2. クレンジング
        data = self._cleaner.remove_nulls(data)
        if dedup_key:
            data = self._cleaner.deduplicate(data, dedup_key)
        clean_count = len(data)
 
        # 3. 分析
        stats = self._analyzer.aggregate(data, target_column)
 
        # 4. レポート生成
        report = self._reporter.generate_summary(stats)
 
        return AnalysisResult(
            raw_count=raw_count,
            clean_count=clean_count,
            stats=stats,
            report=report,
        )
 
    def quick_summary(self, path: str, column: str) -> dict:
        """クレンジングなしの簡易集計"""
        data = self._loader.load_csv(path)
        return self._analyzer.aggregate(data, column)
 
 
# === 使用例 ===
 
pipeline = DataPipelineFacade(
    loader=DataLoader(),
    cleaner=DataCleaner(),
    analyzer=DataAnalyzer(),
    reporter=ReportGenerator(),
)
 
result = pipeline.analyze_csv("sales.csv", target_column="age", dedup_key="name")
print(f"Raw: {result.raw_count}, Clean: {result.clean_count}")
print(result.report)
# 出力:
# DataLoader: Loading CSV from sales.csv
# DataCleaner: Removing nulls from 2 records
# DataCleaner: Deduplicating by name
# DataAnalyzer: Aggregating column 'age'
# ReportGenerator: Generating summary report
# Raw: 2, Clean: 2
# {
#   "count": 2,
#   "sum": 55,
#   "avg": 27.5,
#   "min": 25,
#   "max": 30
# }

// === サブシステム群 ===
 
class SmtpClient {
    public void connect(String host, int port) {
        System.out.println("SMTP: Connected to " + host + ":" + port);
    }
    public void authenticate(String user, String pass) {
        System.out.println("SMTP: Authenticated as " + user);
    }
    public void send(String from, String to, String raw) {
        System.out.println("SMTP: Sent from " + from + " to " + to);
    }
    public void disconnect() {
        System.out.println("SMTP: Disconnected");
    }
}
 
class MimeBuilder {
    private String subject = "";
    private String textBody = "";
    private String htmlBody = "";
    private final List<String> attachments = new ArrayList<>();
 
    public void setSubject(String subject) { this.subject = subject; }
    public void setTextBody(String body) { this.textBody = body; }
    public void setHtmlBody(String html) { this.htmlBody = html; }
    public void addAttachment(String path) { attachments.add(path); }
 
    public String build() {
        System.out.println("MIME: Building message (subject=" + subject
            + ", attachments=" + attachments.size() + ")");
        return "MIME-Version: 1.0\nSubject: " + subject + "\n\n" + textBody;
    }
}
 
class TemplateEngine {
    public String render(String templateName, Map<String, Object> vars) {
        System.out.println("Template: Rendering " + templateName);
        // 実際はテンプレートファイルを読み込み、変数を埋め込む
        return "<html><body>Hello " + vars.getOrDefault("name", "User") + "</body></html>";
    }
}
 
class AddressValidator {
    public boolean validate(String email) {
        boolean valid = email != null && email.contains("@");
        System.out.println("Validator: " + email + " -> " + (valid ? "OK" : "INVALID"));
        return valid;
    }
}
 
// === Facade ===
 
class EmailFacade {
    private final SmtpClient smtp;
    private final MimeBuilder mime;
    private final TemplateEngine templates;
    private final AddressValidator validator;
    private final String smtpHost;
    private final int smtpPort;
    private final String smtpUser;
    private final String smtpPass;
 
    public EmailFacade(String host, int port, String user, String pass) {
        this.smtp = new SmtpClient();
        this.mime = new MimeBuilder();
        this.templates = new TemplateEngine();
        this.validator = new AddressValidator();
        this.smtpHost = host;
        this.smtpPort = port;
        this.smtpUser = user;
        this.smtpPass = pass;
    }
 
    /** テンプレートを使ったメール送信（最も一般的なユースケース） */
    public void sendTemplated(
        String from, String to,
        String templateName, Map<String, Object> vars
    ) {
        if (!validator.validate(to)) {
            throw new IllegalArgumentException("Invalid email: " + to);
        }
 
        String html = templates.render(templateName, vars);
 
        mime.setSubject((String) vars.getOrDefault("subject", "No Subject"));
        mime.setHtmlBody(html);
        String raw = mime.build();
 
        smtp.connect(smtpHost, smtpPort);
        try {
            smtp.authenticate(smtpUser, smtpPass);
            smtp.send(from, to, raw);
        } finally {
            smtp.disconnect();
        }
    }
 
    /** プレーンテキストメールの簡易送信 */
    public void sendPlain(String from, String to, String subject, String body) {
        if (!validator.validate(to)) {
            throw new IllegalArgumentException("Invalid email: " + to);
        }
 
        mime.setSubject(subject);
        mime.setTextBody(body);
        String raw = mime.build();
 
        smtp.connect(smtpHost, smtpPort);
        try {
            smtp.authenticate(smtpUser, smtpPass);
            smtp.send(from, to, raw);
        } finally {
            smtp.disconnect();
        }
    }
}
 
// === 使用例 ===
 
EmailFacade email = new EmailFacade("smtp.example.com", 587, "user", "pass");
 
email.sendTemplated(
    "noreply@example.com",
    "user@example.com",
    "welcome",
    Map.of("name", "Taro", "subject", "Welcome!")
);
// 出力:
// Validator: user@example.com -> OK
// Template: Rendering welcome
// MIME: Building message (subject=Welcome!, attachments=0)
// SMTP: Connected to smtp.example.com:587
// SMTP: Authenticated as user
// SMTP: Sent from noreply@example.com to user@example.com
// SMTP: Disconnected

package main
 
import (
    "fmt"
    "log"
    "net/http"
    "time"
)
 
// === サブシステム群 ===
 
type Router struct {
    routes map[string]http.HandlerFunc
}
 
func NewRouter() *Router {
    return &Router{routes: make(map[string]http.HandlerFunc)}
}
 
func (r *Router) AddRoute(path string, handler http.HandlerFunc) {
    r.routes[path] = handler
    fmt.Printf("Router: Added route %s\n", path)
}
 
func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    if handler, ok := r.routes[req.URL.Path]; ok {
        handler(w, req)
    } else {
        http.NotFound(w, req)
    }
}
 
type Middleware struct {
    handlers []func(http.Handler) http.Handler
}
 
func NewMiddleware() *Middleware {
    return &Middleware{}
}
 
func (m *Middleware) Use(mw func(http.Handler) http.Handler) {
    m.handlers = append(m.handlers, mw)
    fmt.Println("Middleware: Added middleware")
}
 
func (m *Middleware) Apply(handler http.Handler) http.Handler {
    for i := len(m.handlers) - 1; i >= 0; i-- {
        handler = m.handlersi
    }
    return handler
}
 
type CORSConfig struct {
    AllowOrigins []string
    AllowMethods []string
}
 
func (c *CORSConfig) Apply(next http.Handler) http.Handler {
    fmt.Println("CORS: Configured")
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Access-Control-Allow-Origin", "*")
        next.ServeHTTP(w, r)
    })
}
 
type GracefulShutdown struct {
    server *http.Server
}
 
func NewGracefulShutdown(addr string, handler http.Handler) *GracefulShutdown {
    return &GracefulShutdown{
        server: &http.Server{
            Addr:         addr,
            Handler:      handler,
            ReadTimeout:  10 * time.Second,
            WriteTimeout: 10 * time.Second,
        },
    }
}
 
func (g *GracefulShutdown) Start() error {
    fmt.Printf("Server: Listening on %s\n", g.server.Addr)
    return g.server.ListenAndServe()
}
 
// === Facade ===
 
type ServerFacade struct {
    router     *Router
    middleware *Middleware
    cors       *CORSConfig
    addr       string
}
 
func NewServerFacade(addr string) *ServerFacade {
    return &ServerFacade{
        router:     NewRouter(),
        middleware: NewMiddleware(),
        cors:       &CORSConfig{},
        addr:       addr,
    }
}
 
// GET ルートを追加
func (s *ServerFacade) GET(path string, handler http.HandlerFunc) {
    s.router.AddRoute(path, handler)
}
 
// ミドルウェアを追加
func (s *ServerFacade) Use(mw func(http.Handler) http.Handler) {
    s.middleware.Use(mw)
}
 
// サーバー起動（CORS・ミドルウェア・グレースフルシャットダウンを自動設定）
func (s *ServerFacade) Start() error {
    var handler http.Handler = s.router
    handler = s.cors.Apply(handler)
    handler = s.middleware.Apply(handler)
 
    gs := NewGracefulShutdown(s.addr, handler)
    return gs.Start()
}
 
// === 使用例 ===
 
func main() {
    app := NewServerFacade(":8080")
 
    // ロギングミドルウェア
    app.Use(func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            log.Printf("%s %s", r.Method, r.URL.Path)
            next.ServeHTTP(w, r)
        })
    })
 
    app.GET("/health", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("OK"))
    })
 
    // Router, Middleware, CORS, GracefulShutdown を意識せずに起動
    app.Start()
}

import { useState, useEffect, useCallback, useMemo } from "react";
 
// === サブシステム（個別の Hook） ===
 
function useCart() {
  const [items, setItems] = useState<CartItem[]>([]);
 
  const addItem = useCallback((item: CartItem) => {
    setItems(prev => [...prev, item]);
  }, []);
 
  const removeItem = useCallback((id: string) => {
    setItems(prev => prev.filter(item => item.id !== id));
  }, []);
 
  const clear = useCallback(() => setItems([]), []);
 
  const total = useMemo(
    () => items.reduce((sum, item) => sum + item.price * item.quantity, 0),
    [items],
  );
 
  return { items, addItem, removeItem, clear, total };
}
 
function usePayment() {
  const [processing, setProcessing] = useState(false);
  const [error, setError] = useState<string | null>(null);
 
  const charge = useCallback(async (amount: number, method: string) => {
    setProcessing(true);
    setError(null);
    try {
      const res = await fetch("/api/payment", {
        method: "POST",
        body: JSON.stringify({ amount, method }),
      });
      if (!res.ok) throw new Error("Payment failed");
      return await res.json();
    } catch (e) {
      setError((e as Error).message);
      throw e;
    } finally {
      setProcessing(false);
    }
  }, []);
 
  return { charge, processing, error };
}
 
function useShipping() {
  const [address, setAddress] = useState<Address | null>(null);
  const [cost, setCost] = useState(0);
 
  const calculate = useCallback(async (items: CartItem[], addr: Address) => {
    const res = await fetch("/api/shipping/calculate", {
      method: "POST",
      body: JSON.stringify({ items, address: addr }),
    });
    const data = await res.json();
    setCost(data.cost);
    return data.cost;
  }, []);
 
  return { address, setAddress, cost, calculate };
}
 
function useCoupon() {
  const [code, setCode] = useState("");
  const [discount, setDiscount] = useState(0);
 
  const apply = useCallback(async (couponCode: string) => {
    const res = await fetch(`/api/coupons/${couponCode}`);
    if (!res.ok) throw new Error("Invalid coupon");
    const data = await res.json();
    setCode(couponCode);
    setDiscount(data.discount);
    return data.discount;
  }, []);
 
  return { code, discount, apply, setCode };
}
 
// === Facade Hook ===
 
interface CartItem {
  id: string;
  name: string;
  price: number;
  quantity: number;
}
 
interface Address {
  zip: string;
  city: string;
  line1: string;
}
 
interface CheckoutState {
  // カート
  items: CartItem[];
  addItem: (item: CartItem) => void;
  removeItem: (id: string) => void;
  // 金額
  subtotal: number;
  shippingCost: number;
  discount: number;
  total: number;
  // アクション
  applyCoupon: (code: string) => Promise<void>;
  setShippingAddress: (addr: Address) => Promise<void>;
  checkout: (paymentMethod: string) => Promise<void>;
  // 状態
  isProcessing: boolean;
  error: string | null;
  step: "cart" | "shipping" | "payment" | "complete";
}
 
function useCheckout(): CheckoutState {
  const cart = useCart();
  const payment = usePayment();
  const shipping = useShipping();
  const coupon = useCoupon();
  const [step, setStep] = useState<CheckoutState["step"]>("cart");
 
  const total = useMemo(
    () => Math.max(0, cart.total + shipping.cost - coupon.discount),
    [cart.total, shipping.cost, coupon.discount],
  );
 
  const applyCoupon = useCallback(async (code: string) => {
    await coupon.apply(code);
  }, [coupon]);
 
  const setShippingAddress = useCallback(async (addr: Address) => {
    shipping.setAddress(addr);
    await shipping.calculate(cart.items, addr);
    setStep("shipping");
  }, [cart.items, shipping]);
 
  const checkout = useCallback(async (paymentMethod: string) => {
    setStep("payment");
    await payment.charge(total, paymentMethod);
    cart.clear();
    setStep("complete");
  }, [total, payment, cart]);
 
  return {
    items: cart.items,
    addItem: cart.addItem,
    removeItem: cart.removeItem,
    subtotal: cart.total,
    shippingCost: shipping.cost,
    discount: coupon.discount,
    total,
    applyCoupon,
    setShippingAddress,
    checkout,
    isProcessing: payment.processing,
    error: payment.error,
    step,
  };
}
 
// === コンポーネントはシンプルに ===
 
function CheckoutPage() {
  const {
    items, subtotal, shippingCost, discount, total,
    checkout, isProcessing, error, step,
  } = useCheckout();
 
  if (step === "complete") return <div>Thank you!</div>;
 
  return (
    <div>
      <h2>Checkout ({items.length} items)</h2>
      <p>Subtotal: ${subtotal}</p>
      <p>Shipping: ${shippingCost}</p>
      <p>Discount: -${discount}</p>
      <p>Total: ${total}</p>
      {error && <p style={{ color: "red" }}>{error}</p>}
      <button onClick={() => checkout("credit_card")} disabled={isProcessing}>
        {isProcessing ? "Processing..." : "Pay Now"}
      </button>
    </div>
  );
}

// === サブシステム群 ===
 
class HttpClient {
    fun get(url: String, headers: Map<String, String> = emptyMap()): String {
        println("HTTP: GET $url")
        return """{"status": "ok"}"""
    }
 
    fun post(url: String, body: String, headers: Map<String, String> = emptyMap()): String {
        println("HTTP: POST $url body=$body")
        return """{"id": 1}"""
    }
}
 
class JsonParser {
    fun <T> parse(json: String, clazz: Class<T>): T {
        println("JSON: Parsing ${json.take(50)}...")
        @Suppress("UNCHECKED_CAST")
        return mapOf("status" to "ok") as T
    }
 
    fun toJson(obj: Any): String {
        println("JSON: Serializing $obj")
        return """{"serialized": true}"""
    }
}
 
class TokenManager {
    private var token: String? = null
 
    fun getToken(): String {
        return token ?: throw IllegalStateException("Not authenticated")
    }
 
    fun setToken(newToken: String) {
        token = newToken
        println("Token: Stored new token")
    }
 
    fun isAuthenticated(): Boolean = token != null
 
    fun clearToken() {
        token = null
        println("Token: Cleared")
    }
}
 
class CacheManager {
    private val cache = mutableMapOf<String, Pair<String, Long>>()
    private val ttl = 60_000L // 1分
 
    fun get(key: String): String? {
        val entry = cache[key] ?: return null
        if (System.currentTimeMillis() - entry.second > ttl) {
            cache.remove(key)
            return null
        }
        println("Cache: HIT for $key")
        return entry.first
    }
 
    fun put(key: String, value: String) {
        cache[key] = value to System.currentTimeMillis()
        println("Cache: Stored $key")
    }
}
 
// === Facade ===
 
class ApiClient(
    private val http: HttpClient = HttpClient(),
    private val json: JsonParser = JsonParser(),
    private val auth: TokenManager = TokenManager(),
    private val cache: CacheManager = CacheManager(),
    private val baseUrl: String = "https://api.example.com",
) {
    /** 認証ヘッダー付き GET（キャッシュあり） */
    fun <T> get(path: String, clazz: Class<T>, useCache: Boolean = true): T {
        val url = "$baseUrl$path"
 
        if (useCache) {
            cache.get(url)?.let { return json.parse(it, clazz) }
        }
 
        val headers = mapOf("Authorization" to "Bearer ${auth.getToken()}")
        val response = http.get(url, headers)
 
        if (useCache) cache.put(url, response)
        return json.parse(response, clazz)
    }
 
    /** 認証ヘッダー付き POST */
    fun <T> post(path: String, body: Any, clazz: Class<T>): T {
        val url = "$baseUrl$path"
        val headers = mapOf("Authorization" to "Bearer ${auth.getToken()}")
        val jsonBody = json.toJson(body)
        val response = http.post(url, jsonBody, headers)
        return json.parse(response, clazz)
    }
 
    /** ログイン（トークン取得・保存） */
    fun login(username: String, password: String) {
        val body = json.toJson(mapOf("username" to username, "password" to password))
        val response = http.post("$baseUrl/auth/login", body)
        val result = json.parse(response, Map::class.java)
        auth.setToken(result["token"] as? String ?: "dummy-token")
    }
 
    /** ログアウト */
    fun logout() {
        auth.clearToken()
    }
}
 
// === 使用例 ===
 
fun main() {
    val api = ApiClient()
    api.login("user", "pass")
    val result = api.get("/users/me", Map::class.java)
    println("Result: $result")
}

// === 内部モジュール群 ===
// internal/parser.ts
class Parser {
  parse(source: string): ASTNode {
    console.log("Parser: Parsing source code");
    return { type: "program", body: [] };
  }
}
 
// internal/validator.ts
class Validator {
  validate(ast: ASTNode): ValidationResult {
    console.log("Validator: Validating AST");
    return { valid: true, errors: [] };
  }
}
 
// internal/optimizer.ts
class Optimizer {
  optimize(ast: ASTNode): ASTNode {
    console.log("Optimizer: Optimizing AST");
    return ast;
  }
}
 
// internal/transformer.ts
class Transformer {
  transform(ast: ASTNode): IRNode {
    console.log("Transformer: Transforming to IR");
    return { type: "module", instructions: [] };
  }
}
 
// internal/emitter.ts
class Emitter {
  emit(ir: IRNode): string {
    console.log("Emitter: Generating output");
    return "compiled output";
  }
}
 
// === 型定義 ===
interface ASTNode {
  type: string;
  body: ASTNode[];
}
 
interface ValidationResult {
  valid: boolean;
  errors: string[];
}
 
interface IRNode {
  type: string;
  instructions: unknown[];
}
 
interface CompileOptions {
  optimize?: boolean;
  validate?: boolean;
  sourceMaps?: boolean;
}
 
interface CompileResult {
  code: string;
  ast?: ASTNode;
  errors: string[];
}
 
// === Facade (index.ts) ===
 
/**
 * コンパイラの公開 API。
 * 内部の Parser, Validator, Optimizer, Transformer, Emitter を隠蔽する。
 */
export function compile(
  source: string,
  options: CompileOptions = {},
): CompileResult {
  const { optimize = true, validate = true } = options;
 
  // 1. パース
  const parser = new Parser();
  const ast = parser.parse(source);
 
  // 2. バリデーション（オプション）
  if (validate) {
    const validator = new Validator();
    const result = validator.validate(ast);
    if (!result.valid) {
      return { code: "", errors: result.errors };
    }
  }
 
  // 3. 最適化（オプション）
  let optimizedAst = ast;
  if (optimize) {
    const optimizer = new Optimizer();
    optimizedAst = optimizer.optimize(ast);
  }
 
  // 4. 変換
  const transformer = new Transformer();
  const ir = transformer.transform(optimizedAst);
 
  // 5. 出力
  const emitter = new Emitter();
  const code = emitter.emit(ir);
 
  return { code, ast, errors: [] };
}
 
// === 使用例 ===
// 利用側は内部を知る必要がない
// import { compile } from "my-compiler";
 
const result = compile("const x = 1 + 2;");
console.log(result.code);
 
const resultNoOptimize = compile("const x = 1 + 2;", { optimize: false });

from typing import Any, TypeVar, Generic
from dataclasses import dataclass, field
from datetime import datetime
 
 
# === サブシステム群 ===
 
class ConnectionPool:
    """データベース接続プール"""
    _instance = None
 
    def __init__(self, dsn: str, pool_size: int = 5):
        self.dsn = dsn
        self.pool_size = pool_size
        print(f"ConnectionPool: Created (dsn={dsn}, size={pool_size})")
 
    def acquire(self) -> "Connection":
        print("ConnectionPool: Connection acquired")
        return Connection()
 
    def release(self, conn: "Connection") -> None:
        print("ConnectionPool: Connection released")
 
 
class Connection:
    """データベース接続"""
    def execute(self, sql: str, params: tuple = ()) -> list[dict]:
        print(f"Connection: {sql} params={params}")
        return [{"id": 1}]  # ダミー結果
 
    def begin(self) -> None:
        print("Connection: BEGIN")
 
    def commit(self) -> None:
        print("Connection: COMMIT")
 
    def rollback(self) -> None:
        print("Connection: ROLLBACK")
 
 
class QueryBuilder:
    """SQL クエリビルダー"""
    def __init__(self, table: str):
        self._table = table
        self._conditions: list[str] = []
        self._params: list[Any] = []
        self._order: str | None = None
        self._limit: int | None = None
 
    def where(self, condition: str, *params: Any) -> "QueryBuilder":
        self._conditions.append(condition)
        self._params.extend(params)
        return self
 
    def order_by(self, column: str, desc: bool = False) -> "QueryBuilder":
        direction = "DESC" if desc else "ASC"
        self._order = f"{column} {direction}"
        return self
 
    def limit(self, n: int) -> "QueryBuilder":
        self._limit = n
        return self
 
    def build_select(self) -> tuple[str, tuple]:
        sql = f"SELECT * FROM {self._table}"
        if self._conditions:
            sql += " WHERE " + " AND ".join(self._conditions)
        if self._order:
            sql += f" ORDER BY {self._order}"
        if self._limit:
            sql += f" LIMIT {self._limit}"
        return sql, tuple(self._params)
 
    def build_insert(self, data: dict) -> tuple[str, tuple]:
        cols = ", ".join(data.keys())
        placeholders = ", ".join(["?"] * len(data))
        sql = f"INSERT INTO {self._table} ({cols}) VALUES ({placeholders})"
        return sql, tuple(data.values())
 
    def build_delete(self) -> tuple[str, tuple]:
        sql = f"DELETE FROM {self._table}"
        if self._conditions:
            sql += " WHERE " + " AND ".join(self._conditions)
        return sql, tuple(self._params)
 
 
class Migrator:
    """スキーママイグレーション"""
    def create_table(self, name: str, columns: dict[str, str]) -> str:
        cols = ", ".join(f"{k} {v}" for k, v in columns.items())
        return f"CREATE TABLE IF NOT EXISTS {name} ({cols})"
 
 
# === Facade ===
 
T = TypeVar("T")
 
 
class DatabaseFacade:
    """データベース操作の統一インタフェース"""
 
    def __init__(self, dsn: str):
        self._pool = ConnectionPool(dsn)
        self._migrator = Migrator()
 
    def find(
        self,
        table: str,
        conditions: dict[str, Any] | None = None,
        order_by: str | None = None,
        limit: int | None = None,
    ) -> list[dict]:
        """条件検索（SELECT）"""
        qb = QueryBuilder(table)
        if conditions:
            for col, val in conditions.items():
                qb.where(f"{col} = ?", val)
        if order_by:
            desc = order_by.startswith("-")
            col = order_by.lstrip("-")
            qb.order_by(col, desc=desc)
        if limit:
            qb.limit(limit)
 
        sql, params = qb.build_select()
        conn = self._pool.acquire()
        try:
            return conn.execute(sql, params)
        finally:
            self._pool.release(conn)
 
    def insert(self, table: str, data: dict) -> dict:
        """レコード挿入（INSERT）"""
        qb = QueryBuilder(table)
        sql, params = qb.build_insert(data)
        conn = self._pool.acquire()
        try:
            conn.begin()
            result = conn.execute(sql, params)
            conn.commit()
            return result[0] if result else {}
        except Exception:
            conn.rollback()
            raise
        finally:
            self._pool.release(conn)
 
    def delete(self, table: str, conditions: dict[str, Any]) -> None:
        """レコード削除（DELETE）"""
        qb = QueryBuilder(table)
        for col, val in conditions.items():
            qb.where(f"{col} = ?", val)
        sql, params = qb.build_delete()
        conn = self._pool.acquire()
        try:
            conn.begin()
            conn.execute(sql, params)
            conn.commit()
        except Exception:
            conn.rollback()
            raise
        finally:
            self._pool.release(conn)
 
    def migrate(self, table: str, columns: dict[str, str]) -> None:
        """テーブル作成（マイグレーション）"""
        sql = self._migrator.create_table(table, columns)
        conn = self._pool.acquire()
        try:
            conn.execute(sql)
        finally:
            self._pool.release(conn)
 
 
# === 使用例 ===
 
db = DatabaseFacade("postgresql://localhost:5432/mydb")
 
# テーブル作成
db.migrate("users", {
    "id": "SERIAL PRIMARY KEY",
    "name": "VARCHAR(100)",
    "email": "VARCHAR(255)",
    "created_at": "TIMESTAMP DEFAULT NOW()",
})
 
# レコード挿入
db.insert("users", {"name": "Alice", "email": "alice@example.com"})
 
# 検索
users = db.find("users", conditions={"name": "Alice"}, order_by="-created_at", limit=10)
 
# 削除
db.delete("users", conditions={"id": 1})

// === Strategy インタフェース ===
 
interface NotificationChannel {
  send(to: string, message: string): Promise<boolean>;
}
 
class EmailChannel implements NotificationChannel {
  async send(to: string, message: string): Promise<boolean> {
    console.log(`Email to ${to}: ${message}`);
    return true;
  }
}
 
class SmsChannel implements NotificationChannel {
  async send(to: string, message: string): Promise<boolean> {
    console.log(`SMS to ${to}: ${message}`);
    return true;
  }
}
 
class PushChannel implements NotificationChannel {
  async send(to: string, message: string): Promise<boolean> {
    console.log(`Push to ${to}: ${message}`);
    return true;
  }
}
 
class SlackChannel implements NotificationChannel {
  async send(to: string, message: string): Promise<boolean> {
    console.log(`Slack to ${to}: ${message}`);
    return true;
  }
}
 
// === サブシステム群 ===
 
class TemplateRenderer {
  render(template: string, vars: Record<string, string>): string {
    let result = template;
    for (const [key, value] of Object.entries(vars)) {
      result = result.replace(`{{${key}}}`, value);
    }
    return result;
  }
}
 
class UserPreferences {
  getPreferredChannels(userId: string): string[] {
    // 実際はDBから取得
    return ["email", "push"];
  }
 
  getContactInfo(userId: string): Record<string, string> {
    return {
      email: "user@example.com",
      phone: "+81-90-1234-5678",
      deviceToken: "abc123",
      slackId: "U12345",
    };
  }
}
 
class NotificationLog {
  async log(
    userId: string,
    channel: string,
    message: string,
    success: boolean,
  ): Promise<void> {
    console.log(
      `Log: user=${userId} channel=${channel} success=${success}`
    );
  }
}
 
// === Facade ===
 
interface NotifyOptions {
  template: string;
  vars: Record<string, string>;
  userId: string;
  channels?: string[];  // 指定しなければユーザー設定を使用
}
 
class NotificationFacade {
  private channelMap: Map<string, NotificationChannel>;
 
  constructor(
    private renderer: TemplateRenderer,
    private preferences: UserPreferences,
    private logger: NotificationLog,
    channels: Record<string, NotificationChannel>,
  ) {
    this.channelMap = new Map(Object.entries(channels));
  }
 
  /** 通知送信: テンプレート展開 → チャネル選択 → 送信 → ログ */
  async notify(options: NotifyOptions): Promise<void> {
    const { template, vars, userId } = options;
 
    // 1. テンプレート展開
    const message = this.renderer.render(template, vars);
 
    // 2. チャネル決定（明示指定 or ユーザー設定）
    const channelNames = options.channels
      ?? this.preferences.getPreferredChannels(userId);
 
    // 3. 連絡先取得
    const contacts = this.preferences.getContactInfo(userId);
 
    // 4. 全チャネルに送信（並列）
    const results = await Promise.allSettled(
      channelNames.map(async (name) => {
        const channel = this.channelMap.get(name);
        if (!channel) {
          console.warn(`Unknown channel: ${name}`);
          return;
        }
 
        const to = contacts[name] ?? contacts.email;
        const success = await channel.send(to, message);
        await this.logger.log(userId, name, message, success);
      }),
    );
 
    const failures = results.filter(r => r.status === "rejected");
    if (failures.length > 0) {
      console.error(`${failures.length} notification(s) failed`);
    }
  }
 
  /** 緊急通知: 全チャネルに送信 */
  async emergency(userId: string, message: string): Promise<void> {
    const allChannels = Array.from(this.channelMap.keys());
    await this.notify({
      template: "[URGENT] {{message}}",
      vars: { message },
      userId,
      channels: allChannels,
    });
  }
}
 
// === 使用例 ===
 
const notifier = new NotificationFacade(
  new TemplateRenderer(),
  new UserPreferences(),
  new NotificationLog(),
  {
    email: new EmailChannel(),
    sms: new SmsChannel(),
    push: new PushChannel(),
    slack: new SlackChannel(),
  },
);
 
// ユーザー設定に基づいて通知（email + push）
await notifier.notify({
  template: "Hello {{name}}, your order #{{orderId}} has shipped!",
  vars: { name: "Taro", orderId: "12345" },
  userId: "user-1",
});
 
// 緊急通知: 全チャネル
await notifier.emergency("user-1", "System maintenance in 30 minutes");