// command.ts -- Command パターンの基本構造
 
// ============================
// Command インターフェース
// ============================
interface Command {
  execute(): void;
  undo(): void;
  describe(): string;
  /** Undo 不可能な操作かどうかを示すフラグ */
  readonly isUndoable: boolean;
}
 
// ============================
// Receiver: テキストエディタ
// ============================
class TextEditor {
  private content: string = '';
  private cursorPosition: number = 0;
  private selectionStart: number = -1;
  private selectionEnd: number = -1;
 
  getContent(): string {
    return this.content;
  }
 
  getCursorPosition(): number {
    return this.cursorPosition;
  }
 
  setCursorPosition(pos: number): void {
    this.cursorPosition = Math.max(0, Math.min(pos, this.content.length));
  }
 
  setSelection(start: number, end: number): void {
    this.selectionStart = start;
    this.selectionEnd = end;
  }
 
  getSelection(): { start: number; end: number } | null {
    if (this.selectionStart < 0) return null;
    return { start: this.selectionStart, end: this.selectionEnd };
  }
 
  clearSelection(): void {
    this.selectionStart = -1;
    this.selectionEnd = -1;
  }
 
  insertAt(position: number, text: string): void {
    this.content =
      this.content.slice(0, position) + text + this.content.slice(position);
    this.cursorPosition = position + text.length;
  }
 
  deleteRange(start: number, end: number): string {
    const deleted = this.content.slice(start, end);
    this.content = this.content.slice(0, start) + this.content.slice(end);
    this.cursorPosition = start;
    return deleted;
  }
 
  replaceRange(start: number, end: number, newText: string): string {
    const deleted = this.content.slice(start, end);
    this.content =
      this.content.slice(0, start) + newText + this.content.slice(end);
    this.cursorPosition = start + newText.length;
    return deleted;
  }
 
  getLength(): number {
    return this.content.length;
  }
}
 
// ============================
// Concrete Command: テキスト挿入
// ============================
class InsertTextCommand implements Command {
  readonly isUndoable = true;
 
  constructor(
    private editor: TextEditor,
    private position: number,
    private text: string
  ) {}
 
  execute(): void {
    this.editor.insertAt(this.position, this.text);
  }
 
  undo(): void {
    this.editor.deleteRange(this.position, this.position + this.text.length);
  }
 
  describe(): string {
    return `Insert "${this.text}" at position ${this.position}`;
  }
}
 
// ============================
// Concrete Command: テキスト削除
// ============================
class DeleteTextCommand implements Command {
  readonly isUndoable = true;
  private deletedText: string = '';
 
  constructor(
    private editor: TextEditor,
    private start: number,
    private end: number
  ) {}
 
  execute(): void {
    this.deletedText = this.editor.deleteRange(this.start, this.end);
  }
 
  undo(): void {
    this.editor.insertAt(this.start, this.deletedText);
  }
 
  describe(): string {
    return `Delete "${this.deletedText}" from ${this.start} to ${this.end}`;
  }
}
 
// ============================
// Concrete Command: テキスト置換
// ============================
class ReplaceTextCommand implements Command {
  readonly isUndoable = true;
  private originalText: string = '';
 
  constructor(
    private editor: TextEditor,
    private start: number,
    private end: number,
    private newText: string
  ) {}
 
  execute(): void {
    this.originalText = this.editor.replaceRange(
      this.start, this.end, this.newText
    );
  }
 
  undo(): void {
    this.editor.replaceRange(
      this.start, this.start + this.newText.length, this.originalText
    );
  }
 
  describe(): string {
    return `Replace "${this.originalText}" with "${this.newText}"`;
  }
}
 
// ============================
// 使用例
// ============================
const editor = new TextEditor();
 
const cmd1 = new InsertTextCommand(editor, 0, 'Hello');
cmd1.execute();
console.log(editor.getContent()); // "Hello"
 
const cmd2 = new InsertTextCommand(editor, 5, ' World');
cmd2.execute();
console.log(editor.getContent()); // "Hello World"
 
const cmd3 = new ReplaceTextCommand(editor, 0, 5, 'Hi');
cmd3.execute();
console.log(editor.getContent()); // "Hi World"
 
cmd3.undo();
console.log(editor.getContent()); // "Hello World"
 
cmd2.undo();
console.log(editor.getContent()); // "Hello"

// undo-redo-manager.ts -- Undo/Redo の管理
 
// ============================
// イベント通知付き UndoRedoManager
// ============================
type HistoryEvent =
  | { type: 'execute'; command: Command }
  | { type: 'undo'; command: Command }
  | { type: 'redo'; command: Command }
  | { type: 'clear' };
 
