命令模式

// ==================== 命令接口 ====================

interface Command {
  execute(): void;
  undo(): void;
  /** 命令描述，用于日志与调试 */
  describe(): string;
}

// ==================== 接收者：文本缓冲区 ====================

class TextBuffer {
  private content = "";

  getContent(): string { return this.content; }
  setContent(content: string): void { this.content = content; }

  insert(position: number, text: string): void {
    this.content = this.content.slice(0, position) + text + this.content.slice(position);
  }
  delete(position: number, length: number): string {
    const removed = this.content.slice(position, position + length);
    this.content = this.content.slice(0, position) + this.content.slice(position + length);
    return removed;
  }
}

// ==================== 具体命令 ====================
class InsertCommand implements Command {
  private applied = false;
  constructor(
    private readonly buffer: TextBuffer,
    private readonly position: number,
    private readonly text: string
  ) {}
  execute(): void {
    if (!this.applied) { this.buffer.insert(this.position, this.text); this.applied = true; }
  }
  undo(): void {
    if (this.applied) { this.buffer.delete(this.position, this.text.length); this.applied = false; }
  }
  describe(): string { return `Insert "${this.text}" at position ${this.position}`; }
}

class DeleteCommand implements Command {
  private removed = "";
  private applied = false;
  constructor(
    private readonly buffer: TextBuffer,
    private readonly position: number,
    private readonly length: number
  ) {}
  execute(): void {
    if (!this.applied) { this.removed = this.buffer.delete(this.position, this.length); this.applied = true; }
  }
  undo(): void {
    if (this.applied) { this.buffer.insert(this.position, this.removed); this.applied = false; }
  }
  describe(): string { return `Delete ${this.length} chars at position ${this.position}`; }
}

// ==================== 调用者：编辑器 ====================
class Editor {
  private history: Command[] = [];
  private redo: Command[] = [];

  constructor(private readonly buffer: TextBuffer) {}

  execute(command: Command): void {
    command.execute();
    console.log(`[EXEC] ${command.describe()}`);
    this.history.push(command);
    this.redo.length = 0;
  }
  undo(): void {
    const cmd = this.history.pop();
    if (!cmd) return;
    cmd.undo();
    console.log(`[UNDO] ${cmd.describe()}`);
    this.redo.push(cmd);
  }
  redoAction(): void {
    const cmd = this.redo.pop();
    if (!cmd) return;
    cmd.execute();
    console.log(`[REDO] ${cmd.describe()}`);
    this.history.push(cmd);
  }
  getContent(): string { return this.buffer.getContent(); }
}

// ==================== 使用 ====================
const buffer = new TextBuffer();
buffer.setContent("Hello, World");
const editor = new Editor(buffer);
editor.execute(new DeleteCommand(buffer, 5, 7));
// [EXEC] Delete 7 chars at position 5
console.log(editor.getContent()); // "Hello"

editor.undo();
// [UNDO] Delete 7 chars at position 5
console.log(editor.getContent()); // "Hello, World"

// ==================== 泛型命令定义 ====================

interface Command<TState> {
  readonly type: string;
  execute(state: TState): TState;
  undo(state: TState): TState;
  describe(): string;
}

// ==================== 命令历史管理器 ====================

class CommandHistory<TState> {
  private undoStack: Command<TState>[] = [];
  private redoStack: Command<TState>[] = [];

  execute(state: TState, command: Command<TState>): TState {
    const newState = command.execute(state);
    this.undoStack.push(command);
    this.redoStack.length = 0;
    return newState;
  }

  undo(state: TState): TState {
    const command = this.undoStack.pop();
    if (!command) return state;
    this.redoStack.push(command);
    return command.undo(state);
  }

  redo(state: TState): TState {
    const command = this.redoStack.pop();
    if (!command) return state;
    this.undoStack.push(command);
    return command.execute(state);
  }

  canUndo(): boolean { return this.undoStack.length > 0; }
  canRedo(): boolean { return this.redoStack.length > 0; }
  size(): number { return this.undoStack.length; }

  clear(): void {
    this.undoStack.length = 0;
    this.redoStack.length = 0;
  }
}

// ==================== 宏命令实现 ====================

class MacroCommand<TState> implements Command<TState> {
  readonly type = 'MACRO';
  private readonly subCommands: Command<TState>[];

  constructor(
    subCommands: Command<TState>[],
    private readonly macroName: string = 'UnnamedMacro',
  ) {
    if (subCommands.length === 0) {
      throw new Error('MacroCommand requires at least one sub-command');
    }
    this.subCommands = subCommands;
  }

