alma 0.1.1

//! Normal and visual Vim action dispatch for the ECS adapter.

use super::{
    effects::{VimEffect, VimEffectBatch},
    insert::enter_insert_mode,
    keyboard::{VimInputState, normalized_editor_tokens},
    status::push_status_effect_from_line,
};
use crate::{
    buffer::BufferEdit,
    ecs::{
        components::buffer::{BufferEntity, ViewEntity},
        events::{
            edit::{BufferEditRequested, EditHistoryRequested},
            input::{EditorInputEvent, VimInputRejected, VimInputRejectionReason},
            intent::ViewportIntent,
            status::{StatusMessage, StatusMessageRequested},
        },
    },
    text_stream::TextByteStream,
    vim::{
        ActionContext, ActionDispatcher, Count, InsertEntry, KeyToken, LeaderState, NormalCommand,
        NormalGrammarOutput, NormalState, OperationEffect, OperationOutcome, Operator,
        PastePlacement, PastePlanError, RegisterBank, RegisterName, VimAction, VimCommandState,
        VimConfig, VimCursor, VimMode, VimOperation, VimSearchState, VimSelectionState,
        VimStatusLine, VisualCommandContext, VisualGrammarOutput, VisualState, plan_paste,
        repeat::{RepeatState, RepeatableOperation},
    },
};
use bevy::prelude::MessageWriter;

/// Maximum count-expanded paste payload accepted from one request.
const MAX_PASTE_TEXT_BYTES_PER_REQUEST: usize = 1024 * 1024;

/// Normal-input context.
pub(super) struct NormalInputContext<'state, 'writer> {
    /// Authoritative text stream snapshot.
    pub(super) stream: &'state TextByteStream,
    /// Text.
    pub(super) text: &'state str,
    /// Cursor state.
    pub(super) cursor: &'state mut VimCursor,
    /// Mode.
    pub(super) mode: &'state mut VimMode,
    /// Selection.
    pub(super) selection_state: &'state mut VimSelectionState,
    /// Search.
    pub(super) search_state: &'state mut VimSearchState,
    /// Command-line state.
    pub(super) command_state: &'state mut VimCommandState,
    /// Status.
    pub(super) status_line: &'state mut VimStatusLine,
    /// Pending ECS effects.
    pub(super) effects: &'state mut VimEffectBatch,
    /// View.
    pub(super) target: ViewEntity,
    /// Target buffer.
    pub(super) buffer_target: BufferEntity,
    /// View-local registers.
    pub(super) registers: &'state mut RegisterBank,
    /// View-local dot-repeat state.
    pub(super) repeat_state: &'state mut RepeatState,
    /// Leader.
    pub(super) leader_state: &'state mut LeaderState,
    /// Normal controller.
    pub(super) normal_state: &'state mut NormalState,
    /// Visual controller.
    pub(super) visual_state: &'state mut VisualState,
    /// Device input state.
    pub(super) input_state: &'state mut VimInputState,
    /// Input rejection notifications.
    pub(super) rejected: &'state mut MessageWriter<'writer, VimInputRejected>,
    /// Config.
    pub(super) vim_config: &'state VimConfig,
    /// Viewport height.
    pub(super) visible_line_count: usize,
    /// Inputs for this frame.
    pub(super) input_events: &'state [EditorInputEvent],
    /// Frame delta.
    pub(super) delta_millis: u64,
}

/// Handles normal/visual tokens.
pub(super) fn handle_normal_input(mut context: NormalInputContext<'_, '_>) {
    context
        .leader_state
        .tick(context.delta_millis, context.vim_config.leader.delay_ms);

    let tokens = normalized_editor_tokens(context.input_events).collect::<Vec<_>>();
    for token in tokens {
        if handle_normal_token(&mut context, token).is_done() {
            return;
        }
    }

    if context.leader_state.is_pending() || context.leader_state.is_menu_visible() {
        context.input_state.repeat.cancel();
        return;
    }

    context.input_state.repeat.cancel();
}

/// Token handling outcome.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum NormalTokenOutcome {
    /// Keep reading.
    Continue,
    /// Stop reading.
    Done,
}

impl NormalTokenOutcome {
    /// Is terminal.
    const fn is_done(self) -> bool {
        matches!(self, Self::Done)
    }
}