type HistoryListener = (event: HistoryEvent) => void;
 
class UndoRedoManager {
  private undoStack: Command[] = [];
  private redoStack: Command[] = [];
  private readonly maxHistory: number;
  private listeners: HistoryListener[] = [];
  private batchLevel: number = 0;
  private batchCommands: Command[] = [];
 
  constructor(maxHistory: number = 100) {
    this.maxHistory = maxHistory;
  }
 
  /** コマンドを実行し、Undo スタックに追加 */
  execute(command: Command): void {
    command.execute();
 
    if (this.batchLevel > 0) {
      // バッチモード中はバッチに蓄積
      this.batchCommands.push(command);
      return;
    }
 
    this.undoStack.push(command);
 
    // 新しいコマンド実行時は Redo スタックをクリア
    // (分岐した履歴は破棄される)
    this.redoStack = [];
 
    // 履歴の上限を超えたら古いものを削除
    if (this.undoStack.length > this.maxHistory) {
      this.undoStack.shift();
    }
 
    this.notify({ type: 'execute', command });
  }
 
  /** 直前のコマンドを取り消す */
  undo(): boolean {
    const command = this.undoStack.pop();
    if (!command) return false;
 
    command.undo();
    this.redoStack.push(command);
    this.notify({ type: 'undo', command });
    return true;
  }
 
  /** 取り消したコマンドをやり直す */
  redo(): boolean {
    const command = this.redoStack.pop();
    if (!command) return false;
 
    command.execute();
    this.undoStack.push(command);
    this.notify({ type: 'redo', command });
    return true;
  }
 
  /** バッチ操作の開始（複数操作を1つの Undo 単位にまとめる） */
  beginBatch(): void {
    this.batchLevel++;
    if (this.batchLevel === 1) {
      this.batchCommands = [];
    }
  }
 
  /** バッチ操作の終了 */
  endBatch(description?: string): void {
    this.batchLevel--;
    if (this.batchLevel === 0 && this.batchCommands.length > 0) {
      const macro = new MacroCommand(this.batchCommands, description);
      this.undoStack.push(macro);
      this.redoStack = [];
 
      if (this.undoStack.length > this.maxHistory) {
        this.undoStack.shift();
      }
      this.notify({ type: 'execute', command: macro });
    }
  }
 
  canUndo(): boolean {
    return this.undoStack.length > 0;
  }
 
  canRedo(): boolean {
    return this.redoStack.length > 0;
  }
 
  getHistory(): string[] {
    return this.undoStack.map(cmd => cmd.describe());
  }
 
  getUndoCount(): number {
    return this.undoStack.length;
  }
 
  getRedoCount(): number {
    return this.redoStack.length;
  }
 
  /** 全履歴をクリア */
  clear(): void {
    this.undoStack = [];
    this.redoStack = [];
    this.notify({ type: 'clear' });
  }
 
  /** 履歴変更のリスナーを追加 */
  subscribe(listener: HistoryListener): () => void {
    this.listeners.push(listener);
    return () => {
      this.listeners = this.listeners.filter(l => l !== listener);
    };
  }
 
  private notify(event: HistoryEvent): void {
    for (const listener of this.listeners) {
      listener(event);
    }
  }
}
 
// ============================
// 使用例
// ============================
const editor2 = new TextEditor();
const manager = new UndoRedoManager();
 
// イベント監視
manager.subscribe(event => {
  console.log(`[History] ${event.type}: ${
    event.type !== 'clear' ? event.command.describe() : 'all'
  }`);
});
 
manager.execute(new InsertTextCommand(editor2, 0, 'Hello'));
// [History] execute: Insert "Hello" at position 0
console.log(editor2.getContent()); // "Hello"
 
manager.execute(new InsertTextCommand(editor2, 5, ' World'));
// [History] execute: Insert " World" at position 5
console.log(editor2.getContent()); // "Hello World"
 
manager.undo();
// [History] undo: Insert " World" at position 5
console.log(editor2.getContent()); // "Hello"
 
manager.redo();
// [History] redo: Insert " World" at position 5
console.log(editor2.getContent()); // "Hello World"
 
// バッチ操作: 「検索と置換」を1つの Undo 単位に
manager.beginBatch();
manager.execute(new DeleteTextCommand(editor2, 0, 5));
manager.execute(new InsertTextCommand(editor2, 0, 'Hi'));
manager.endBatch('Replace "Hello" with "Hi"');
 
