// 問題のあるコード: 利用側が具象クラスを直接知っている
class OrderService {
  processPayment(order: Order): void {
    let processor;
 
    // 利用側が「どのクラスを生成するか」を知っている
    if (order.paymentMethod === "credit") {
      processor = new CreditCardProcessor(order.cardNumber, order.cvv);
    } else if (order.paymentMethod === "paypal") {
      processor = new PayPalProcessor(order.email);
    } else if (order.paymentMethod === "bank") {
      processor = new BankTransferProcessor(order.bankAccount);
    }
    // 新しい支払い方法を追加するたびに、ここを変更する必要がある → OCP 違反
 
    processor.charge(order.amount);
  }
}

// Product インタフェース
interface Notification {
  send(message: string): void;
  getType(): string;
}
 
// Concrete Products
class EmailNotification implements Notification {
  constructor(private recipient: string) {}
 
  send(message: string): void {
    console.log(`[Email → ${this.recipient}] ${message}`);
  }
 
  getType(): string {
    return "email";
  }
}
 
class SlackNotification implements Notification {
  constructor(private channel: string) {}
 
  send(message: string): void {
    console.log(`[Slack #${this.channel}] ${message}`);
  }
 
  getType(): string {
    return "slack";
  }
}
 
class SmsNotification implements Notification {
  constructor(private phoneNumber: string) {}
 
  send(message: string): void {
    console.log(`[SMS → ${this.phoneNumber}] ${message}`);
  }
 
  getType(): string {
    return "sms";
  }
}
 
// Creator（抽象クラス）
abstract class NotificationService {
  // Factory Method: サブクラスが具体的な Notification を決定
  abstract createNotification(): Notification;
 
  // Template Method: 通知の送信フロー
  notify(message: string): void {
    const notification = this.createNotification();
    console.log(`Sending via ${notification.getType()}...`);
    notification.send(message);
    console.log("Notification sent successfully.");
  }
}
 
// Concrete Creators
class EmailService extends NotificationService {
  constructor(private recipient: string) {
    super();
  }
 
  createNotification(): Notification {
    return new EmailNotification(this.recipient);
  }
}
 
class SlackService extends NotificationService {
  constructor(private channel: string) {
    super();
  }
 
  createNotification(): Notification {
    return new SlackNotification(this.channel);
  }
}
 
// 使用: Creator の型で扱えるため、具体的な通知手段に依存しない
function sendDeployNotification(service: NotificationService): void {
  service.notify("デプロイ完了: v2.1.0");
}
 
sendDeployNotification(new SlackService("deployments"));
// Sending via slack...
// [Slack #deployments] デプロイ完了: v2.1.0
// Notification sent successfully.
 
sendDeployNotification(new EmailService("admin@example.com"));
// Sending via email...
// [Email → admin@example.com] デプロイ完了: v2.1.0
// Notification sent successfully.

type NotificationType = "email" | "slack" | "sms";
 
interface NotificationConfig {
  type: NotificationType;
  recipient?: string;
  channel?: string;
  phoneNumber?: string;
}
 
// Simple Factory 関数
function createNotification(config: NotificationConfig): Notification {
  switch (config.type) {
    case "email":
      if (!config.recipient) throw new Error("Email requires recipient");
      return new EmailNotification(config.recipient);
    case "slack":
      if (!config.channel) throw new Error("Slack requires channel");
      return new SlackNotification(config.channel);
    case "sms":
      if (!config.phoneNumber) throw new Error("SMS requires phoneNumber");
      return new SmsNotification(config.phoneNumber);
    default:
      // TypeScript の exhaustive check
      const _exhaustive: never = config.type;
      throw new Error(`Unknown notification type: ${_exhaustive}`);
  }
}
 
// 使用
const emailNotif = createNotification({
  type: "email",
  recipient: "user@example.com"
});
emailNotif.send("Hello!");
 
const slackNotif = createNotification({
  type: "slack",
  channel: "general"
});
slackNotif.send("Hello team!");

// 抽象プロダクト
interface Button {
  render(): string;
  onClick(handler: () => void): void;
}
 
interface Input {
  render(): string;
  getValue(): string;
  setValue(value: string): void;
}
 