/// Handles one normal/visual token.
fn handle_normal_token(
    context: &mut NormalInputContext<'_, '_>,
    token: KeyToken,
) -> NormalTokenOutcome {
    if *context.mode == VimMode::Normal {
        if token == context.vim_config.leader.key && !context.leader_state.is_pending() {
            context.normal_state.reset_grammar();
            context.input_state.repeat.cancel();
            context.leader_state.start();
            return NormalTokenOutcome::Done;
        }

        if context.leader_state.is_pending() || context.leader_state.is_menu_visible() {
            dispatch_leader_token(context, token);
            return NormalTokenOutcome::Done;
        }
    }

    if let VimMode::Visual(active_visual_mode) = *context.mode {
        match context.visual_state.feed(
            token,
            VisualCommandContext {
                text: context.text,
                cursor: context.cursor,
                mode: context.mode,
                active_visual_mode,
                selection_state: context.selection_state,
                normal_state: context.normal_state,
            },
        ) {
            VisualGrammarOutput::Command(command) => {
                context.leader_state.cancel();
                context.input_state.repeat.cancel();
                if let Some(operation) =
                    command.operator_operation(context.selection_state, active_visual_mode)
                {
                    let result = dispatch_operator_operation(
                        operation,
                        OperatorDispatchContext {
                            stream: context.stream,
                            cursor: context.cursor,
                            mode: context.mode,
                            buffer_target: context.buffer_target,
                            registers: context.registers,
                            effects: context.effects,
                            repeat_state: None,
                        },
                    );
                    if result.is_applied() {
                        if !result.entered_insert() {
                            *context.mode = VimMode::Normal;
                        }
                        context.selection_state.clear();
                    }
                }
                return NormalTokenOutcome::Done;
            }
            VisualGrammarOutput::Unmatched => {
                context.leader_state.cancel();
                context.input_state.repeat.cancel();
                return NormalTokenOutcome::Done;
            }
            VisualGrammarOutput::Pending => {
                context.leader_state.cancel();
                return NormalTokenOutcome::Done;
            }
        }
    }

    match context.normal_state.feed_command(token) {
        NormalGrammarOutput::Command(command) => {
            dispatch_completed_normal_command(
                command,
                CompletedNormalCommandContext {
                    stream: context.stream,
                    text: context.text,
                    cursor: context.cursor,
                    mode: context.mode,
                    selection_state: context.selection_state,
                    search_state: context.search_state,
                    command_state: context.command_state,
                    status_line: context.status_line,
                    normal_state: context.normal_state,
                    visible_line_count: context.visible_line_count,
                    options: &context.vim_config.options,
                    effects: context.effects,
                    target: context.target,
                    buffer_target: context.buffer_target,
                    registers: context.registers,
                    repeat_state: context.repeat_state,
                    rejected: context.rejected,
                },
            );
            context.leader_state.cancel();
            context.input_state.repeat.cancel();
            NormalTokenOutcome::Done
        }
        NormalGrammarOutput::Pending => {
            context.leader_state.cancel();
            NormalTokenOutcome::Done
        }
        NormalGrammarOutput::Unmatched => {
            context.leader_state.cancel();
            NormalTokenOutcome::Continue
        }
    }
}

/// Dispatches a pending leader token.
fn dispatch_leader_token(context: &mut NormalInputContext<'_, '_>, token: KeyToken) {
    if let Some(binding) = context.vim_config.leader.binding_for(&[token]) {
        ActionDispatcher::dispatch(
            &binding.action,
            ActionContext {
                text: context.text,
                cursor: context.cursor,
                mode: context.mode,
                selection_state: context.selection_state,
                search_state: context.search_state,
                command_state: context.command_state,
                status_line: context.status_line,
                normal_state: context.normal_state,
                visible_line_count: context.visible_line_count,
                options: &context.vim_config.options,
            },
        );
        push_status_effect_from_line(context.target, context.status_line, context.effects);
    }
    context.leader_state.cancel();
    context.input_state.repeat.cancel();
}