  execute(state: TState): TState {
    return this.subCommands.reduce((s, cmd) => cmd.execute(s), state);
  }
  undo(state: TState): TState {
    // 逆序撤销
    return [...this.subCommands].reverse().reduce((s, cmd) => cmd.undo(s), state);
  }
  describe(): string {
    return `MACRO[${this.macroName}](${this.subCommands.map((c) => c.describe()).join(' + ')})`;
  }
}

// ==================== 使用：画布批量操作 ====================
interface CanvasState {
  rects: Array<{ id: string; x: number; y: number; color: string }>;
}

const moveRectCommand = (id: string, dx: number, dy: number): Command<CanvasState> => ({
  type: 'MOVE_RECT',
  execute(state) {
    return { rects: state.rects.map((r) => r.id === id ? { ...r, x: r.x + dx, y: r.y + dy } : r) };
  },
  undo(state) {
    return { rects: state.rects.map((r) => r.id === id ? { ...r, x: r.x - dx, y: r.y - dy } : r) };
  },
  describe() { return `Move rect ${id} by (${dx},${dy})`; }
});

const colorRectCommand = (id: string, color: string): Command<CanvasState> => ({
  type: 'COLOR_RECT',
  execute(state) {
    return { rects: state.rects.map((r) => r.id === id ? { ...r, color } : r) };
  },
  undo(state) {
    return state; // 简化：不记录旧颜色
  },
  describe() { return `Color rect ${id} as ${color}`; }
});

const initialState: CanvasState = { rects: [{ id: 'rect-1', x: 10, y: 20, color: '#ff0000' }] };
const macroCmd = new MacroCommand<CanvasState>(
  [moveRectCommand('rect-1', 50, 30), colorRectCommand('rect-1', '#00ff00')],
  'MoveAndColor'
);

const history = new CommandHistory<CanvasState>();
const newState = history.execute(initialState, macroCmd);
// rect-1: { x: 60, y: 50, color: '#00ff00' }

const undoneState = history.undo(newState);
// rect-1: { x: 10, y: 20, color: '#00ff00' } -- 位置已撤销；颜色保持 #00ff00（colorRect 的 undo 为简化实现，未记录旧色）

// ==================== 异步命令接口 ====================

interface AsyncCommand<TState> {
  readonly type: string;
  readonly priority: number; // 数值越大优先级越高
  execute(state: TState): Promise<TState>;
  undo(state: TState): Promise<TState>;
  describe(): string;
}

// ==================== 优先级命令队列 ====================
class PriorityCommandQueue<TState> {
  private pending: AsyncCommand<TState>[] = [];
  private running = 0;
  private stats = { completed: 0, failed: 0, cancelled: 0 };

  enqueue(command: AsyncCommand<TState>): void {
    this.pending.push(command);
    this.pending.sort((a, b) => b.priority - a.priority); // 高优先级在前
  }

  async drain(initialState: TState): Promise<TState> {
    let state = initialState;
    while (this.pending.length > 0) {
      const command = this.pending.shift()!;
      try {
        state = await command.execute(state);
        this.stats.completed++;
      } catch (err) {
        this.stats.failed++;
        console.error(`命令失败: ${command.describe()}`, err);
      }
    }
    return state;
  }

  getQueueStats() {
    return { pending: this.pending.length, running: this.running, ...this.stats };
  }
}

// ==================== 使用：部署编排 ====================
interface DeployState {
  services: Map<string, string>; // service -> version
  order: string[];
}

class DeployServiceCommand implements AsyncCommand<DeployState> {
  readonly type = 'DEPLOY';
  constructor(
    private readonly service: string,
    private readonly version: string,
    readonly priority: number
  ) {}
  async execute(state: DeployState): Promise<DeployState> {
    await new Promise((r) => setTimeout(r, 10));
    const services = new Map(state.services).set(this.service, this.version);
    return { services, order: [...state.order, this.service] };
  }
  async undo(state: DeployState): Promise<DeployState> { return state; }
  describe(): string { return `部署 ${this.service}@${this.version}`; }
}

const deployQueue = new PriorityCommandQueue<DeployState>();
deployQueue.enqueue(new DeployServiceCommand('api-gateway', '1.5.0', 5));
deployQueue.enqueue(new DeployServiceCommand('frontend-app', '3.1.0', 1));
deployQueue.enqueue(new DeployServiceCommand('user-service', '2.0.0', 10));
deployQueue.enqueue(new DeployServiceCommand('order-service', '2.8.0', 8));