console.log(editor2.getContent()); // "Hi World"
manager.undo(); // バッチ全体が1回の Undo で元に戻る
console.log(editor2.getContent()); // "Hello World"

// macro-command.ts -- 複数コマンドの合成（Composite パターンとの組合せ）
 
// ============================
// MacroCommand: 複数コマンドを1つにまとめる
// ============================
class MacroCommand implements Command {
  readonly isUndoable = true;
  private commands: Command[];
  private label: string;
 
  constructor(commands: Command[] = [], label?: string) {
    this.commands = [...commands];
    this.label = label ?? 'Macro';
  }
 
  add(command: Command): this {
    this.commands.push(command);
    return this;
  }
 
  execute(): void {
    for (const command of this.commands) {
      command.execute();
    }
  }
 
  undo(): void {
    // 逆順で Undo（LIFO: 最後に実行したものから戻す）
    for (let i = this.commands.length - 1; i >= 0; i--) {
      this.commands[i].undo();
    }
  }
 
  describe(): string {
    if (this.label !== 'Macro') return this.label;
    return `Macro [${this.commands.map(c => c.describe()).join(', ')}]`;
  }
}
 
// ============================
// MacroRecorder: ユーザー操作の記録・再生
// ============================
class MacroRecorder {
  private recording: boolean = false;
  private commands: Command[] = [];
  private macros: Map<string, MacroCommand> = new Map();
 
  startRecording(): void {
    this.recording = true;
    this.commands = [];
    console.log('Recording started...');
  }
 
  stopRecording(name: string): MacroCommand {
    this.recording = false;
    const macro = new MacroCommand([...this.commands], name);
    this.macros.set(name, macro);
    console.log(`Macro "${name}" saved (${this.commands.length} commands)`);
    return macro;
  }
 
  recordCommand(command: Command): void {
    if (this.recording) {
      this.commands.push(command);
    }
  }
 
  isRecording(): boolean {
    return this.recording;
  }
 
  getMacro(name: string): MacroCommand | undefined {
    return this.macros.get(name);
  }
 
  listMacros(): string[] {
    return [...this.macros.keys()];
  }
}
 
// ============================
// 使用例: テキスト整形マクロ
// ============================
const editorMacro = new TextEditor();
const managerMacro = new UndoRedoManager();
const recorder = new MacroRecorder();
 
// マクロの記録開始
recorder.startRecording();
 
// 操作を記録しつつ実行
const m1 = new InsertTextCommand(editorMacro, 0, '# ');
recorder.recordCommand(m1);
managerMacro.execute(m1);
 
const m2 = new InsertTextCommand(
  editorMacro, editorMacro.getLength(), '\n---\n'
);
recorder.recordCommand(m2);
managerMacro.execute(m2);
 
// マクロを名前付きで保存
const formatMacro = recorder.stopRecording('heading-format');
 
console.log(editorMacro.getContent());
// "# \n---\n"
 
// マクロを別のテキストに再適用
// ※ 新しい editor でコマンドを再生成する必要がある点に注意

// command-queue.ts -- 非同期コマンドの順序実行
 
// ============================
// AsyncCommand インターフェース
// ============================
interface AsyncCommand {
  execute(): Promise<void>;
  undo(): Promise<void>;
  describe(): string;
  /** リトライ可能かどうか */
  canRetry(): boolean;
  /** 最大リトライ回数 */
  maxRetries: number;
}
 
// ============================
// CommandQueue: 順序実行キュー
// ============================
type QueueEvent =
  | { type: 'enqueue'; command: AsyncCommand }
  | { type: 'execute'; command: AsyncCommand }
  | { type: 'retry'; command: AsyncCommand; attempt: number }
  | { type: 'fail'; command: AsyncCommand; error: Error }
  | { type: 'rollback'; command: AsyncCommand }
  | { type: 'complete' };
 
class CommandQueue {
  private queue: Array<{ command: AsyncCommand; retries: number }> = [];
  private processing: boolean = false;
  private executed: AsyncCommand[] = [];
  private listeners: Array<(event: QueueEvent) => void> = [];
 
  enqueue(command: AsyncCommand): void {
    this.queue.push({ command, retries: 0 });
    this.notify({ type: 'enqueue', command });
    this.processNext();
  }
 
  enqueueAll(commands: AsyncCommand[]): void {
    for (const command of commands) {
      this.queue.push({ command, retries: 0 });
      this.notify({ type: 'enqueue', command });
    }
    this.processNext();
  }
 