/// Completed normal-command context.
struct CompletedNormalCommandContext<'state, 'writer> {
    /// Authoritative text stream snapshot.
    stream: &'state TextByteStream,
    /// Text.
    text: &'state str,
    /// Cursor state.
    cursor: &'state mut VimCursor,
    /// Mode.
    mode: &'state mut VimMode,
    /// Selection.
    selection_state: &'state mut VimSelectionState,
    /// Search.
    search_state: &'state mut VimSearchState,
    /// Command-line state.
    command_state: &'state mut VimCommandState,
    /// Status.
    status_line: &'state mut VimStatusLine,
    /// Normal controller.
    normal_state: &'state mut NormalState,
    /// Viewport height.
    visible_line_count: usize,
    /// Search options.
    options: &'state crate::vim::config::VimOptions,
    /// Pending ECS effects.
    effects: &'state mut VimEffectBatch,
    /// View.
    target: ViewEntity,
    /// Target buffer.
    buffer_target: BufferEntity,
    /// View-local registers.
    registers: &'state mut RegisterBank,
    /// View-local dot-repeat state.
    repeat_state: &'state mut RepeatState,
    /// Input rejection notifications.
    rejected: &'state mut MessageWriter<'writer, VimInputRejected>,
}

/// Dispatches a completed normal-mode command.
fn dispatch_completed_normal_command(
    command: NormalCommand,
    context: CompletedNormalCommandContext<'_, '_>,
) {
    let CompletedNormalCommandContext {
        stream,
        text,
        cursor,
        mode,
        selection_state,
        search_state,
        command_state,
        status_line,
        normal_state,
        visible_line_count,
        options,
        effects,
        target,
        buffer_target,
        registers,
        repeat_state,
        rejected,
    } = context;
    if dispatch_viewport_position(command, target, effects) {
        return;
    }
    if dispatch_normal_insert_command(
        command,
        NormalInsertDispatchContext {
            text,
            cursor,
            mode,
            selection_state,
            target,
            buffer_target,
            effects,
        },
    ) {
        return;
    }
    dispatch_non_insert_normal_command(
        command,
        NonInsertNormalDispatchContext {
            stream,
            text,
            cursor,
            mode,
            selection_state,
            search_state,
            command_state,
            status_line,
            normal_state,
            visible_line_count,
            options,
            effects,
            target,
            buffer_target,
            registers,
            repeat_state,
            rejected,
        },
    );
}

/// State needed after viewport and insert commands have been handled.
struct NonInsertNormalDispatchContext<'state, 'writer> {
    /// Authoritative text stream snapshot.
    stream: &'state TextByteStream,
    /// Text.
    text: &'state str,
    /// Cursor state.
    cursor: &'state mut VimCursor,
    /// Mode.
    mode: &'state mut VimMode,
    /// Selection.
    selection_state: &'state mut VimSelectionState,
    /// Search.
    search_state: &'state mut VimSearchState,
    /// Command-line state.
    command_state: &'state mut VimCommandState,
    /// Status.
    status_line: &'state mut VimStatusLine,
    /// Normal controller.
    normal_state: &'state mut NormalState,
    /// Viewport height.
    visible_line_count: usize,
    /// Search options.
    options: &'state crate::vim::config::VimOptions,
    /// Pending ECS effects.
    effects: &'state mut VimEffectBatch,
    /// View.
    target: ViewEntity,
    /// Target buffer.
    buffer_target: BufferEntity,
    /// View-local registers.
    registers: &'state mut RegisterBank,
    /// View-local dot-repeat state.
    repeat_state: &'state mut RepeatState,
    /// Input rejection notifications.
    rejected: &'state mut MessageWriter<'writer, VimInputRejected>,
}

/// Dispatches normal commands that are not viewport or insert entries.
fn dispatch_non_insert_normal_command(
    command: NormalCommand,
    context: NonInsertNormalDispatchContext<'_, '_>,
) {
    let NonInsertNormalDispatchContext {
        stream,
        text,
        cursor,
        mode,
        selection_state,
        search_state,
        command_state,
        status_line,
        normal_state,
        visible_line_count,
        options,
        effects,
        target,
        buffer_target,
        registers,
        repeat_state,
        rejected,
    } = context;
    if dispatch_normal_operator_command(
        command,
        NormalOperatorDispatchContext {
            stream,
            cursor,
            mode,
            buffer_target,
            registers,
            effects,
            repeat_state,
        },
    ) {
        return;
    }
    if dispatch_normal_paste_command(
        command,
        NormalPasteDispatchContext {
            text,
            cursor,
            target,
            buffer_target,
            registers,
            effects,
            repeat_state,
            rejected,
        },
    ) {
        return;
    }
    if dispatch_repeat_last_change(
        command,
        repeat_state,
        RepeatDispatchContext {
            stream,
            text,
            cursor,
            target,
            buffer_target,
            mode,
            registers,
            effects,
            rejected,
        },
    ) {
        return;
    }
    if dispatch_edit_history_command(command, buffer_target, effects) {
        return;
    }
    dispatch_pure_normal_command(
        command,
        PureNormalDispatchContext {
            text,
            cursor,
            mode,
            selection_state,
            search_state,
            command_state,
            status_line,
            normal_state,
            visible_line_count,
            options,
        },
    );
    push_status_effect_from_line(target, status_line, effects);
}