// 执行顺序按优先级：user-service(10) -> order-service(8) -> api-gateway(5) -> frontend-app(1)
const deployState: DeployState = { services: new Map(), order: [] };
const finalState = await deployQueue.drain(deployState);
console.log(deployQueue.getQueueStats());
// { pending: 0, running: 0, completed: 4, failed: 0, cancelled: 0 }

import { createStore } from 'redux';

// Redux action 就是命令对象的变体
interface AddTodoAction {
  readonly type: 'ADD_TODO';
  readonly payload: { id: string; text: string };
}

interface ToggleTodoAction {
  readonly type: 'TOGGLE_TODO';
  readonly payload: { id: string };
}

type TodoAction = AddTodoAction | ToggleTodoAction;

interface TodoItem { id: string; text: string; completed: boolean; }
type TodoState = TodoItem[];

// reducer 是接收者 —— 根据命令(action)产生新状态
function todoReducer(state: TodoState = [], action: TodoAction): TodoState {
  switch (action.type) {
    case 'ADD_TODO':
      return [...state, { id: action.payload.id, text: action.payload.text, completed: false }];
    case 'TOGGLE_TODO':
      return state.map((todo) =>
        todo.id === action.payload.id ? { ...todo, completed: !todo.completed } : todo
      );
    default:
      return state;
  }
}

// dispatch 是 Invoker —— 将命令传递给接收者
const store = createStore(todoReducer);
store.dispatch({ type: 'ADD_TODO', payload: { id: '1', text: 'Learn Command Pattern' } });

// ProseMirror Step 的简化模型
interface EditorStep {
  readonly stepType: string;
  readonly from: number;
  readonly to: number;
  readonly slice?: unknown;
  /** 应用此步骤，返回新文档和反向映射 */
  apply(doc: ProseMirrorDoc): StepResult;
  /** 生成反向步骤 */
  invert(doc: ProseMirrorDoc): EditorStep;
  /** 合并连续的相同类型步骤以压缩历史 */
  merge(other: EditorStep): EditorStep | null;
}

// 简化文档模型
interface ProseMirrorDoc { content: string; }
interface StepResult { doc: ProseMirrorDoc; }

// 操作栈（编辑器历史）
class EditorHistory {
  private stack: EditorStep[] = [];
  private undone: EditorStep[][] = [];

  addStep(step: EditorStep): void {
    // 尝试与顶部步骤合并以压缩历史
    const top = this.stack[this.stack.length - 1];
    const merged = top ? top.merge(step) : null;
    if (merged) this.stack[this.stack.length - 1] = merged;
    else this.stack.push(step);
    this.undone.length = 0;
  }

  undo(currentDoc: ProseMirrorDoc): ProseMirrorDoc {
    const step = this.stack.pop();
    if (!step) return currentDoc;
    const invertedSteps: EditorStep[] = [];
    let doc = currentDoc;
    // 逆序应用反向步骤
    const inverted = step.invert(doc);
    invertedSteps.push(inverted);
    doc = inverted.apply(doc).doc;

    this.undone.push(invertedSteps);
    return doc;
  }
}

interface Position {
  readonly x: number;
  readonly y: number;
}

interface DragState {
  elements: Map<string, Position>;
}

class DragCommand implements Command<DragState> {
  readonly type = 'DRAG';
  private oldPos: Position | null = null;

  constructor(
    private readonly elementId: string,
    private readonly newPos: Position
  ) {}

  execute(state: DragState): DragState {
    this.oldPos = state.elements.get(this.elementId) ?? null;
    const elements = new Map(state.elements);
    elements.set(this.elementId, this.newPos);
    return { elements };
  }
  undo(state: DragState): DragState {
    const elements = new Map(state.elements);
    if (this.oldPos) elements.set(this.elementId, this.oldPos);
    else elements.delete(this.elementId);
    return { elements };
  }
  describe(): string { return `拖动 ${this.elementId} 到 (${this.newPos.x}, ${this.newPos.y})`; }
}

// ==================== 使用 ====================
const getState = (): DragState => ({ elements: new Map() });
const setState = (s: DragState) => { console.log('状态更新:', [...s.elements]); };
const history = new CommandHistory<DragState>();
const historyCtx = history;

document.addEventListener('keydown', (e: KeyboardEvent) => {
  if (e.ctrlKey && e.key === 'z' && historyCtx.canUndo()) {
    setState(historyCtx.undo(getState()));
  }
});