  private async processNext(): Promise<void> {
    if (this.processing || this.queue.length === 0) return;
 
    this.processing = true;
    const entry = this.queue.shift()!;
 
    try {
      await entry.command.execute();
      this.executed.push(entry.command);
      this.notify({ type: 'execute', command: entry.command });
    } catch (error) {
      const err = error instanceof Error ? error : new Error(String(error));
      this.notify({ type: 'fail', command: entry.command, error: err });
 
      if (entry.command.canRetry() && entry.retries < entry.command.maxRetries) {
        // リトライ: キューの先頭に戻す
        entry.retries++;
        this.notify({
          type: 'retry',
          command: entry.command,
          attempt: entry.retries,
        });
        this.queue.unshift(entry);
      } else {
        // 失敗時のロールバック
        await this.rollback();
      }
    } finally {
      this.processing = false;
      if (this.queue.length > 0) {
        this.processNext();
      } else {
        this.notify({ type: 'complete' });
      }
    }
  }
 
  private async rollback(): Promise<void> {
    console.log('Rolling back executed commands...');
    while (this.executed.length > 0) {
      const cmd = this.executed.pop()!;
      try {
        await cmd.undo();
        this.notify({ type: 'rollback', command: cmd });
      } catch (err) {
        console.error(`Rollback failed for: ${cmd.describe()}`, err);
        // 補償トランザクションのロールバック失敗は
        // 人間の介入が必要な場面 → アラート
      }
    }
    // ロールバック後はキューも全てクリア
    this.queue = [];
  }
 
  subscribe(listener: (event: QueueEvent) => void): () => void {
    this.listeners.push(listener);
    return () => {
      this.listeners = this.listeners.filter(l => l !== listener);
    };
  }
 
  private notify(event: QueueEvent): void {
    for (const listener of this.listeners) {
      listener(event);
    }
  }
}
 
// ============================
// 使用例: API コール のトランザクション
// ============================
class CreateUserCommand implements AsyncCommand {
  maxRetries = 2;
  private userId: string | null = null;
 
  constructor(private userData: { name: string; email: string }) {}
 
  async execute(): Promise<void> {
    // API 呼び出し (シミュレーション)
    console.log(`Creating user: ${this.userData.name}`);
    this.userId = `user_${Date.now()}`;
  }
 
  async undo(): Promise<void> {
    if (this.userId) {
      console.log(`Deleting user: ${this.userId}`);
      this.userId = null;
    }
  }
 
  canRetry(): boolean { return true; }
  describe(): string { return `CreateUser(${this.userData.name})`; }
}
 
class SendWelcomeEmailCommand implements AsyncCommand {
  maxRetries = 3;
 
  constructor(private email: string) {}
 
  async execute(): Promise<void> {
    console.log(`Sending welcome email to: ${this.email}`);
    // ネットワークエラーのシミュレーション
    if (Math.random() < 0.3) {
      throw new Error('SMTP connection timeout');
    }
  }
 
  async undo(): Promise<void> {
    console.log(`Email to ${this.email} cannot be unsent (no-op)`);
  }
 
  canRetry(): boolean { return true; }
  describe(): string { return `SendEmail(${this.email})`; }
}
 
// キューの使用
const queue = new CommandQueue();
 
queue.subscribe(event => {
  switch (event.type) {
    case 'execute':
      console.log(`Executed: ${event.command.describe()}`);
      break;
    case 'retry':
      console.log(`Retrying: ${event.command.describe()} (attempt ${event.attempt})`);
      break;
    case 'rollback':
      console.log(`Rolled back: ${event.command.describe()}`);
      break;
  }
});
 
queue.enqueueAll([
  new CreateUserCommand({ name: 'Alice', email: 'alice@example.com' }),
  new SendWelcomeEmailCommand('alice@example.com'),
]);

# command_python.py -- Python での Command パターン実装
from __future__ import annotations
from typing import Protocol, runtime_checkable
from dataclasses import dataclass, field
from datetime import datetime
 
 
# ============================
# Command プロトコル
# ============================
@runtime_checkable
class Command(Protocol):
    def execute(self) -> None: ...
    def undo(self) -> None: ...
    def describe(self) -> str: ...
 
 