/// State needed to adapt a normal insert-entry command.
struct NormalInsertDispatchContext<'state> {
    /// Buffer text snapshot.
    text: &'state str,
    /// Cursor state.
    cursor: &'state VimCursor,
    /// Mode state.
    mode: &'state mut VimMode,
    /// Selection state.
    selection_state: &'state mut VimSelectionState,
    /// View target.
    target: ViewEntity,
    /// Target buffer.
    buffer_target: BufferEntity,
    /// Pending ECS effects.
    effects: &'state mut VimEffectBatch,
}

/// Emits insert-entry effects when the command enters insert mode.
fn dispatch_normal_insert_command(
    command: NormalCommand,
    context: NormalInsertDispatchContext<'_>,
) -> bool {
    let NormalCommand::Insert(entry) = command else {
        return false;
    };
    let NormalInsertDispatchContext {
        text,
        cursor,
        mode,
        selection_state,
        target,
        buffer_target,
        effects,
    } = context;
    dispatch_insert_entry(
        entry,
        InsertEntryDispatchContext {
            text,
            cursor,
            mode,
            selection_state,
            target,
            buffer_target,
            effects,
        },
    );
    true
}

/// State needed to dispatch a pure normal command without ECS effects.
struct PureNormalDispatchContext<'state> {
    /// Buffer text snapshot.
    text: &'state str,
    /// Cursor state.
    cursor: &'state mut VimCursor,
    /// Mode state.
    mode: &'state mut VimMode,
    /// Selection state.
    selection_state: &'state mut VimSelectionState,
    /// Search state.
    search_state: &'state mut VimSearchState,
    /// Command-line state.
    command_state: &'state mut VimCommandState,
    /// Status line.
    status_line: &'state mut VimStatusLine,
    /// Normal controller.
    normal_state: &'state mut NormalState,
    /// Visible viewport line count.
    visible_line_count: usize,
    /// Search options.
    options: &'state crate::vim::config::VimOptions,
}

/// Dispatches normal commands that remain pure Vim state changes.
fn dispatch_pure_normal_command(command: NormalCommand, context: PureNormalDispatchContext<'_>) {
    let PureNormalDispatchContext {
        text,
        cursor,
        mode,
        selection_state,
        search_state,
        command_state,
        status_line,
        normal_state,
        visible_line_count,
        options,
    } = context;

    ActionDispatcher::dispatch(
        &VimAction::NormalCommand(command),
        ActionContext {
            text,
            cursor,
            mode,
            selection_state,
            search_state,
            command_state,
            status_line,
            normal_state,
            visible_line_count,
            options,
        },
    );
}

/// Emits viewport effects when the command is a viewport placement.
fn dispatch_viewport_position(
    command: NormalCommand,
    target: ViewEntity,
    effects: &mut VimEffectBatch,
) -> bool {
    let NormalCommand::ViewportPosition(position) = command else {
        return false;
    };

    effects.push(VimEffect::Viewport(ViewportIntent {
        target,
        placement: position,
    }));
    effects.push(VimEffect::Status(StatusMessageRequested {
        target,
        message: StatusMessage::Clear,
    }));
    true
}

/// State needed to adapt a normal operator command.
struct NormalOperatorDispatchContext<'state> {
    /// Authoritative text stream snapshot.
    stream: &'state TextByteStream,
    /// Cursor state.
    cursor: &'state mut VimCursor,
    /// Mode state.
    mode: &'state mut VimMode,
    /// Target buffer.
    buffer_target: BufferEntity,
    /// View-local registers.
    registers: &'state mut RegisterBank,
    /// Pending ECS effects.
    effects: &'state mut VimEffectBatch,
    /// View-local repeat state.
    repeat_state: &'state mut RepeatState,
}

