// 責任1: 注文のバリデーション
class OrderValidator {
  validate(items: CartItem[]): void {
    if (items.length === 0) throw new Error('Cart is empty');
    for (const item of items) {
      if (item.quantity <= 0) throw new Error('Invalid quantity');
    }
  }
}

// 責任2: 価格計算
class PriceCalculator {
  calculate(items: CartItem[]): number {
    return items.reduce((total, item) => {
      const subtotal = item.price * item.quantity;
      const discount = item.category === 'food' ? subtotal * 0.08 : 0;
      return total + subtotal - discount;
    }, 0);
  }
}

// 責任3: 注文の永続化
class OrderRepository {
  save(order: Order): void {
    db.query(`INSERT INTO orders VALUES (...)`, order);
  }
}

// 責任4: 通知
class OrderNotifier {
  constructor(private userRepository: UserRepository) {}

  notifyOrderCreated(order: Order): void {
    const user = this.userRepository.findById(order.userId);
    smtp.send(user.email, 'Order Confirmed', `Your order #${order.id} has been placed.`);
  }
}

// 責任5: ログ記録
class OrderLogger {
  logCreation(order: Order): void {
    fs.appendFileSync('orders.log', `${new Date().toISOString()} Order ${order.id} created\n`);
  }
}

// オーケストレーション
class OrderService {
  constructor(
    private validator: OrderValidator,
    private calculator: PriceCalculator,
    private repository: OrderRepository,
    private notifier: OrderNotifier,
    private logger: OrderLogger
  ) {}

  createOrder(userId: string, items: CartItem[]): Order {
    this.validator.validate(items);
    const total = this.calculator.calculate(items);
    const order: Order = { id: generateId(), userId, items, total, status: 'pending' };
    this.repository.save(order);
    this.notifier.notifyOrderCreated(order);
    this.logger.logCreation(order);
    return order;
  }
}

interface NotificationChannel {
  send(userId: string, message: string): void;
}

class EmailChannel implements NotificationChannel {
  constructor(private userRepository: UserRepository) {}

  send(userId: string, message: string): void {
    const user = this.userRepository.findById(userId);
    smtp.send(user.email, 'Notification', message);
  }
}

class SmsChannel implements NotificationChannel {
  constructor(private userRepository: UserRepository) {}

  send(userId: string, message: string): void {
    const user = this.userRepository.findById(userId);
    smsGateway.send(user.phone, message);
  }
}

class SlackChannel implements NotificationChannel {
  send(userId: string, message: string): void {
    slackApi.postMessage(userId, message);
  }
}

// 新しいチャネルの追加：クラスを追加するだけ
class PushChannel implements NotificationChannel {
  send(userId: string, message: string): void {
    pushService.send(userId, { title: 'Notification', body: message });
  }
}

class NotificationService {
  private channels: Map<string, NotificationChannel> = new Map();

  registerChannel(name: string, channel: NotificationChannel): void {
    this.channels.set(name, channel);
  }

  send(userId: string, message: string, channelName: string): void {
    const channel = this.channels.get(channelName);
    if (!channel) throw new Error(`Unknown channel: ${channelName}`);
    channel.send(userId, message);
  }
}

interface ConfigReader {
  get(key: string): string | undefined;
  has(key: string): boolean;
}

interface ConfigWriter {
  set(key: string, value: string): void;
  delete(key: string): void;
}

class ReadOnlyConfig implements ConfigReader {
  constructor(private data: Map<string, string>) {}

  get(key: string): string | undefined {
    return this.data.get(key);
  }

  has(key: string): boolean {
    return this.data.has(key);
  }
}

class MutableConfig implements ConfigReader, ConfigWriter {
  private data: Map<string, string> = new Map();

  get(key: string): string | undefined {
    return this.data.get(key);
  }

  has(key: string): boolean {
    return this.data.has(key);
  }

  set(key: string, value: string): void {
    this.data.set(key, value);
  }

  delete(key: string): void {
    this.data.delete(key);
  }
}

// 読み取りだけ必要な場所
function displayConfig(config: ConfigReader): void {
  // set/delete は呼べない = エラーが起きない
  console.log(config.get('app.name'));
}