interface Dialog {
  render(): string;
  show(): void;
  close(): void;
}
 
// 抽象ファクトリ
interface UIFactory {
  createButton(label: string): Button;
  createInput(placeholder: string): Input;
  createDialog(title: string): Dialog;
}
 
// Concrete: Material Design
class MaterialButton implements Button {
  constructor(private label: string) {}
  render() { return `<md-button>${this.label}</md-button>`; }
  onClick(handler: () => void) { /* Material ripple effect + handler */ }
}
 
class MaterialInput implements Input {
  private value = "";
  constructor(private placeholder: string) {}
  render() { return `<md-input placeholder="${this.placeholder}" />`; }
  getValue() { return this.value; }
  setValue(v: string) { this.value = v; }
}
 
class MaterialDialog implements Dialog {
  constructor(private title: string) {}
  render() { return `<md-dialog><h2>${this.title}</h2></md-dialog>`; }
  show() { console.log(`Material Dialog opened: ${this.title}`); }
  close() { console.log(`Material Dialog closed: ${this.title}`); }
}
 
class MaterialFactory implements UIFactory {
  createButton(label: string) { return new MaterialButton(label); }
  createInput(placeholder: string) { return new MaterialInput(placeholder); }
  createDialog(title: string) { return new MaterialDialog(title); }
}
 
// Concrete: iOS Style
class IOSButton implements Button {
  constructor(private label: string) {}
  render() { return `<ios-button>${this.label}</ios-button>`; }
  onClick(handler: () => void) { /* iOS haptic feedback + handler */ }
}
 
class IOSInput implements Input {
  private value = "";
  constructor(private placeholder: string) {}
  render() { return `<ios-input placeholder="${this.placeholder}" />`; }
  getValue() { return this.value; }
  setValue(v: string) { this.value = v; }
}
 
class IOSDialog implements Dialog {
  constructor(private title: string) {}
  render() { return `<ios-dialog><h2>${this.title}</h2></ios-dialog>`; }
  show() { console.log(`iOS Dialog opened: ${this.title}`); }
  close() { console.log(`iOS Dialog closed: ${this.title}`); }
}
 
class IOSFactory implements UIFactory {
  createButton(label: string) { return new IOSButton(label); }
  createInput(placeholder: string) { return new IOSInput(placeholder); }
  createDialog(title: string) { return new IOSDialog(title); }
}
 
// 使用: ファクトリを差し替えるだけで UI 全体のテーマが変わる
function buildLoginForm(factory: UIFactory): string {
  const emailInput = factory.createInput("メールアドレス");
  const passwordInput = factory.createInput("パスワード");
  const submitButton = factory.createButton("ログイン");
 
  return [
    emailInput.render(),
    passwordInput.render(),
    submitButton.render(),
  ].join("\n");
}
 
console.log("--- Material Design ---");
console.log(buildLoginForm(new MaterialFactory()));
// <md-input placeholder="メールアドレス" />
// <md-input placeholder="パスワード" />
// <md-button>ログイン</md-button>
 
console.log("--- iOS Style ---");
console.log(buildLoginForm(new IOSFactory()));
// <ios-input placeholder="メールアドレス" />
// <ios-input placeholder="パスワード" />
// <ios-button>ログイン</ios-button>

type Creator<T> = (...args: any[]) => T;
 
class NotificationRegistry {
  private static registry = new Map<string, Creator<Notification>>();
 
  // 型を登録（各モジュールが自分で登録する）
  static register(type: string, creator: Creator<Notification>): void {
    if (this.registry.has(type)) {
      console.warn(`Overwriting existing creator for: ${type}`);
    }
    this.registry.set(type, creator);
  }
 
  // 型からインスタンスを生成
  static create(type: string, ...args: any[]): Notification {
    const creator = this.registry.get(type);
    if (!creator) {
      const available = Array.from(this.registry.keys()).join(", ");
      throw new Error(
        `Unknown notification type: "${type}". Available: [${available}]`
      );
    }
    return creator(...args);
  }
 
  // 登録されている型の一覧
  static getRegisteredTypes(): string[] {
    return Array.from(this.registry.keys());
  }
}
 