interface FileSnapshot {
  readonly path: string;
  readonly content: string;
}

interface RepositoryState {
  readonly files: Map<string, string>;
  readonly HEAD: string;
}

class GitCommitCommand implements Command<RepositoryState> {
  readonly type = 'GIT_COMMIT';
  private commitHash: string;
  private committed = false;

  constructor(
    private readonly changes: FileSnapshot[],
    private readonly message: string
  ) {
    this.commitHash = `commit-${Math.random().toString(16).slice(2, 10)}`;
  }

  execute(state: RepositoryState): RepositoryState {
    if (this.committed) return state;
    const files = new Map(state.files);
    this.changes.forEach((c) => files.set(c.path, c.content));
    this.committed = true;
    return { files, HEAD: this.commitHash };
  }
  undo(state: RepositoryState): RepositoryState {
    if (!this.committed) return state;
    const files = new Map(state.files);
    this.changes.forEach((c) => files.delete(c.path));
    return { files, HEAD: 'HEAD~1' };
  }

  describe(): string {
    const fileList = this.changes.map((c) => c.path).join(', ');
    return `Commit ${this.commitHash.slice(0, 7)}: "${this.message}" [${fileList}]`;
  }
}

interface Memento<TState> {
  getState(): TState;
}

class Caretaker<TState> {
  private readonly mementos: Memento<TState>[] = [];

  push(memento: Memento<TState>): void {
    this.mementos.push(memento);
  }

  pop(): Memento<TState> | undefined {
    return this.mementos.pop();
  }
}

// 备忘录命令：命令执行时保存快照，undo 时恢复
class MementoCommand<TState> implements Command<TState> {
  readonly type = 'MEMENTO_COMMAND';
  private snapshot: TState | null = null;

  constructor(private readonly description: string) {}

  execute(state: TState): TState {
    this.snapshot = state; // 保存快照（实际应为深拷贝）
    return state;
  }
  undo(state: TState): TState {
    return this.snapshot ?? state; // 恢复到快照
  }

  describe(): string {
    return this.description;
  }
}

// 命令接口
interface Command {
    void execute();
    void undo();
}

// 接收者：实际执行操作的对象
class Light {
    private boolean on = false;

    public void on() {
        on = true;
        System.out.println("灯打开");
    }

    public void off() {
        on = false;
        System.out.println("灯关闭");
    }

    public boolean isOn() { return on; }
}

// 具体命令：开灯
class LightOnCommand implements Command {
    private final Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() { light.on(); }

    @Override
    public void undo() { light.off(); }
}

// 具体命令：关灯
class LightOffCommand implements Command {
    private final Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() { light.off(); }

    @Override
    public void undo() { light.on(); }
}

// 调用者/命令历史：支持撤销
class RemoteControl {
    private final java.util.Stack<Command> history = new java.util.Stack<>();

    public void press(Command command) {
        command.execute();
        history.push(command);
    }

    public void undo() {
        if (!history.isEmpty()) {
            history.pop().undo();
        }
    }
}

// 使用
public class Client {
    public static void main(String[] args) {
        Light light = new Light();
        RemoteControl remote = new RemoteControl();

        remote.press(new LightOnCommand(light));   // 开灯
        remote.press(new LightOffCommand(light));  // 关灯
        remote.undo();  // 撤销，回到开灯
    }
}

from abc import ABC, abstractmethod

class Command(ABC):
    @abstractmethod
    def execute(self):
        pass

    @abstractmethod
    def undo(self):
        pass

# 接收者
class Light:
    def __init__(self):
        self.is_on = False

    def on(self):
        self.is_on = True
        print("灯打开")

    def off(self):
        self.is_on = False
        print("灯关闭")

class LightOnCommand(Command):
    def __init__(self, light: Light):
        self._light = light

    def execute(self):
        self._light.on()

    def undo(self):
        self._light.off()

class LightOffCommand(Command):
    def __init__(self, light: Light):
        self._light = light

    def execute(self):
        self._light.off()

    def undo(self):
        self._light.on()

# 调用者：命令历史，支持撤销
class RemoteControl:
    def __init__(self):
        self._history = []

    def press(self, command: Command):
        command.execute()
        self._history.append(command)

    def undo(self):
        if self._history:
            self._history.pop().undo()

light = Light()
remote = RemoteControl()
remote.press(LightOnCommand(light))
remote.press(LightOffCommand(light))
remote.undo()  # 回到开灯