/// Emits operator effects when the command is a normal-mode operator.
fn dispatch_normal_operator_command(
    command: NormalCommand,
    context: NormalOperatorDispatchContext<'_>,
) -> bool {
    if !matches!(command, NormalCommand::Operator { .. }) {
        return false;
    }
    let NormalOperatorDispatchContext {
        stream,
        cursor,
        mode,
        buffer_target,
        registers,
        effects,
        repeat_state,
    } = context;
    let operation = VimOperation::from(command);
    let _applied = dispatch_operator_operation(
        operation.clone(),
        OperatorDispatchContext {
            stream,
            cursor,
            mode,
            buffer_target,
            registers,
            effects,
            repeat_state: RepeatableOperation::from_operation(operation)
                .map(|operation| (repeat_state, operation)),
        },
    );
    true
}

/// State needed to adapt a normal paste command.
struct NormalPasteDispatchContext<'state, 'writer> {
    /// Buffer text snapshot.
    text: &'state str,
    /// Cursor state.
    cursor: &'state VimCursor,
    /// View target.
    target: ViewEntity,
    /// Target buffer.
    buffer_target: BufferEntity,
    /// View-local registers.
    registers: &'state RegisterBank,
    /// Pending ECS effects.
    effects: &'state mut VimEffectBatch,
    /// View-local repeat state.
    repeat_state: &'state mut RepeatState,
    /// Input rejection notifications.
    rejected: &'state mut MessageWriter<'writer, VimInputRejected>,
}

/// Emits paste effects when the command is a normal-mode paste.
fn dispatch_normal_paste_command(
    command: NormalCommand,
    context: NormalPasteDispatchContext<'_, '_>,
) -> bool {
    let NormalCommand::Paste { count, placement } = command else {
        return false;
    };
    let NormalPasteDispatchContext {
        text,
        cursor,
        target,
        buffer_target,
        registers,
        effects,
        repeat_state,
        rejected,
    } = context;
    if dispatch_paste_command(PasteDispatchContext {
        text,
        cursor,
        target,
        buffer_target,
        registers,
        count,
        placement,
        effects,
        rejected,
    }) && let Some(operation) =
        RepeatableOperation::from_operation(VimOperation::Paste { count, placement })
    {
        repeat_state.record(operation);
    }
    true
}

/// Replays dot-repeat when requested by the normal command.
fn dispatch_repeat_last_change(
    command: NormalCommand,
    repeat_state: &RepeatState,
    context: RepeatDispatchContext<'_, '_>,
) -> bool {
    if command != NormalCommand::RepeatLastChange {
        return false;
    }
    if let Some(operation) = repeat_state.last_change() {
        dispatch_repeat_operation(&operation, context);
    }
    true
}

/// Emits undo or redo effects when requested by the normal command.
fn dispatch_edit_history_command(
    command: NormalCommand,
    buffer_target: BufferEntity,
    effects: &mut VimEffectBatch,
) -> bool {
    let request = match command {
        NormalCommand::Undo => EditHistoryRequested::undo(buffer_target),
        NormalCommand::Redo => EditHistoryRequested::redo(buffer_target),
        _ => return false,
    };
    effects.push(VimEffect::EditHistory(request));
    true
}

/// State needed to adapt paste into ECS-facing effects.
struct PasteDispatchContext<'state, 'writer> {
    /// Buffer text snapshot.
    text: &'state str,
    /// Cursor state.
    cursor: &'state VimCursor,
    /// View target.
    target: ViewEntity,
    /// Target buffer.
    buffer_target: BufferEntity,
    /// View-local registers.
    registers: &'state RegisterBank,
    /// Paste count.
    count: Count,
    /// Paste side.
    placement: PastePlacement,
    /// Pending ECS effects.
    effects: &'state mut VimEffectBatch,
    /// Input rejection notifications.
    rejected: &'state mut MessageWriter<'writer, VimInputRejected>,
}