// 各モジュールが自分のプロダクトを登録
// email-notification.ts
NotificationRegistry.register("email",
  (recipient: string) => new EmailNotification(recipient)
);
 
// slack-notification.ts
NotificationRegistry.register("slack",
  (channel: string) => new SlackNotification(channel)
);
 
// sms-notification.ts
NotificationRegistry.register("sms",
  (phone: string) => new SmsNotification(phone)
);
 
// 新しい型の追加: 既存コードの変更は一切不要（OCP 準拠）
// teams-notification.ts
class TeamsNotification implements Notification {
  constructor(private webhook: string) {}
  send(message: string) { console.log(`[Teams] ${message}`); }
  getType() { return "teams"; }
}
NotificationRegistry.register("teams",
  (webhook: string) => new TeamsNotification(webhook)
);
 
// 使用
const notification = NotificationRegistry.create("teams", "https://webhook.url");
notification.send("Teams notification!");
console.log(NotificationRegistry.getRegisteredTypes());
// ["email", "slack", "sms", "teams"]

from abc import ABC, abstractmethod
from typing import Any
import json
import xml.etree.ElementTree as ET
 
class Serializer(ABC):
    """直列化の抽象クラス"""
 
    @abstractmethod
    def serialize(self, data: dict) -> str:
        """データを文字列に変換する"""
        ...
 
    @abstractmethod
    def deserialize(self, raw: str) -> dict:
        """文字列からデータを復元する"""
        ...
 
    @abstractmethod
    def content_type(self) -> str:
        """MIME タイプを返す"""
        ...
 
class JsonSerializer(Serializer):
    def serialize(self, data: dict) -> str:
        return json.dumps(data, ensure_ascii=False, indent=2)
 
    def deserialize(self, raw: str) -> dict:
        return json.loads(raw)
 
    def content_type(self) -> str:
        return "application/json"
 
class XmlSerializer(Serializer):
    def serialize(self, data: dict) -> str:
        root = ET.Element("data")
        for key, value in data.items():
            child = ET.SubElement(root, key)
            child.text = str(value)
        return ET.tostring(root, encoding="unicode")
 
    def deserialize(self, raw: str) -> dict:
        root = ET.fromstring(raw)
        return {child.tag: child.text for child in root}
 
    def content_type(self) -> str:
        return "application/xml"
 
class CsvSerializer(Serializer):
    def serialize(self, data: dict) -> str:
        headers = ",".join(data.keys())
        values = ",".join(str(v) for v in data.values())
        return f"{headers}\n{values}"
 
    def deserialize(self, raw: str) -> dict:
        lines = raw.strip().split("\n")
        headers = lines[0].split(",")
        values = lines[1].split(",")
        return dict(zip(headers, values))
 
    def content_type(self) -> str:
        return "text/csv"
 
# Simple Factory
def get_serializer(fmt: str) -> Serializer:
    """フォーマット名から適切な Serializer を返す Factory"""
    factories: dict[str, type[Serializer]] = {
        "json": JsonSerializer,
        "xml": XmlSerializer,
        "csv": CsvSerializer,
    }
    cls = factories.get(fmt)
    if cls is None:
        available = ", ".join(factories.keys())
        raise ValueError(f"Unknown format: '{fmt}'. Available: [{available}]")
    return cls()
 
# 使用
data = {"name": "太郎", "age": "30", "city": "東京"}
 
for fmt in ["json", "xml", "csv"]:
    s = get_serializer(fmt)
    serialized = s.serialize(data)
    print(f"\n--- {fmt} ({s.content_type()}) ---")
    print(serialized)
    restored = s.deserialize(serialized)
    print(f"Restored: {restored}")

public interface Shape {
    double area();
    String description();
}
 
public class Circle implements Shape {
    private final double radius;
 
    public Circle(double radius) {
        this.radius = radius;
    }
 
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
 
    @Override
    public String description() {
        return String.format("Circle(radius=%.2f, area=%.2f)", radius, area());
    }
}
 
public class Rectangle implements Shape {
    private final double width, height;
 
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
 
    @Override
    public double area() {
        return width * height;
    }
 
    @Override
    public String description() {
        return String.format("Rectangle(%.2f x %.2f, area=%.2f)", width, height, area());
    }
}
 