# ============================
# Receiver: スプレッドシート
# ============================
class Spreadsheet:
    def __init__(self, rows: int = 100, cols: int = 26):
        self._cells: dict[tuple[int, int], str | float] = {}
        self._rows = rows
        self._cols = cols
 
    def get_cell(self, row: int, col: int) -> str | float | None:
        return self._cells.get((row, col))
 
    def set_cell(self, row: int, col: int, value: str | float) -> None:
        self._cells[(row, col)] = value
 
    def delete_cell(self, row: int, col: int) -> str | float | None:
        return self._cells.pop((row, col), None)
 
    def get_range(
        self, r1: int, c1: int, r2: int, c2: int
    ) -> dict[tuple[int, int], str | float]:
        return {
            (r, c): v
            for (r, c), v in self._cells.items()
            if r1 <= r <= r2 and c1 <= c <= c2
        }
 
 
# ============================
# Concrete Command: セル値の設定
# ============================
@dataclass
class SetCellCommand:
    sheet: Spreadsheet
    row: int
    col: int
    new_value: str | float
    _old_value: str | float | None = field(default=None, init=False)
 
    def execute(self) -> None:
        self._old_value = self.sheet.get_cell(self.row, self.col)
        self.sheet.set_cell(self.row, self.col, self.new_value)
 
    def undo(self) -> None:
        if self._old_value is None:
            self.sheet.delete_cell(self.row, self.col)
        else:
            self.sheet.set_cell(self.row, self.col, self._old_value)
 
    def describe(self) -> str:
        col_letter = chr(ord("A") + self.col)
        return f"Set {col_letter}{self.row + 1} = {self.new_value}"
 
 
# ============================
# Concrete Command: 範囲の一括クリア
# ============================
@dataclass
class ClearRangeCommand:
    sheet: Spreadsheet
    r1: int
    c1: int
    r2: int
    c2: int
    _saved: dict[tuple[int, int], str | float] = field(
        default_factory=dict, init=False
    )
 
    def execute(self) -> None:
        self._saved = self.sheet.get_range(self.r1, self.c1, self.r2, self.c2)
        for (r, c) in self._saved:
            self.sheet.delete_cell(r, c)
 
    def undo(self) -> None:
        for (r, c), v in self._saved.items():
            self.sheet.set_cell(r, c, v)
 
    def describe(self) -> str:
        c1_letter = chr(ord("A") + self.c1)
        c2_letter = chr(ord("A") + self.c2)
        return f"Clear {c1_letter}{self.r1 + 1}:{c2_letter}{self.r2 + 1}"
 
 
# ============================
# UndoRedoManager (Python 版)
# ============================
@dataclass
class UndoRedoManager:
    max_history: int = 100
    _undo_stack: list[Command] = field(default_factory=list, init=False)
    _redo_stack: list[Command] = field(default_factory=list, init=False)
 
    def execute(self, command: Command) -> None:
        command.execute()
        self._undo_stack.append(command)
        self._redo_stack.clear()
        if len(self._undo_stack) > self.max_history:
            self._undo_stack.pop(0)
 
    def undo(self) -> bool:
        if not self._undo_stack:
            return False
        cmd = self._undo_stack.pop()
        cmd.undo()
        self._redo_stack.append(cmd)
        return True
 
    def redo(self) -> bool:
        if not self._redo_stack:
            return False
        cmd = self._redo_stack.pop()
        cmd.execute()
        self._undo_stack.append(cmd)
        return True
 
    def history(self) -> list[str]:
        return [cmd.describe() for cmd in self._undo_stack]
 
 
# ============================
# 使用例
# ============================
if __name__ == "__main__":
    sheet = Spreadsheet()
    mgr = UndoRedoManager()
 
    mgr.execute(SetCellCommand(sheet, 0, 0, "Name"))
    mgr.execute(SetCellCommand(sheet, 0, 1, "Age"))
    mgr.execute(SetCellCommand(sheet, 1, 0, "Alice"))
    mgr.execute(SetCellCommand(sheet, 1, 1, 30))
 
    print(f"A1={sheet.get_cell(0, 0)}, B1={sheet.get_cell(0, 1)}")
    # A1=Name, B1=Age
    print(f"A2={sheet.get_cell(1, 0)}, B2={sheet.get_cell(1, 1)}")
    # A2=Alice, B2=30
 
    mgr.undo()  # B2 = 30 を取り消し
    print(f"B2 after undo: {sheet.get_cell(1, 1)}")
    # B2 after undo: None
 
    mgr.redo()  # B2 = 30 を復元
    print(f"B2 after redo: {sheet.get_cell(1, 1)}")
    # B2 after redo: 30
 
    print("History:", mgr.history())
    # History: ['Set A1 = Name', 'Set B1 = Age', 'Set A2 = Alice', 'Set B2 = 30']

// functional-command.ts -- 関数型アプローチの Command パターン
 