// 書き込みも必要な場所
function updateConfig(config: ConfigWriter, key: string, value: string): void {
  config.set(key, value);
}

interface DataReader {
  read(id: string): any;
}

interface DataWriter {
  write(id: string, data: any): void;
  delete(id: string): void;
}

interface DataSearcher {
  search(query: string): any[];
}

interface DataBackup {
  backup(): void;
  restore(backupId: string): void;
}

interface DataMonitor {
  getStats(): StoreStats;
}

// 全機能を持つ実装
class FullDataStore implements DataReader, DataWriter, DataSearcher, DataBackup, DataMonitor {
  read(id: string): any { /* ... */ }
  write(id: string, data: any): void { /* ... */ }
  delete(id: string): void { /* ... */ }
  search(query: string): any[] { return []; }
  backup(): void { /* ... */ }
  restore(backupId: string): void { /* ... */ }
  getStats(): StoreStats { return {} as StoreStats; }
}

// 各クライアントは必要なインターフェースだけに依存
class SearchService {
  constructor(private store: DataSearcher) {}
  find(query: string): any[] {
    return this.store.search(query);
  }
}

class BackupService {
  constructor(private store: DataBackup) {}
  performBackup(): void {
    this.store.backup();
  }
}

class CrudService {
  constructor(
    private reader: DataReader,
    private writer: DataWriter
  ) {}
  // ...
}

interface PaymentGateway {
  charge(amount: number, paymentToken: string): string;
}

class StripePaymentGateway implements PaymentGateway {
  charge(amount: number, paymentToken: string): string {
    // Stripe固有の実装
    return `stripe-txn-${Date.now()}`;
  }
}

class PayPalPaymentGateway implements PaymentGateway {
  charge(amount: number, paymentToken: string): string {
    // PayPal固有の実装
    return `paypal-txn-${Date.now()}`;
  }
}

// テスト用モック
class MockPaymentGateway implements PaymentGateway {
  public lastCharge: { amount: number; token: string } | null = null;

  charge(amount: number, paymentToken: string): string {
    this.lastCharge = { amount, token: paymentToken };
    return 'mock-txn-123';
  }
}

class OrderService {
  constructor(private gateway: PaymentGateway) {} // 抽象に依存

  placeOrder(order: Order, paymentToken: string): string {
    return this.gateway.charge(order.total, paymentToken);
  }
}

// 使い方
const service = new OrderService(new StripePaymentGateway());
// テスト時
const mockGateway = new MockPaymentGateway();
const testService = new OrderService(mockGateway);

// DIP: 抽象に依存
interface SalesRepository {
  findByDateRange(start: Date, end: Date): Sale[];
}

// OCP: 販売タイプごとのフォーマッター
interface SaleFormatter {
  readonly type: string;
  format(sale: Sale): string;
}

class OnlineSaleFormatter implements SaleFormatter {
  readonly type = 'online';
  format(sale: Sale): string { return `[Online] ${sale.amount}`; }
}

class StoreSaleFormatter implements SaleFormatter {
  readonly type = 'store';
  format(sale: Sale): string { return `[Store] ${sale.amount}`; }
}

// SRP: 集計ロジック
class SalesAggregator {
  calculateTotal(sales: Sale[]): number {
    return sales.reduce((sum, sale) => sum + sale.amount, 0);
  }
}

// SRP: レポート組み立て
class SalesReportGenerator {
  private formatters: Map<string, SaleFormatter> = new Map();

  constructor(
    private repository: SalesRepository,
    private aggregator: SalesAggregator,
    formatters: SaleFormatter[]
  ) {
    for (const f of formatters) {
      this.formatters.set(f.type, f);
    }
  }

  generate(startDate: Date, endDate: Date): string {
    const sales = this.repository.findByDateRange(startDate, endDate);
    const total = this.aggregator.calculateTotal(sales);

    const lines = sales.map(sale => {
      const formatter = this.formatters.get(sale.type);
      return formatter ? formatter.format(sale) : `[Unknown] ${sale.amount}`;
    });

    return `Sales Report\n${lines.join('\n')}\nTotal: ${total}`;
  }
}