// Parameterized Factory Method with enum
public enum ShapeType {
    CIRCLE, RECTANGLE, TRIANGLE
}
 
public class ShapeFactory {
    public static Shape create(ShapeType type, double... params) {
        return switch (type) {
            case CIRCLE -> new Circle(params[0]);
            case RECTANGLE -> new Rectangle(params[0], params[1]);
            case TRIANGLE -> new Triangle(params[0], params[1]);
        };
    }
}
 
// 使用
Shape circle = ShapeFactory.create(ShapeType.CIRCLE, 5.0);
Shape rect = ShapeFactory.create(ShapeType.RECTANGLE, 3.0, 4.0);
System.out.println(circle.description()); // Circle(radius=5.00, area=78.54)
System.out.println(rect.description());   // Rectangle(3.00 x 4.00, area=12.00)

package main
 
import "fmt"
 
// Product インタフェース
type Logger interface {
    Log(message string)
    Level() string
}
 
// Concrete Products
type ConsoleLogger struct{}
 
func (l *ConsoleLogger) Log(message string) {
    fmt.Printf("[CONSOLE] %s\n", message)
}
func (l *ConsoleLogger) Level() string { return "console" }
 
type FileLogger struct {
    filename string
}
 
func (l *FileLogger) Log(message string) {
    fmt.Printf("[FILE:%s] %s\n", l.filename, message)
}
func (l *FileLogger) Level() string { return "file" }
 
type CloudLogger struct {
    endpoint string
}
 
func (l *CloudLogger) Log(message string) {
    fmt.Printf("[CLOUD:%s] %s\n", l.endpoint, message)
}
func (l *CloudLogger) Level() string { return "cloud" }
 
// Factory 関数（Go ではファーストクラス関数を活用）
type LoggerFactory func() Logger
 
// Registry
var loggerFactories = map[string]LoggerFactory{
    "console": func() Logger { return &ConsoleLogger{} },
    "file":    func() Logger { return &FileLogger{filename: "app.log"} },
    "cloud":   func() Logger { return &CloudLogger{endpoint: "https://log.example.com"} },
}
 
func CreateLogger(loggerType string) (Logger, error) {
    factory, exists := loggerFactories[loggerType]
    if !exists {
        return nil, fmt.Errorf("unknown logger type: %s", loggerType)
    }
    return factory(), nil
}
 
// 新しい型の登録
func RegisterLogger(name string, factory LoggerFactory) {
    loggerFactories[name] = factory
}
 
func main() {
    logger, _ := CreateLogger("console")
    logger.Log("Application started")
 
    logger2, _ := CreateLogger("cloud")
    logger2.Log("Cloud logging active")
}

// 非同期 Factory パターン
interface DataSource {
  connect(): Promise<void>;
  query(sql: string): Promise<any[]>;
  disconnect(): Promise<void>;
}
 
class PostgresDataSource implements DataSource {
  private pool: any;
 
  constructor(private connectionString: string) {}
 
  async connect(): Promise<void> {
    console.log(`Connecting to PostgreSQL: ${this.connectionString}`);
    // this.pool = await createPool(this.connectionString);
  }
 
  async query(sql: string): Promise<any[]> {
    console.log(`[PG] ${sql}`);
    return [];
  }
 
  async disconnect(): Promise<void> {
    // await this.pool.end();
  }
}
 
class MySQLDataSource implements DataSource {
  constructor(private config: { host: string; port: number; database: string }) {}
 
  async connect(): Promise<void> {
    console.log(`Connecting to MySQL: ${this.config.host}:${this.config.port}`);
  }
 
  async query(sql: string): Promise<any[]> {
    console.log(`[MySQL] ${sql}`);
    return [];
  }
 
  async disconnect(): Promise<void> {}
}
 
// 非同期 Factory: 生成 + 初期化を1ステップで行う
async function createDataSource(
  type: "postgres" | "mysql",
  config: Record<string, any>
): Promise<DataSource> {
  let ds: DataSource;
 
  switch (type) {
    case "postgres":
      ds = new PostgresDataSource(config.connectionString);
      break;
    case "mysql":
      ds = new MySQLDataSource({
        host: config.host,
        port: config.port,
        database: config.database,
      });
      break;
    default:
      throw new Error(`Unknown data source type: ${type}`);
  }
 
  // Factory が初期化まで保証する
  await ds.connect();
  return ds;
}
 