// ============================
// 関数型 Command の型定義
// ============================
interface FunctionalCommand {
  execute: () => void;
  undo: () => void;
  describe: () => string;
}
 
// ============================
// Command ファクトリ
// ============================
function createInsertCommand(
  editor: TextEditor,
  position: number,
  text: string
): FunctionalCommand {
  return {
    execute: () => editor.insertAt(position, text),
    undo: () => editor.deleteRange(position, position + text.length),
    describe: () => `Insert "${text}" at ${position}`,
  };
}
 
function createDeleteCommand(
  editor: TextEditor,
  start: number,
  end: number
): FunctionalCommand {
  let deleted = '';
  return {
    execute: () => { deleted = editor.deleteRange(start, end); },
    undo: () => editor.insertAt(start, deleted),
    describe: () => `Delete [${start}:${end}]`,
  };
}
 
// ============================
// 汎用 Command ファクトリ（任意の操作をコマンドに）
// ============================
function makeCommand(
  doFn: () => void,
  undoFn: () => void,
  description: string
): FunctionalCommand {
  return {
    execute: doFn,
    undo: undoFn,
    describe: () => description,
  };
}
 
// ============================
// 関数型 UndoRedoManager
// ============================
function createUndoRedoManager() {
  const undoStack: FunctionalCommand[] = [];
  const redoStack: FunctionalCommand[] = [];
 
  return {
    execute(cmd: FunctionalCommand): void {
      cmd.execute();
      undoStack.push(cmd);
      redoStack.length = 0;
    },
    undo(): boolean {
      const cmd = undoStack.pop();
      if (!cmd) return false;
      cmd.undo();
      redoStack.push(cmd);
      return true;
    },
    redo(): boolean {
      const cmd = redoStack.pop();
      if (!cmd) return false;
      cmd.execute();
      undoStack.push(cmd);
      return true;
    },
    history(): string[] {
      return undoStack.map(c => c.describe());
    },
  };
}
 
// ============================
// 使用例: クラス不要の軽量 Command
// ============================
const ed = new TextEditor();
const mgr = createUndoRedoManager();
 
mgr.execute(createInsertCommand(ed, 0, 'Hello'));
mgr.execute(createInsertCommand(ed, 5, ' World'));
console.log(ed.getContent()); // "Hello World"
 
mgr.undo();
console.log(ed.getContent()); // "Hello"
 
// 任意の操作もコマンドに変換可能
let logBuffer: string[] = [];
mgr.execute(makeCommand(
  () => logBuffer.push('entry'),
  () => logBuffer.pop(),
  'Add log entry'
));

// command-bus.ts -- 型安全な Command ディスパッチ
 
// ============================
// Command と Handler の型定義
// ============================
interface TypedCommand<TName extends string, TPayload, TResult> {
  readonly type: TName;
  readonly payload: TPayload;
  // TResult は型レベルの情報のみ（実行時に使用しない）
  readonly __result?: TResult;
}
 
type CommandHandler<C extends TypedCommand<string, unknown, unknown>> =
  (command: C) => C extends TypedCommand<string, unknown, infer R> ? R : never;
 
// ============================
// Command バス
// ============================
class CommandBus {
  private handlers = new Map<string, CommandHandler<any>>();
  private middleware: Array<(
    command: TypedCommand<string, unknown, unknown>,
    next: () => unknown
  ) => unknown> = [];
 
  /** ハンドラの登録 */
  register<C extends TypedCommand<string, unknown, unknown>>(
    type: C['type'],
    handler: CommandHandler<C>
  ): void {
    this.handlers.set(type, handler);
  }
 
  /** ミドルウェアの追加（ロギング、認証等） */
  use(
    middleware: (
      command: TypedCommand<string, unknown, unknown>,
      next: () => unknown
    ) => unknown
  ): void {
    this.middleware.push(middleware);
  }
 
  /** コマンドのディスパッチ */
  dispatch<C extends TypedCommand<string, unknown, unknown>>(
    command: C
  ): C extends TypedCommand<string, unknown, infer R> ? R : never {
    const handler = this.handlers.get(command.type);
    if (!handler) {
      throw new Error(`No handler registered for command: ${command.type}`);
    }
 
    // ミドルウェアチェーンの構築
    const chain = this.middleware.reduceRight(
      (next, mw) => () => mw(command, next),
      () => handler(command)
    );
 
    return chain() as any;
  }
}
 
// ============================
// 具体的なコマンド定義
// ============================
type CreateOrderCommand = TypedCommand<
  'CreateOrder',
  { userId: string; items: Array<{ sku: string; qty: number }> },
  { orderId: string }