/// Emits a paste edit and post-paste cursor request for the unnamed register.
fn dispatch_paste_command(context: PasteDispatchContext<'_, '_>) -> bool {
    let PasteDispatchContext {
        text,
        cursor,
        target,
        buffer_target,
        registers,
        count,
        placement,
        effects,
        rejected,
    } = context;
    let Some(register) = registers.get(RegisterName::Unnamed) else {
        return false;
    };

    let plan = match plan_paste(
        text,
        cursor.byte_index(),
        register,
        count,
        placement,
        MAX_PASTE_TEXT_BYTES_PER_REQUEST,
    ) {
        Ok(plan) => plan,
        Err(PastePlanError::EmptyRegister) => return false,
        Err(PastePlanError::PayloadTooLarge {
            requested_byte_len,
            max_byte_len,
        }) => {
            let _sent = rejected.write(VimInputRejected {
                target,
                reason: VimInputRejectionReason::PastePayloadTooLarge {
                    target,
                    rejected_byte_len: requested_byte_len,
                    max_byte_len,
                },
            });
            return false;
        }
    };
    let insert_at = plan.byte_index();
    let cursor_byte_index = plan.cursor_byte_index();

    effects.push(VimEffect::BufferEdit(BufferEditRequested {
        target: buffer_target,
        edit: BufferEdit::insert(insert_at, plan.into_text()),
    }));
    if cursor.byte_index() != cursor_byte_index || cursor.desired_column().is_some() {
        effects.push(VimEffect::CursorMove(
            crate::ecs::events::cursor::CursorMoveRequested::cursor_cell(
                target,
                crate::ecs::components::cursor::ByteIndex(cursor_byte_index),
                None,
            ),
        ));
    }
    true
}

/// State needed to replay one dot-repeat operation.
struct RepeatDispatchContext<'state, 'writer> {
    /// Authoritative text stream snapshot.
    stream: &'state TextByteStream,
    /// Buffer text snapshot.
    text: &'state str,
    /// Cursor state.
    cursor: &'state mut VimCursor,
    /// View target.
    target: ViewEntity,
    /// Target buffer.
    buffer_target: BufferEntity,
    /// Mode state.
    mode: &'state mut VimMode,
    /// View-local registers.
    registers: &'state mut RegisterBank,
    /// Pending ECS effects.
    effects: &'state mut VimEffectBatch,
    /// Input rejection notifications.
    rejected: &'state mut MessageWriter<'writer, VimInputRejected>,
}

/// Replays a stored semantic operation without touching repeat state.
fn dispatch_repeat_operation(
    operation: &RepeatableOperation,
    context: RepeatDispatchContext<'_, '_>,
) {
    let RepeatDispatchContext {
        stream,
        text,
        cursor,
        target,
        buffer_target,
        mode,
        registers,
        effects,
        rejected,
    } = context;

    match operation.operation() {
        VimOperation::ApplyOperator { .. } => {
            let _result = dispatch_operator_operation(
                operation.operation(),
                OperatorDispatchContext {
                    stream,
                    cursor,
                    mode,
                    buffer_target,
                    registers,
                    effects,
                    repeat_state: None,
                },
            );
        }
        VimOperation::Paste { count, placement } => {
            let _applied = dispatch_paste_command(PasteDispatchContext {
                text,
                cursor,
                target,
                buffer_target,
                registers,
                count,
                placement,
                effects,
                rejected,
            });
        }
        _ => {}
    }
}

/// State needed to adapt insert-entry commands into ECS-facing effects.
struct InsertEntryDispatchContext<'state> {
    /// Buffer text snapshot.
    text: &'state str,
    /// Cursor state.
    cursor: &'state VimCursor,
    /// Mode state.
    mode: &'state mut VimMode,
    /// Selection state.
    selection_state: &'state mut VimSelectionState,
    /// View target.
    target: ViewEntity,
    /// Target buffer.
    buffer_target: BufferEntity,
    /// Pending ECS effects.
    effects: &'state mut VimEffectBatch,
}

/// Emits mode/cursor/edit requests for one insert-entry command.
fn dispatch_insert_entry(entry: InsertEntry, context: InsertEntryDispatchContext<'_>) {
    let InsertEntryDispatchContext {
        text,
        cursor,
        mode,
        selection_state,
        target,
        buffer_target,
        effects,
        ..
    } = context;

    selection_state.clear();
    enter_insert_mode(
        entry,
        text,
        cursor.byte_index(),
        mode,
        target,
        buffer_target,
        effects,
    );
}