// 使用
async function main() {
  const ds = await createDataSource("postgres", {
    connectionString: "postgresql://localhost:5432/mydb"
  });
  const users = await ds.query("SELECT * FROM users");
  await ds.disconnect();
}

// バリデーション戦略を Factory で生成
interface ValidationStrategy {
  validate(value: string): { valid: boolean; error?: string };
}
 
class EmailValidator implements ValidationStrategy {
  validate(value: string) {
    const valid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
    return { valid, error: valid ? undefined : "Invalid email format" };
  }
}
 
class PhoneValidator implements ValidationStrategy {
  validate(value: string) {
    const valid = /^\d{10,11}$/.test(value.replace(/-/g, ""));
    return { valid, error: valid ? undefined : "Invalid phone number" };
  }
}
 
class UrlValidator implements ValidationStrategy {
  validate(value: string) {
    try {
      new URL(value);
      return { valid: true };
    } catch {
      return { valid: false, error: "Invalid URL" };
    }
  }
}
 
// Factory
const validatorFactory = new Map<string, () => ValidationStrategy>([
  ["email", () => new EmailValidator()],
  ["phone", () => new PhoneValidator()],
  ["url", () => new UrlValidator()],
]);
 
function createValidator(type: string): ValidationStrategy {
  const factory = validatorFactory.get(type);
  if (!factory) throw new Error(`Unknown validator: ${type}`);
  return factory();
}
 
// 使用: 設定駆動で動的にバリデータを選択
const formFields = [
  { name: "email", type: "email", value: "user@example.com" },
  { name: "phone", type: "phone", value: "090-1234-5678" },
  { name: "website", type: "url", value: "https://example.com" },
];
 
for (const field of formFields) {
  const validator = createValidator(field.type);
  const result = validator.validate(field.value);
  console.log(`${field.name}: ${result.valid ? "OK" : result.error}`);
}
// email: OK
// phone: OK
// website: OK

// DI コンテナで Factory を管理する実務的なパターン
interface IPaymentProcessor {
  charge(amount: number): Promise<{ success: boolean; transactionId: string }>;
  refund(transactionId: string): Promise<boolean>;
}
 
interface IPaymentFactory {
  create(method: string): IPaymentProcessor;
  getSupportedMethods(): string[];
}
 
class PaymentFactory implements IPaymentFactory {
  private processors = new Map<string, () => IPaymentProcessor>();
 
  register(method: string, factory: () => IPaymentProcessor): void {
    this.processors.set(method, factory);
  }
 
  create(method: string): IPaymentProcessor {
    const factory = this.processors.get(method);
    if (!factory) {
      throw new Error(`Unsupported payment method: ${method}`);
    }
    return factory();
  }
 
  getSupportedMethods(): string[] {
    return Array.from(this.processors.keys());
  }
}
 
// DI コンテナとの統合
// container.ts
const container = new Container();
 
// Factory 自体を Singleton スコープで登録
container.bind<IPaymentFactory>(TYPES.PaymentFactory)
  .toDynamicValue(() => {
    const factory = new PaymentFactory();
    factory.register("credit", () => new CreditCardProcessor());
    factory.register("paypal", () => new PayPalProcessor());
    factory.register("bank", () => new BankTransferProcessor());
    return factory;
  })
  .inSingletonScope();
 
// 使用側: Factory を注入してもらう
class OrderService {
  constructor(
    @inject(TYPES.PaymentFactory) private paymentFactory: IPaymentFactory
  ) {}
 
  async processOrder(order: Order): Promise<void> {
    const processor = this.paymentFactory.create(order.paymentMethod);
    const result = await processor.charge(order.amount);
    if (!result.success) {
      throw new Error("Payment failed");
    }
  }
}

// 問題: string ベースの Factory は型安全でない
const notif = createNotification("emal");  // typo! 実行時エラー
 
// 解決策 1: Union 型で制限
type NotificationType = "email" | "slack" | "sms";
function createNotification(type: NotificationType): Notification { ... }
 
