Command

interface Command {
    fun execute()
    fun undo()
}

class MoveShape(
    private val canvas: Canvas,
    private val shapeId: ShapeId,
    private val dx: Float,
    private val dy: Float,
) : Command {
    override fun execute() = canvas.move(shapeId, dx, dy)
    override fun undo() = canvas.move(shapeId, -dx, -dy)
}

class History {
    private val undoStack = ArrayDeque<Command>()
    private val redoStack = ArrayDeque<Command>()

    fun perform(command: Command) {
        command.execute()
        undoStack.addLast(command)
        redoStack.clear()                     // a new action makes redo history invalid
    }
    fun undo() {
        val command = undoStack.removeLastOrNull() ?: return
        command.undo()
        redoStack.addLast(command)
    }
    fun redo() {
        val command = redoStack.removeLastOrNull() ?: return
        command.execute()
        undoStack.addLast(command)
    }
}

public interface Command {
    void execute();
    void undo();
}

public final class MoveShape implements Command {
    private final Canvas canvas;
    private final ShapeId shapeId;
    private final float dx, dy;

    public MoveShape(Canvas canvas, ShapeId shapeId, float dx, float dy) {
        this.canvas = canvas; this.shapeId = shapeId; this.dx = dx; this.dy = dy;
    }
    public void execute() { canvas.move(shapeId, dx, dy); }
    public void undo() { canvas.move(shapeId, -dx, -dy); }
}

public final class History {
    private final Deque<Command> undoStack = new ArrayDeque<>();
    private final Deque<Command> redoStack = new ArrayDeque<>();

    public void perform(Command command) {
        command.execute();
        undoStack.push(command);
        redoStack.clear();                    // a new action makes redo history invalid
    }
    public void undo() {
        Command command = undoStack.poll();
        if (command == null) return;
        command.undo();
        redoStack.push(command);
    }
    public void redo() {
        Command command = redoStack.poll();
        if (command == null) return;
        command.execute();
        undoStack.push(command);
    }
}

interface Command {
  execute(): void;
  undo(): void;
}

class MoveShape implements Command {
  constructor(
    private readonly canvas: Canvas,
    private readonly shapeId: string,
    private readonly dx: number,
    private readonly dy: number,
  ) {}
  execute(): void { this.canvas.move(this.shapeId, this.dx, this.dy); }
  undo(): void { this.canvas.move(this.shapeId, -this.dx, -this.dy); }
}

class History {
  private undoStack: Command[] = [];
  private redoStack: Command[] = [];

  perform(command: Command): void {
    command.execute();
    this.undoStack.push(command);
    this.redoStack = [];                      // a new action makes redo history invalid
  }
  undo(): void {
    const command = this.undoStack.pop();
    if (!command) return;
    command.undo();
    this.redoStack.push(command);
  }
  redo(): void {
    const command = this.redoStack.pop();
    if (!command) return;
    command.execute();
    this.undoStack.push(command);
  }
}

@Serializable
sealed interface NoteCommand {
    @Serializable data class Create(val id: String, val title: String) : NoteCommand
    @Serializable data class Rename(val id: String, val title: String) : NoteCommand
    @Serializable data class Delete(val id: String) : NoteCommand
}

@Entity(tableName = "command_queue")
data class QueuedCommand(
    @PrimaryKey val commandId: String = UUID.randomUUID().toString(),   // for idempotency
    val payload: String,                                                 // JSON of NoteCommand
    val createdAt: Long = System.currentTimeMillis(),
)

class CommandQueue(private val dao: CommandDao, private val api: NotesApi, private val json: Json) {
    suspend fun enqueue(command: NoteCommand) =
        dao.insert(QueuedCommand(payload = json.encodeToString(command)))

    suspend fun drain(): Boolean {            // called from a WorkManager worker
        while (true) {
            val next = dao.oldest() ?: return true
            try {
                api.send(next.commandId, json.decodeFromString<NoteCommand>(next.payload))
                dao.delete(next)
            } catch (e: IOException) {
                return false                  // retry later, in order
            }
        }
    }
}

public sealed interface NoteCommand permits CreateNote, RenameNote, DeleteNote {}
public record CreateNote(String id, String title) implements NoteCommand {}
public record RenameNote(String id, String title) implements NoteCommand {}
public record DeleteNote(String id) implements NoteCommand {}

public record QueuedCommand(String commandId, NoteCommand command, Instant createdAt) {}

public final class CommandQueue {
    private final QueueStore store;           // persisted
    private final NotesApi api;

    public CommandQueue(QueueStore store, NotesApi api) { this.store = store; this.api = api; }

    public void enqueue(NoteCommand command) {
        store.append(new QueuedCommand(UUID.randomUUID().toString(), command, Instant.now()));
    }

    public boolean drain() {
        Optional<QueuedCommand> next;
        while ((next = store.oldest()).isPresent()) {
            try {
                api.send(next.get());             // server ignores a commandId it has seen
                store.remove(next.get());
            } catch (UncheckedIOException e) {
                return false;                     // retry later, in order
            }
        }
        return true;
    }
}

type NoteCommand =
  | { type: "create"; id: string; title: string }
  | { type: "rename"; id: string; title: string }
  | { type: "delete"; id: string };

interface QueuedCommand { commandId: string; command: NoteCommand; createdAt: number }

class CommandQueue {
  constructor(private readonly store: QueueStore, private readonly api: NotesApi) {}  // e.g. IndexedDB

  async enqueue(command: NoteCommand): Promise<void> {
    await this.store.append({ commandId: crypto.randomUUID(), command, createdAt: Date.now() });
  }

  async drain(): Promise<boolean> {
    for (let next = await this.store.oldest(); next; next = await this.store.oldest()) {
      try {
        await this.api.send(next);            // server ignores a commandId it has seen
        await this.store.remove(next.commandId);
      } catch {
        return false;                         // offline: retry later, in order
      }
    }
    return true;
  }
}