/// State needed to adapt pure operator outcomes into ECS-facing effects.
struct OperatorDispatchContext<'state> {
    /// Authoritative text stream snapshot.
    stream: &'state TextByteStream,
    /// Cursor state for local post-operator placement.
    cursor: &'state mut VimCursor,
    /// Mode state.
    mode: &'state mut VimMode,
    /// Target buffer.
    buffer_target: BufferEntity,
    /// View-local registers.
    registers: &'state mut RegisterBank,
    /// Pending ECS effects.
    effects: &'state mut VimEffectBatch,
    /// Repeat state to update if this operation completes.
    repeat_state: Option<(&'state mut RepeatState, RepeatableOperation)>,
}

/// Result of adapting a resolved operator outcome.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum OperatorDispatchResult {
    /// No adapter-visible effect was emitted.
    NotApplied,
    /// Operator completed and remains in normal mode.
    AppliedNormal,
    /// Operator completed and entered insert mode.
    AppliedInsert,
}

impl OperatorDispatchResult {
    /// Returns whether the operator completed.
    const fn is_applied(self) -> bool {
        !matches!(self, Self::NotApplied)
    }

    /// Returns whether completion entered insert mode.
    const fn entered_insert(self) -> bool {
        matches!(self, Self::AppliedInsert)
    }
}

/// Resolves and emits ECS-facing effects for a pure operator operation.
fn dispatch_operator_operation(
    operation: VimOperation,
    context: OperatorDispatchContext<'_>,
) -> OperatorDispatchResult {
    let OperatorDispatchContext {
        stream,
        cursor,
        mode,
        buffer_target,
        registers,
        effects,
        repeat_state,
    } = context;

    let Ok(outcome) = operation.resolve(stream, cursor.byte_index()) else {
        return OperatorDispatchResult::NotApplied;
    };

    let result = emit_operator_outcome(
        outcome,
        OperatorOutcomeEmitContext {
            stream,
            cursor,
            mode,
            buffer_target,
            registers,
            effects,
        },
    );
    if result.is_applied()
        && let Some((repeat_state, operation)) = repeat_state
    {
        repeat_state.record(operation);
    }
    result
}

/// State needed to emit one resolved operator outcome.
struct OperatorOutcomeEmitContext<'state> {
    /// Authoritative text stream snapshot.
    stream: &'state TextByteStream,
    /// Cursor state for local post-operator placement.
    cursor: &'state mut VimCursor,
    /// Mode state.
    mode: &'state mut VimMode,
    /// Target buffer.
    buffer_target: BufferEntity,
    /// View-local registers.
    registers: &'state mut RegisterBank,
    /// Pending ECS effects.
    effects: &'state mut VimEffectBatch,
}

/// Converts resolved operator outcomes into register writes and typed ECS requests.
fn emit_operator_outcome(
    outcome: OperationOutcome,
    context: OperatorOutcomeEmitContext<'_>,
) -> OperatorDispatchResult {
    let OperatorOutcomeEmitContext {
        stream,
        cursor,
        mode,
        buffer_target,
        registers,
        effects,
    } = context;
    let text = stream.as_str();

    let mut result = OperatorDispatchResult::NotApplied;
    for effect in outcome.into_effects() {
        let OperationEffect::ApplyOperator { operator, target } = effect else {
            continue;
        };

        match operator {
            Operator::Delete => {
                if registers.write_delete(stream, target).is_err() {
                    continue;
                }
                cursor.set_byte_index(text, target.range().start());
                cursor.set_desired_column(None);
                effects.push(VimEffect::BufferEdit(BufferEditRequested {
                    target: buffer_target,
                    edit: BufferEdit::delete_validated(target.range().validated_text_range()),
                }));
                result = OperatorDispatchResult::AppliedNormal;
            }
            Operator::Yank => {
                if registers.write_yank(stream, target).is_ok() {
                    result = OperatorDispatchResult::AppliedNormal;
                }
            }
            Operator::Change => {
                if registers.write_delete(stream, target).is_err() {
                    continue;
                }
                let caret = target.range().start();
                cursor.set_byte_index(text, caret);
                cursor.set_desired_column(None);
                effects.push(VimEffect::BufferEdit(BufferEditRequested {
                    target: buffer_target,
                    edit: BufferEdit::delete_validated(target.range().validated_text_range()),
                }));
                *mode = VimMode::Insert(InsertEntry::AtCursor.insert_state());
                result = OperatorDispatchResult::AppliedInsert;
            }
        }
    }
    result
}