// 解決策 2: Enum（Java/TypeScript）
enum NotificationType {
  Email = "email",
  Slack = "slack",
  Sms = "sms",
}
 
// 解決策 3: Discriminated Union（TypeScript）
type NotificationRequest =
  | { type: "email"; recipient: string }
  | { type: "slack"; channel: string }
  | { type: "sms"; phoneNumber: string };
 
function createNotification(req: NotificationRequest): Notification {
  switch (req.type) {
    case "email":
      return new EmailNotification(req.recipient);  // 型安全にアクセス
    case "slack":
      return new SlackNotification(req.channel);     // 型安全にアクセス
    case "sms":
      return new SmsNotification(req.phoneNumber);   // 型安全にアクセス
  }
}

// 問題: Registry に登録されたオブジェクトが GC されない
class HeavyRegistry {
  private static cache = new Map<string, LargeObject>();
 
  static getOrCreate(key: string): LargeObject {
    if (!this.cache.has(key)) {
      this.cache.set(key, new LargeObject(key)); // 蓄積し続ける
    }
    return this.cache.get(key)!;
  }
}
 
// 解決策: WeakMap または LRU キャッシュを使用
class SafeRegistry {
  private static cache = new LRUCache<string, LargeObject>({ max: 100 });
 
  static getOrCreate(key: string): LargeObject {
    let obj = this.cache.get(key);
    if (!obj) {
      obj = new LargeObject(key);
      this.cache.set(key, obj);
    }
    return obj;
  }
}

// NG: あらゆる型を1つの Factory で処理
class UniversalFactory {
  create(type: string): any {  // any は危険信号
    if (type === "user") return new User();
    if (type === "order") return new Order();
    if (type === "product") return new Product();
    if (type === "payment") return new Payment();
    if (type === "notification") return new Notification();
    if (type === "report") return new Report();
    // ... 50行の if-else
    throw new Error(`Unknown type: ${type}`);
  }
}

// OK: ドメインごとに Factory を分割
class UserFactory {
  static create(type: UserType): User { ... }
}
 
class OrderFactory {
  static create(items: CartItem[]): Order { ... }
}
 
class NotificationFactory {
  static create(type: NotificationType): Notification { ... }
}

// NG: プロダクトが1種類なのに Abstract Factory を使う
interface ShapeFactory {
  createShape(): Shape;  // 1メソッドだけ → Abstract Factory は過剰
}
 
class CircleFactory implements ShapeFactory {
  createShape(): Shape { return new Circle(); }
}
 
class RectangleFactory implements ShapeFactory {
  createShape(): Shape { return new Rectangle(); }
}

// OK: Simple Factory または Factory Method を使う
function createShape(type: "circle" | "rectangle"): Shape {
  switch (type) {
    case "circle": return new Circle();
    case "rectangle": return new Rectangle();
  }
}

// NG: Factory が生成以外の責任を持つ
class OrderFactory {
  static create(items: CartItem[], coupon?: string): Order {
    const order = new Order(items);
 
    // ビジネスロジック（Factory の責任ではない）
    if (coupon) {
      const discount = this.validateCoupon(coupon);  // クーポン検証
      order.applyDiscount(discount);                 // 割引適用
    }
 
    order.calculateTax();      // 税計算
    order.calculateShipping(); // 送料計算
    this.sendAnalytics(order); // 分析データ送信
 
    return order;
  }
}

// OK: Factory は生成のみ。ビジネスロジックはドメインサービスに委譲
class OrderFactory {
  static create(items: CartItem[]): Order {
    return new Order(items);  // 生成のみ
  }
}
 
class OrderService {
  constructor(
    private couponService: CouponService,
    private taxService: TaxService,
    private analytics: AnalyticsService,
  ) {}
 
  async processOrder(items: CartItem[], coupon?: string): Promise<Order> {
    const order = OrderFactory.create(items);
 
    if (coupon) {
      const discount = await this.couponService.validate(coupon);
      order.applyDiscount(discount);
    }
 
    order.tax = this.taxService.calculate(order);
    await this.analytics.track("order_created", order);
 
    return order;
  }
}

// === あなたの実装をここに書いてください ===

// === あなたの実装をここに書いてください ===

// === あなたの実装をここに書いてください ===