>;
 
type CancelOrderCommand = TypedCommand<
  'CancelOrder',
  { orderId: string; reason: string },
  { refundAmount: number }
>;
 
// ============================
// 使用例
// ============================
const bus = new CommandBus();
 
// ロギングミドルウェア
bus.use((command, next) => {
  console.log(`[CommandBus] Dispatching: ${command.type}`, command.payload);
  const start = performance.now();
  const result = next();
  const elapsed = performance.now() - start;
  console.log(`[CommandBus] Completed: ${command.type} (${elapsed.toFixed(2)}ms)`);
  return result;
});
 
// ハンドラ登録
bus.register<CreateOrderCommand>('CreateOrder', (cmd) => {
  console.log(`Creating order for user: ${cmd.payload.userId}`);
  return { orderId: `ORD-${Date.now()}` };
});
 
bus.register<CancelOrderCommand>('CancelOrder', (cmd) => {
  console.log(`Cancelling order: ${cmd.payload.orderId}`);
  return { refundAmount: 1500 };
});
 
// ディスパッチ（型安全: 戻り値が自動推論される）
const result = bus.dispatch<CreateOrderCommand>({
  type: 'CreateOrder',
  payload: { userId: 'u1', items: [{ sku: 'SKU-001', qty: 2 }] },
});
console.log(result.orderId); // 型安全: string

// ============================
// [NG] 1文字ごとにコマンドを生成
// ============================
// Undo が1文字ずつ戻る、メモリも浪費
manager.execute(new InsertTextCommand(editor, 0, 'H'));
manager.execute(new InsertTextCommand(editor, 1, 'e'));
manager.execute(new InsertTextCommand(editor, 2, 'l'));
manager.execute(new InsertTextCommand(editor, 3, 'l'));
manager.execute(new InsertTextCommand(editor, 4, 'o'));
// Undo 5回で "Hello" → "Hell" → "Hel" → "He" → "H" → ""
// ユーザーの期待: Undo 1回で "Hello" が消える
 
// ============================
// [OK] 意味のある単位でコマンドを生成
// ============================
// 入力をバッファリングし、一定時間の無入力でコマンドを確定
class BufferedTextInput {
  private buffer: string = '';
  private bufferStart: number = 0;
  private timer: ReturnType<typeof setTimeout> | null = null;
 
  constructor(
    private editor: TextEditor,
    private manager: UndoRedoManager,
    private debounceMs: number = 500
  ) {}
 
  /** 1文字入力のたびに呼ばれる */
  type(char: string): void {
    if (this.buffer === '') {
      this.bufferStart = this.editor.getCursorPosition();
    }
    // エディタに直接挿入（Command 経由ではない）
    this.editor.insertAt(this.editor.getCursorPosition(), char);
    this.buffer += char;
 
    // デバウンス: 一定時間入力がなければ Command を確定
    if (this.timer) clearTimeout(this.timer);
    this.timer = setTimeout(() => this.flush(), this.debounceMs);
  }
 
  /** Enter キーや操作切り替え時にも呼ぶ */
  flush(): void {
    if (this.buffer) {
      // ★ すでに editor には反映済みなので、
      //    undo 用に逆操作を記録するだけの Command を作る
      const text = this.buffer;
      const start = this.bufferStart;
      const cmd: Command = {
        isUndoable: true,
        execute: () => { /* 既に反映済み */ },
        undo: () => this.editor.deleteRange(start, start + text.length),
        describe: () => `Type "${text}"`,
      };
      // execute() は呼ばず、履歴にだけ追加
      this.manager['undoStack'].push(cmd);
      this.buffer = '';
    }
  }
}

// ============================
// [NG] undo() が実装されていない（空のメソッド）
// ============================
class SendEmailCommand implements Command {
  readonly isUndoable = true; // 嘘の宣言!
 
  execute(): void {
    emailService.send(this.email);
  }
 
  undo(): void {
    // 何もしない...?? 送信済みメールは取り消せないのに
    // isUndoable = true なので、ユーザーは Undo できると期待する
  }
 
  describe(): string { return `Send email to ${this.email}`; }
}
 
// ============================
// [OK 方法1] 補償アクション (Compensating Action) を定義
// ============================
class SendEmailCommandV2 implements Command {
  readonly isUndoable = true;
  private sentId: string | null = null;
 
  constructor(private email: string) {}
 
  execute(): void {
    // 即座に送信せず、「送信予約」にする（5分後に実送信）
    this.sentId = emailService.schedule(this.email, { delayMinutes: 5 });
  }
 
  undo(): void {
    if (this.sentId) {
      // 5分以内なら予約をキャンセル
      const cancelled = emailService.cancelScheduled(this.sentId);
      if (!cancelled) {
        // 既に送信済みの場合は取り消しメールを送信
        emailService.sendCancellation(this.sentId);
      }
    }
  }
 
  describe(): string { return `Schedule email to ${this.email}`; }
}
 
// ============================
// [OK 方法2] Undo 不可であることを明示的に宣言
// ============================
class IrreversibleSendEmailCommand implements Command {
  readonly isUndoable = false; // 正直に宣言
 
  constructor(private email: string) {}
 
  execute(): void {
    emailService.send(this.email);
  }
 
  undo(): void {
    throw new Error('Email sending cannot be undone');
  }
 
  describe(): string { return `Send email to ${this.email} (irreversible)`; }
}
 
// UndoRedoManager 側でも対応
class SafeUndoRedoManager extends UndoRedoManager {
  override undo(): boolean {
    const lastCmd = this['undoStack'][this['undoStack'].length - 1];
    if (lastCmd && !lastCmd.isUndoable) {
      console.warn(`Cannot undo: ${lastCmd.describe()} is irreversible`);
      return false;
    }
    return super.undo();
  }
}

// ============================
// [NG] 1つのコマンドに複数の責任を詰め込む
// ============================
class ProcessOrderCommand implements Command {
  readonly isUndoable = true;
 
  execute(): void {
    // 1つの Command に全ビジネスロジックが...
    this.validateOrder();
    this.calculateTax();
    this.applyDiscount();
    this.chargePayment();
    this.updateInventory();
    this.sendConfirmation();
    this.notifyWarehouse();
  }
 
  undo(): void {
    // 7つの逆操作を正しい順序で...
    // テスト不可能、バグの温床
  }
  // ...
}
 
// ============================
// [OK] 単一責任の小さな Command に分割し、MacroCommand で合成
// ============================
const processOrder = new MacroCommand([
  new ValidateOrderCommand(order),
  new CalculateTaxCommand(order),
  new ApplyDiscountCommand(order),
  new ChargePaymentCommand(order),
  new UpdateInventoryCommand(order),
  new SendConfirmationCommand(order),
  new NotifyWarehouseCommand(order),
], 'Process Order');
 
// 利点:
// - 各 Command が独立してテスト可能
// - 途中で失敗した場合、実行済みの Command だけ undo
// - 新しいステップの追加・削除が容易
// - 各 Command の再利用が可能

// ヒント: Canvas（Receiver）の定義
interface Shape {
  type: 'circle' | 'rect';
  id: string;
  // ...shape-specific properties
}
 
class DrawingCanvas {
  private shapes: Shape[] = [];
 
  addShape(shape: Shape): void { /* ... */ }
  removeShape(id: string): Shape | undefined { /* ... */ }
  clear(): Shape[] { /* ... */ }
  getShapes(): Shape[] { /* ... */ }
}

// ヒント: インターフェース
interface TransactionEngine {
  execute(commands: AsyncCommand[]): Promise<TransactionResult>;
}
 
interface TransactionResult {
  success: boolean;
  executedCount: number;
  failedCommand?: string;
  rolledBackCount?: number;
}

// ヒント: シリアライズ形式
interface SerializedCommand {
  type: string;
  params: Record<string, unknown>;
  timestamp: number;
}
 
interface ReplayEngine {
  record(command: Command): void;
  serialize(): string;
  deserialize(json: string): void;
  replay(receiver: TextEditor, speed?: number): Promise<void>;
}

// useUndoRedo カスタムフック
function useUndoRedo<T>(initialState: T) {
  const [state, setState] = useState(initialState);
  const undoStack = useRef<T[]>([]);
  const redoStack = useRef<T[]>([]);
 
  const execute = useCallback((newState: T) => {
    undoStack.current.push(state);
    redoStack.current = [];
    setState(newState);
  }, [state]);
 
  const undo = useCallback(() => {
    const prev = undoStack.current.pop();
    if (prev !== undefined) {
      redoStack.current.push(state);
      setState(prev);
    }
  }, [state]);
 
  const redo = useCallback(() => {
    const next = redoStack.current.pop();
    if (next !== undefined) {
      undoStack.current.push(state);
      setState(next);
    }
  }, [state]);
 
  return { state, execute, undo, redo,
    canUndo: undoStack.current.length > 0,
    canRedo: redoStack.current.length > 0,
  };
}