Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

66.7 KB
Raw Blame
/**
 * Copyright 2023-present DreamNum Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import type { IAccessor, ICommandInfo, IMutationInfo, IRange, Nullable } from '@univerjs/core';
import { getIntersectRange, IUniverInstanceService, MAX_COLUMN_COUNT, MAX_ROW_COUNT, mergeIntervals, ObjectMatrix, RANGE_TYPE, Rectangle } from '@univerjs/core';
import type { IInsertColMutationParams, IInsertRowMutationParams, IRemoveColMutationParams, IRemoveRowsMutationParams, IRemoveSheetMutationParams } from '../../basics';
import type { IDeleteRangeMoveLeftCommandParams } from '../../commands/commands/delete-range-move-left.command';
import type { IDeleteRangeMoveUpCommandParams } from '../../commands/commands/delete-range-move-up.command';
import type { IInsertRangeMoveDownCommandParams } from '../../commands/commands/insert-range-move-down.command';
import type { IInsertRangeMoveRightCommandParams } from '../../commands/commands/insert-range-move-right.command';
import type { IInsertColCommandParams, IInsertRowCommandParams } from '../../commands/commands/insert-row-col.command';
import type { IMoveRangeCommandParams } from '../../commands/commands/move-range.command';
import type { IMoveColsCommandParams, IMoveRowsCommandParams } from '../../commands/commands/move-rows-cols.command';
import type { IRemoveRowColCommandInterceptParams } from '../../commands/commands/remove-row-col.command';
import type { IReorderRangeCommandParams } from '../../commands/commands/reorder-range.command';
import type { IMoveRangeMutationParams } from '../../commands/mutations/move-range.mutation';
import type { IMoveColumnsMutationParams, IMoveRowsMutationParams } from '../../commands/mutations/move-rows-cols.mutation';
import type { ISheetCommandSharedParams } from '../../commands/utils/interface';
import type { SheetsSelectionsService } from '../selections/selection.service';
import type {
    EffectRefRangeParams,
    IDeleteRangeMoveLeftCommand,
    IDeleteRangeMoveUpCommand,
    IInsertColCommand,
    IInsertRangeMoveDownCommand,
    IInsertRangeMoveRightCommand,
    IInsertRowCommand,
    IMoveColsCommand,
    IMoveRangeCommand,
    IMoveRowsCommand,
    IOperator,
    IRemoveRowColCommand,
    IReorderRangeCommand,
} from './type';
import { DeleteRangeMoveLeftCommand } from '../../commands/commands/delete-range-move-left.command';
import { DeleteRangeMoveUpCommand } from '../../commands/commands/delete-range-move-up.command';
import { InsertRangeMoveDownCommand } from '../../commands/commands/insert-range-move-down.command';
import { InsertRangeMoveRightCommandId } from '../../commands/commands/insert-range-move-right.command';
import { getSheetCommandTarget } from '../../commands/commands/utils/target-util';
import { InsertColMutation, InsertRowMutation } from '../../commands/mutations/insert-row-col.mutation';
import { MoveRangeMutation } from '../../commands/mutations/move-range.mutation';
import { MoveColsMutation, MoveRowsMutation } from '../../commands/mutations/move-rows-cols.mutation';
import { RemoveColMutation, RemoveRowMutation } from '../../commands/mutations/remove-row-col.mutation';
import { RemoveSheetMutation } from '../../commands/mutations/remove-sheet.mutation';
import { EffectRefRangId, OperatorType } from './type';

export const handleRangeTypeInput = (range: IRange) => {
    const _range = { ...range };
    const isColumn = Number.isNaN(_range.startRow) && Number.isNaN(_range.endRow) && !Number.isNaN(_range.startColumn) && !Number.isNaN(_range.endColumn);
    const isRow = Number.isNaN(_range.startColumn) && Number.isNaN(_range.endColumn) && !Number.isNaN(_range.startRow) && !Number.isNaN(_range.endRow);
    if (_range.rangeType === RANGE_TYPE.COLUMN || isColumn) {
        _range.startRow = 0;
        _range.endRow = MAX_ROW_COUNT - 1;
    }
    if (_range.rangeType === RANGE_TYPE.ROW || isRow) {
        _range.startColumn = 0;
        _range.endColumn = MAX_COLUMN_COUNT - 1;
    }
    if (_range.rangeType === RANGE_TYPE.ALL) {
        _range.startColumn = 0;
        _range.endColumn = MAX_COLUMN_COUNT - 1;
        _range.startRow = 0;
        _range.endRow = MAX_ROW_COUNT - 1;
    }
    return _range;
};
export const handleRangeTypeOutput = (range: IRange, maxRow: number, maxCol: number) => {
    const _range = { ...range };
    if (_range.rangeType === RANGE_TYPE.COLUMN) {
        _range.startRow = 0;
        _range.endRow = maxRow;
    } else if (_range.rangeType === RANGE_TYPE.ROW) {
        _range.startColumn = 0;
        _range.endColumn = maxCol;
    } else if (_range.rangeType === RANGE_TYPE.ALL) {
        _range.startColumn = 0;
        _range.startRow = 0;
        _range.endColumn = maxCol;
        _range.endRow = maxRow;
    } else {
        _range.startRow = Math.max(0, _range.startRow);
        _range.endRow = Math.min(maxRow, _range.endRow);
        _range.startColumn = Math.max(0, _range.startColumn);
        _range.endColumn = Math.min(maxCol, _range.endColumn);
    }

    return _range;
};
export const rotateRange = (range: IRange): IRange => {
    // rotate {startRow:2,endRow:3,startCol:3,endCol:10} to
    // {startRow:3,endRow:10,startCol:2,endRow:3}
    let rangeType = range.rangeType;
    if (range.rangeType === RANGE_TYPE.COLUMN) {
        rangeType = RANGE_TYPE.ROW;
    } else if (range.rangeType === RANGE_TYPE.ROW) {
        rangeType = RANGE_TYPE.COLUMN;
    }
    return {
        startRow: range.startColumn,
        endRow: range.endColumn,
        startColumn: range.startRow,
        endColumn: range.endRow,
        rangeType,
    };
};
interface ILine {
    start: number;
    end: number;
}

interface ILineTransform extends ILine {
    offset: number;
}

function mergeAndSortRanges(ranges: IRange[]): IRange[] {
    const merged = ranges.length > 1 ? Rectangle.mergeRanges(ranges) : ranges;
    return sortRanges(merged);
}

function sortRanges(ranges: IRange[]): IRange[] {
    return ranges.sort((a, b) => a.startRow - b.startRow || a.startColumn - b.startColumn || a.endRow - b.endRow || a.endColumn - b.endColumn);
}

function translateRange(range: IRange, rowOffset: number, columnOffset: number): IRange {
    return {
        startRow: range.startRow + rowOffset,
        endRow: range.endRow + rowOffset,
        startColumn: range.startColumn + columnOffset,
        endColumn: range.endColumn + columnOffset,
    };
}

function moveRangeAlongAxis(targetRange: IRange, from: number, count: number, to: number, isRow: boolean): IRange[] {
    let transforms: ILineTransform[];
    if (from > to) {
        transforms = [
            { start: Number.NEGATIVE_INFINITY, end: to - 1, offset: 0 },
            { start: to, end: from - 1, offset: count },
            { start: from, end: from + count - 1, offset: to - from },
            { start: from + count, end: Number.POSITIVE_INFINITY, offset: 0 },
        ];
    } else {
        if (from + count > to) {
            throw new Error('Invalid move operation');
        }
        transforms = [
            { start: Number.NEGATIVE_INFINITY, end: from - 1, offset: 0 },
            { start: from, end: from + count - 1, offset: to - from - count },
            { start: from + count, end: to - 1, offset: -count },
            { start: to, end: Number.POSITIVE_INFINITY, offset: 0 },
        ];
    }

    const rangeStart = isRow ? targetRange.startRow : targetRange.startColumn;
    const rangeEnd = isRow ? targetRange.endRow : targetRange.endColumn;
    const ranges = transforms.flatMap(({ start, end, offset }) => {
        const intersectStart = Math.max(rangeStart, start);
        const intersectEnd = Math.min(rangeEnd, end);
        if (intersectStart > intersectEnd) {
            return [];
        }

        const range = isRow
            ? { startRow: intersectStart, endRow: intersectEnd, startColumn: targetRange.startColumn, endColumn: targetRange.endColumn }
            : { startRow: targetRange.startRow, endRow: targetRange.endRow, startColumn: intersectStart, endColumn: intersectEnd };
        return [translateRange(range, isRow ? offset : 0, isRow ? 0 : offset)];
    });

    return mergeAndSortRanges(ranges);
}
/**
 * see docs/tldr/ref-range/move-rows-cols.tldr
 */

export const handleBaseMoveRowsCols = (
    fromRange: ILine,
    toRange: ILine,
    effectRange: ILine
): { length: number; step: number } => {
    const _effectRange = { ...effectRange };
    const _toRange = { ...toRange };
    const getIntersects = (line1: ILine, line2: ILine): Nullable<ILine> => {
        const start = Math.max(line1.start, line2.start);
        const end = Math.min(line1.end, line2.end);
        if (end < start) {
            return null;
        }
        return { start, end };
    };
    const getLength = (line: ILine) => line.end - line.start + 1;
    const getRelative = (line: ILine, origin: ILine) => ({
        start: line.start - origin.start,
        end: line.start - origin.start + line.end - line.start,
    });
    const getAbsolute = (line: ILine, origin: ILine): ILine => ({
        start: origin.start + line.start,
        end: origin.start + line.start + line.end - line.start,
    });
    const isToLargeFrom = toRange.start > fromRange.start;
    if (isToLargeFrom) {
        const step = Math.min(fromRange.end, toRange.start) - fromRange.start + 1;
        _toRange.start -= step;
        _toRange.end -= step;
    }
    const fromRangeStep = getLength(fromRange);
    const toRangeStep = fromRangeStep;
    const fromRangeIntersectsEffectRange = getIntersects(fromRange, _effectRange);
    const isFromRangeContainEffectRange =
        fromRangeIntersectsEffectRange && getLength(fromRangeIntersectsEffectRange) >= getLength(_effectRange);
    if (fromRange.end < _effectRange.start) {
        _effectRange.start -= fromRangeStep;
        _effectRange.end -= fromRangeStep;
    } else if (fromRangeIntersectsEffectRange) {
        //1- 4 5 8 9 11 12 14 15
        //2- 6 7 8 10 11 13 14 15
        //3- 3 5 6 7 8 9 11
        const fromRangeIntersectsEffectRangeStep = getLength(fromRangeIntersectsEffectRange);
        if (isFromRangeContainEffectRange) {
            //1- 12
            //2- 13
            //3- 6 8 9
            const relative = getRelative(_effectRange, fromRange);
            const newLine = getAbsolute(relative, _toRange);
            _effectRange.start = newLine.start;
            _effectRange.end = newLine.end;
        } else if (fromRangeIntersectsEffectRange.start > fromRange.start) {
            //1- 5 8
            //2- 6 8 10 11 14 15
            //3- 5 7
            if (isToLargeFrom) {
                _effectRange.end -= fromRangeIntersectsEffectRangeStep + fromRangeStep;
                _effectRange.start -= fromRangeStep;
            } else {
                _effectRange.end -= fromRangeIntersectsEffectRangeStep;
            }
        } else {
            if (isToLargeFrom) {
                //1- 4 9 11 14 15
                //3- 3 11
                _effectRange.end -= fromRangeIntersectsEffectRangeStep;
            } else {
                if (_effectRange.start > fromRange.start && _effectRange.end > fromRange.end) {
                    // 2-7
                    _effectRange.start -= fromRangeStep;
                    _effectRange.end -= fromRangeStep + fromRangeIntersectsEffectRangeStep;
                } else {
                    // 2-6 10 11 14 15
                    _effectRange.end -= fromRangeIntersectsEffectRangeStep;
                }
            }
        }
    }

    const toRangeIntersectsEffectRange = getIntersects(_toRange, _effectRange);
    if (!isFromRangeContainEffectRange) {
        if (_toRange.start <= _effectRange.start) {
            _effectRange.start += toRangeStep;
            _effectRange.end += toRangeStep;
        } else if (toRangeIntersectsEffectRange) {
            if (!isToLargeFrom) {
                if (_effectRange.start < _toRange.start && _effectRange.end > _toRange.start) {
                    // 2-4 9 14 expend
                    _effectRange.end += toRangeStep;
                } else if (_effectRange.start >= _toRange.end || (_effectRange.start >= _toRange.start && _effectRange.start <= _toRange.end)) {
                    // 2-5 8 12 15 move right
                    _effectRange.end += toRangeStep;
                    _effectRange.start += toRangeStep;
                }
            } else {
                if (_toRange.end <= _effectRange.start || (_toRange.start <= _effectRange.start && _toRange.end >= _effectRange.start)) {
                    // 1-3 7 13
                    _effectRange.start += toRangeStep;
                    _effectRange.end += toRangeStep;
                } else if (_toRange.start >= _effectRange.start && _toRange.start <= _effectRange.end) {
                    // 1-6 8 10  11 14 15
                    _effectRange.end += toRangeStep;
                }
            }
        }
    }

    return {
        step: _effectRange.start - effectRange.start,
        length: getLength(_effectRange) - getLength(effectRange),
    };
};

export const handleMoveRows = (params: IMoveRowsCommand, targetRange: IRange): IOperator[] => {
    const { fromRange, toRange } = params.params || {};
    if (!toRange || !fromRange) {
        return [];
    }
    const _fromRange = handleRangeTypeInput(fromRange);
    const _toRange = handleRangeTypeInput(toRange);
    const _targetRange = handleRangeTypeInput(targetRange);
    const result = handleBaseMoveRowsCols(
        { start: _fromRange.startRow, end: _fromRange.endRow },
        { start: _toRange.startRow, end: _toRange.endRow },
        { start: _targetRange.startRow, end: _targetRange.endRow }
    );
    if (result === null) {
        return [
            {
                type: OperatorType.Delete,
            },
        ];
    }
    return [
        {
            type: OperatorType.VerticalMove,
            step: result.step || 0,
            length: result.length || 0,
        },
    ];
};

export const handleMoveRowsCommon = (params: IMoveRowsCommand, targetRange: IRange) => {
    const { fromRange, toRange } = params.params || {};
    if (!fromRange || !toRange) {
        return [targetRange];
    }

    const fromRow = fromRange.startRow;
    const count = fromRange.endRow - fromRange.startRow + 1;
    const toRow = toRange.startRow;

    return moveRangeAlongAxis(targetRange, fromRow, count, toRow, true);
};

export const handleReorderRangeCommon = (param: IReorderRangeCommand, targetRange: IRange) => {
    const { range, order } = param.params || {};
    if (!range || !order) {
        return [targetRange];
    }
    const overwrittenRows: IRange[] = [];
    const additions: IRange[] = [];
    const startColumn = Math.max(range.startColumn, targetRange.startColumn);
    const endColumn = Math.min(range.endColumn, targetRange.endColumn);

    Object.keys(order).forEach((key) => {
        const row = Number(key);
        if (row < range.startRow || row > range.endRow) {
            return;
        }

        overwrittenRows.push({ startRow: row, endRow: row, startColumn: range.startColumn, endColumn: range.endColumn });
        const sourceRow = order[row];
        if (sourceRow >= targetRange.startRow && sourceRow <= targetRange.endRow && startColumn <= endColumn) {
            additions.push({ startRow: row, endRow: row, startColumn, endColumn });
        }
    });

    return mergeAndSortRanges([...Rectangle.subtractMulti([targetRange], overwrittenRows), ...additions]);
};

export const handleMoveCols = (params: IMoveColsCommand, targetRange: IRange): IOperator[] => {
    const { fromRange, toRange } = params.params || {};
    if (!toRange || !fromRange) {
        return [];
    }
    const _fromRange = handleRangeTypeInput(fromRange);
    const _toRange = handleRangeTypeInput(toRange);
    const _targetRange = handleRangeTypeInput(targetRange);
    const result = handleBaseMoveRowsCols(
        { start: _fromRange.startColumn, end: _fromRange.endColumn },
        { start: _toRange.startColumn, end: _toRange.endColumn },
        { start: _targetRange.startColumn, end: _targetRange.endColumn }
    );
    if (result === null) {
        return [
            {
                type: OperatorType.Delete,
            },
        ];
    }
    return [
        {
            type: OperatorType.HorizontalMove,
            step: result.step || 0,
            length: result.length || 0,
        },
    ];
};

export const handleMoveColsCommon = (params: IMoveColsCommand, targetRange: IRange) => {
    const { fromRange, toRange } = params.params || {};
    if (!fromRange || !toRange) {
        return [targetRange];
    }

    const fromCol = fromRange.startColumn;
    const count = fromRange.endColumn - fromRange.startColumn + 1;
    const toCol = toRange.startColumn;

    return moveRangeAlongAxis(targetRange, fromCol, count, toCol, false);
};

export const handleMoveRange = (param: IMoveRangeCommand, targetRange: IRange) => {
    const toRange = param.params?.toRange;
    const fromRange = param.params?.fromRange;
    if (!toRange || !fromRange) {
        return [];
    }
    const operators: IOperator[] = [];

    if (Rectangle.contains(toRange, targetRange)) {
        operators.push({
            type: OperatorType.Delete,
        });
    }

    if (Rectangle.contains(fromRange, targetRange)) {
        operators.push({
            type: OperatorType.Delete,
        });
        const relativeRange = Rectangle.getRelativeRange(targetRange, fromRange);
        const positionRange = Rectangle.getPositionRange(relativeRange, toRange);
        return [
            {
                type: OperatorType.Set,
                range: positionRange,
            },
        ] as IOperator[];
    }
    return operators;
};

export const handleMoveRangeCommon = (param: IMoveRangeCommand, targetRange: IRange) => {
    const toRange = param.params?.toRange;
    const fromRange = param.params?.fromRange;
    // illegal
    if (!toRange || !fromRange) {
        return [targetRange];
    }

    if (!Rectangle.intersects(fromRange, targetRange) && !Rectangle.intersects(toRange, targetRange)) {
        return [targetRange];
    }

    if (Rectangle.contains(fromRange, targetRange)) {
        const relativeRange = Rectangle.getRelativeRange(targetRange, fromRange);
        const positionRange = Rectangle.getPositionRange(relativeRange, toRange);
        return [positionRange];
    }

    const columnOffset = toRange.startColumn - fromRange.startColumn;
    const rowOffset = toRange.startRow - fromRange.startRow;
    const movedRange = getIntersectRange(fromRange, targetRange);
    const remainingRanges = Rectangle.subtractMulti([targetRange], [fromRange, toRange]);
    const translatedRanges = movedRange ? [translateRange(movedRange, rowOffset, columnOffset)] : [];

    return mergeAndSortRanges([...remainingRanges, ...translatedRanges]);
};

// see docs/tldr/ref-range/remove-rows-cols.tldr
export const handleBaseRemoveRange = (_removeRange: IRange, _targetRange: IRange) => {
    const removeRange = handleRangeTypeInput(_removeRange);
    const targetRange = handleRangeTypeInput(_targetRange);
    const getLength = (range: IRange): number => range.endColumn - range.startColumn + 1;
    const getRowLength = (range: IRange): number => range.endRow - range.startRow + 1;
    if (removeRange.startRow <= targetRange.startRow && removeRange.endRow >= targetRange.endRow) {
        if (
            // 2
            (targetRange.startColumn < removeRange.startColumn &&
                targetRange.endColumn >= removeRange.startColumn &&
                targetRange.endColumn <= removeRange.endColumn) ||
            // 6
            (targetRange.startColumn < removeRange.startColumn && targetRange.endColumn >= removeRange.endColumn)
        ) {
            const intersectedRange = getIntersectRange(targetRange, removeRange);
            if (intersectedRange) {
                const length = -getLength(intersectedRange);
                return { step: 0, length };
            }
        }
        // 3
        if (
            targetRange.startColumn >= removeRange.startColumn &&
            targetRange.endColumn <= removeRange.endColumn &&
            getRowLength(removeRange) >= getRowLength(targetRange)
        ) {
            return null;
        }
        // 4
        if (
            targetRange.startColumn >= removeRange.startColumn &&
            targetRange.startColumn <= removeRange.endColumn &&
            targetRange.endColumn > removeRange.endColumn
        ) {
            const intersectedRange = getIntersectRange(targetRange, removeRange);
            if (intersectedRange) {
                const length = -getLength(intersectedRange);
                const step = -(getLength(removeRange) - getLength(intersectedRange));

                return { step, length };
            }
        }
        // 5
        if (targetRange.startColumn > removeRange.endColumn) {
            const step = -getLength(removeRange);
            return { step, length: 0 };
        }
    }
    return { step: 0, length: 0 };
};
export const handleIRemoveCol = (param: IRemoveRowColCommand, targetRange: IRange) => {
    const range = param.params?.range;
    if (!range) {
        return [];
    }
    const operators: IOperator[] = [];
    const result = handleBaseRemoveRange(range, targetRange);
    if (!result) {
        operators.push({ type: OperatorType.Delete });
    } else {
        const { step, length } = result;
        operators.push({
            type: OperatorType.HorizontalMove,
            step,
            length,
        });
    }
    return operators;
};

export const handleIRemoveRow = (param: IRemoveRowColCommand, targetRange: IRange, rangeFilteredRows?: number[]) => {
    const range = param.params?.range;
    if (!range) {
        return [];
    }

    const operators: IOperator[] = [];

    // check the remove range contains the filtered rows, if so, we need to skip the filtered rows
    if (rangeFilteredRows && rangeFilteredRows.length > 0) {
        let startRow = range.startRow;

        for (let r = range.startRow; r <= range.endRow; r++) {
            if (rangeFilteredRows.includes(r)) {
                if (r === startRow) {
                    startRow = r + 1;
                    continue;
                }

                _handleBaseRemoveRange({
                    ...range,
                    startRow,
                    endRow: r - 1,
                });
                startRow = r + 1;
                continue;
            }

            if (r === range.endRow) {
                _handleBaseRemoveRange({
                    ...range,
                    startRow,
                    endRow: range.endRow,
                });
            }
        }
    } else {
        _handleBaseRemoveRange(range);
    }

    function _handleBaseRemoveRange(removeRange: IRange) {
        const result = handleBaseRemoveRange(rotateRange(removeRange), rotateRange(targetRange));
        if (!result) {
            operators.push({ type: OperatorType.Delete });
        } else {
            const { step, length } = result;
            operators.push({
                type: OperatorType.VerticalMove,
                step,
                length,
            });
        }
    }

    return operators;
};

export const handleReorderRange = (param: IReorderRangeCommand, targetRange: IRange) => {
    const { range, order } = param.params || {};
    if (!range || !order) {
        return [];
    }

    if (Rectangle.contains(range, targetRange) && targetRange.endRow === targetRange.startRow) {
        const operators: IOperator[] = [];
        const targetRow = targetRange.startRow;
        for (const k in order) {
            if (order[k] === targetRow) {
                const toRow = Number(k);
                operators.push({
                    type: OperatorType.VerticalMove,
                    step: toRow - targetRow,
                    length: 0,
                });
                return operators;
            }
        }
        return [];
    }
    return [];
};

/**
 * see docs/tldr/ref-range/insert-rows-cols.tldr
 * calculate insert steps(move step) or expand size(length) to ref range.
 *
 * @param _insertRange inserted range
 * @param _targetRange ref range
 * @returns {step: number, length: number} step means inserted count of row/col before ref range, that would cause range move few cells(steps) afterward.
 * length means expand size of row/col in ref range, that would make ref range larger than before.
 */
export const handleBaseInsertRange = (_insertRange: IRange, _targetRange: IRange) => {
    const insertRange = handleRangeTypeInput(_insertRange);
    const targetRange = handleRangeTypeInput(_targetRange);
    const getLength = (range: IRange): number => range.endColumn - range.startColumn + 1;
    if (!(insertRange.startRow <= targetRange.startRow && insertRange.endRow >= targetRange.endRow)) {
        return { step: 0, length: 0 };
    }

    // expand range, that means insert new rows/cols in target range
    if (
        // 2
        // Case 2: Overlap on the left side
        // Target range starts before the insert range and ends within the insert range boundaries
        // targetRange:  |----------|
        // insertRange:         |-------|
        // insertRange:
        (targetRange.startColumn < insertRange.startColumn &&
            targetRange.endColumn >= insertRange.startColumn &&
            targetRange.endColumn <= insertRange.endColumn)
        ||
        // 6
        // Case 6: Fully overlapping on both sides
        // Target range starts before the insert range and ends after the insert range
        // targetRange:  |----------------|
        // insertRange:         |-------|
        (targetRange.startColumn < insertRange.startColumn && targetRange.endColumn >= insertRange.endColumn)

        // (targetRange.startColumn === insertRange.startColumn && targetRange.endColumn > insertRange.endColumn)
    ) {
        const length = getLength(insertRange);
        return { step: 0, length };
    }

    // make range shifted backward, that means insert new rows/cols before target range
    if (
        // 3
        // Case 3: Fully contained
        // Target range is completely within the insert range
        // targetRange:      |---|
        // insertRange:    |-------|
        (targetRange.startColumn >= insertRange.startColumn && targetRange.endColumn <= insertRange.endColumn) ||
        // 4
        // Case 4: Overlap on the right side
        // Target range starts within the insert range and ends after the insert range
        // targetRange:         |---------|
        // insertRange:    |-------|
        (targetRange.startColumn >= insertRange.startColumn &&
            targetRange.startColumn <= insertRange.endColumn &&
            targetRange.endColumn > insertRange.endColumn) ||
        //5
        // Case 5: No overlap (target range starts after the insert range ends)
        // targetRange:                |-------|
        // insertRange:    |-------|
        targetRange.startColumn >= insertRange.endColumn

    ) {
        const step = getLength(insertRange);
        return { step, length: 0 };
    }

    return { step: 0, length: 0 };
};

function handleBaseMoveRange(fromRange: IRange, toRange: IRange, targetRange: IRange) {
    const operators: IOperator[] = [];

    if (Rectangle.contains(toRange, targetRange)) {
        operators.push({
            type: OperatorType.Delete,
        });
    }

    if (Rectangle.contains(fromRange, targetRange)) {
        operators.push({
            type: OperatorType.Delete,
        });
        const relativeRange = Rectangle.getRelativeRange(targetRange, fromRange);
        const positionRange = Rectangle.getPositionRange(relativeRange, toRange);
        return [
            {
                type: OperatorType.Set,
                range: positionRange,
            },
        ] as IOperator[];
    }
    return operators;
};

export const handleInsertRow = (param: IInsertRowCommand, targetRange: IRange) => {
    const range = param.params?.range;
    if (!range) {
        return [];
    }
    const operators: IOperator[] = [];
    const result = handleBaseInsertRange(rotateRange(range), rotateRange(targetRange));
    const { step, length } = result;
    operators.push({
        type: OperatorType.VerticalMove,
        step,
        length,
    });
    return operators;
};

export const handleInsertCol = (param: IInsertColCommand, targetRange: IRange) => {
    const range = param.params?.range;
    if (!range) {
        return [];
    }
    const operators: IOperator[] = [];
    const result = handleBaseInsertRange(range, targetRange);
    const { step, length } = result;
    operators.push({
        type: OperatorType.HorizontalMove,
        step,
        length,
    });
    return operators;
};

export const handleInsertRangeMoveDown = (param: IInsertRangeMoveDownCommand, targetRange: IRange) => {
    const range = param.params?.range;
    if (!range) {
        return [];
    }
    const operators: IOperator[] = [];
    const result = handleBaseInsertRange(rotateRange(range), rotateRange(targetRange));
    const { step, length } = result;
    operators.push({
        type: OperatorType.VerticalMove,
        step,
        length,
    });
    return operators;
};

export const handleInsertRangeMoveDownCommon = (param: IInsertRangeMoveDownCommand, targetRange: IRange) => {
    const range = param.params?.range;
    if (!range) {
        return [targetRange];
    }

    const moveCount = range.endRow - range.startRow + 1;
    const bottomRange: IRange = {
        ...range,
        startRow: range.startRow,
        endRow: Number.POSITIVE_INFINITY,
    };

    const noMoveRanges = Rectangle.subtract(targetRange, bottomRange);
    const targetMoveRange = getIntersectRange(bottomRange, targetRange);

    if (!targetMoveRange) {
        return [targetRange];
    }

    return sortRanges([...noMoveRanges, translateRange(targetMoveRange, moveCount, 0)]);
};

export const handleInsertRangeMoveRight = (param: IInsertRangeMoveRightCommand, targetRange: IRange) => {
    const range = param.params?.range;
    if (!range) {
        return [];
    }
    const operators: IOperator[] = [];
    const result = handleBaseInsertRange(range, targetRange);
    const { step, length } = result;
    operators.push({
        type: OperatorType.HorizontalMove,
        step,
        length,
    });
    return operators;
};

export const handleInsertRangeMoveRightCommon = (param: IInsertRangeMoveRightCommand, targetRange: IRange) => {
    const range = param.params?.range;
    if (!range) {
        return [targetRange];
    }

    const moveCount = range.endColumn - range.startColumn + 1;
    const bottomRange: IRange = {
        ...range,
        startColumn: range.startColumn,
        endColumn: Number.POSITIVE_INFINITY,
    };

    const noMoveRanges = Rectangle.subtract(targetRange, bottomRange);
    const targetMoveRange = getIntersectRange(bottomRange, targetRange);

    if (!targetMoveRange) {
        return [targetRange];
    }

    return sortRanges([...noMoveRanges, translateRange(targetMoveRange, 0, moveCount)]);
};

export const handleDeleteRangeMoveLeft = (param: IDeleteRangeMoveLeftCommand, targetRange: IRange) => {
    const range = param.params?.range;
    if (!range) {
        return [];
    }

    const operators: IOperator[] = [];
    const result = handleBaseRemoveRange(range, targetRange);

    if (!result) {
        operators.push({ type: OperatorType.Delete });
    } else {
        const { step, length } = result;
        operators.push({
            type: OperatorType.HorizontalMove,
            step,
            length,
        });
    }

    return operators;
};

export const handleDeleteRangeMoveLeftCommon = (param: IDeleteRangeMoveLeftCommand, targetRange: IRange) => {
    const range = param.params?.range;
    if (!range) {
        return [targetRange];
    }

    const rightRange: IRange = {
        startRow: range.startRow,
        endRow: range.endRow,
        startColumn: range.startColumn,
        endColumn: Number.POSITIVE_INFINITY,
    };

    const moveCount = range.endColumn - range.startColumn + 1;
    const noMoveRanges = Rectangle.subtract(targetRange, rightRange);
    const targetMoveRange = getIntersectRange(rightRange, targetRange);

    if (!targetMoveRange) {
        return [targetRange];
    }

    const movedRanges = targetMoveRange
        ? Rectangle.subtract(targetMoveRange, range).map((target) => translateRange(target, 0, -moveCount))
        : [];

    return mergeAndSortRanges([...noMoveRanges, ...movedRanges]);
};

export const handleDeleteRangeMoveUp = (param: IDeleteRangeMoveUpCommand, targetRange: IRange) => {
    const range = param.params?.range;
    if (!range) {
        return [];
    }
    const operators: IOperator[] = [];
    const result = handleBaseRemoveRange(rotateRange(range), rotateRange(targetRange));
    if (!result) {
        operators.push({ type: OperatorType.Delete });
    } else {
        const { step, length } = result;
        operators.push({
            type: OperatorType.VerticalMove,
            step,
            length,
        });
    }
    return operators;
};

export const handleDeleteRangeMoveUpCommon = (param: IDeleteRangeMoveUpCommand, targetRange: IRange) => {
    const range = param.params?.range;
    if (!range) {
        return [targetRange];
    }

    const bottomRange: IRange = {
        ...range,
        startRow: range.startRow,
        endRow: Number.POSITIVE_INFINITY,
    };

    const moveCount = range.endRow - range.startRow + 1;
    const noMoveRanges = Rectangle.subtract(targetRange, bottomRange);
    const targetMoveRange = getIntersectRange(bottomRange, targetRange);

    if (!targetMoveRange) {
        return [targetRange];
    }

    const movedRanges = targetMoveRange
        ? Rectangle.subtract(targetMoveRange, range).map((target) => translateRange(target, -moveCount, 0))
        : [];

    return mergeAndSortRanges([...noMoveRanges, ...movedRanges]);
};

export const handleRemoveRowCommon = (param: IRemoveRowColCommandInterceptParams, targetRange: IRange) => {
    const ranges = param.ranges ?? [param.range];
    const removed: [number, number][] = ranges.map((range) => [range.startRow, range.endRow]);
    const mergedRemoved = mergeIntervals(removed);

    let targetStartRow = targetRange.startRow;
    let targetEndRow = targetRange.endRow;

    for (let i = mergedRemoved.length - 1; i >= 0; i--) {
        const [startRow, endRow] = mergedRemoved[i];

        if (startRow <= targetRange.startRow && endRow >= targetRange.endRow) {
            return [];
        }

        if (endRow < targetStartRow) {
            const count = endRow - startRow + 1;
            targetStartRow -= count;
            targetEndRow -= count;
        } else if (startRow > targetEndRow) {
            // do nothing
        } else {
            const intersectStart = Math.max(startRow, targetStartRow);
            const intersectEnd = Math.min(endRow, targetEndRow);
            const intersectCount = intersectEnd - intersectStart + 1;

            targetEndRow -= intersectCount;

            if (startRow <= targetStartRow) {
                const beforeCount = intersectStart - targetStartRow;
                targetStartRow -= beforeCount;
            }
        }
    }

    return [
        {
            ...targetRange,
            startRow: targetStartRow,
            endRow: targetEndRow,
        },
    ];
};

/**
 * A ref range follows the data it covers, whichever command entry produced the insertion:
 * inserting above the range shifts it down, inserting inside the range expands it, and
 * inserting below the range leaves it untouched.
 *
 * `direction` only decides which row the inserted cells inherit styles and height from, so it
 * is deliberately ignored here: two entry points that insert a row at the same position must
 * return the same range. This matches `handleBaseInsertRange`, which serves the mutation based
 * ref-range paths, and the collaboration transform algorithms, which cannot supply a direction
 * at all.
 */
export const handleInsertRowCommon = (info: ICommandInfo<IInsertRowCommandParams>, targetRange: IRange) => {
    const param = info.params!;
    const insertRow = param.range.startRow;
    const insertCount = param.range.endRow - param.range.startRow + 1;
    // an endpoint moves only when the insertion point is at or above it
    const startOffset = insertRow <= targetRange.startRow ? insertCount : 0;
    const endOffset = insertRow <= targetRange.endRow ? insertCount : 0;

    if (!startOffset && !endOffset) {
        return [targetRange];
    }

    return [{
        ...targetRange,
        startRow: targetRange.startRow + startOffset,
        endRow: targetRange.endRow + endOffset,
    }];
};

/**
 * Column counterpart of {@link handleInsertRowCommon}: a ref range follows the data it covers,
 * so `direction` is deliberately ignored here as well.
 */
export const handleInsertColCommon = (info: ICommandInfo<IInsertColCommandParams>, targetRange: IRange) => {
    const param = info.params!;
    const insertColumn = param.range.startColumn;
    const insertCount = param.range.endColumn - param.range.startColumn + 1;
    // an endpoint moves only when the insertion point is at or above it
    const startOffset = insertColumn <= targetRange.startColumn ? insertCount : 0;
    const endOffset = insertColumn <= targetRange.endColumn ? insertCount : 0;

    if (!startOffset && !endOffset) {
        return [targetRange];
    }

    return [{
        ...targetRange,
        startColumn: targetRange.startColumn + startOffset,
        endColumn: targetRange.endColumn + endOffset,
    }];
};

export const runRefRangeMutations = (operators: IOperator[], range: IRange) => {
    let result: Nullable<IRange> = { ...range };
    operators.forEach((operator) => {
        switch (operator.type) {
            case OperatorType.Delete: {
                result = null;
                break;
            }
            case OperatorType.HorizontalMove: {
                if (!result) {
                    return;
                }
                result.startColumn += operator.step;
                result.endColumn += operator.step + (operator.length || 0);
                break;
            }
            case OperatorType.VerticalMove: {
                if (!result) {
                    return;
                }
                result.startRow += operator.step;
                result.endRow += operator.step + (operator.length || 0);
                break;
            }
            case OperatorType.Set: {
                result = operator.range;
                break;
            }
        }
    });
    if (result) {
        if (result.endColumn < result.startColumn || result.endRow < result.startRow) {
            return null;
        }
    }
    return result;
};

export const handleDefaultRangeChangeWithEffectRefCommands = (range: IRange, commandInfo: ICommandInfo) => {
    let operator: IOperator[] = [];
    switch (commandInfo.id) {
        case EffectRefRangId.DeleteRangeMoveLeftCommandId: {
            operator = handleDeleteRangeMoveLeft(commandInfo as IDeleteRangeMoveLeftCommand, range);
            break;
        }
        case EffectRefRangId.DeleteRangeMoveUpCommandId: {
            operator = handleDeleteRangeMoveUp(commandInfo as IDeleteRangeMoveUpCommand, range);
            break;
        }
        case EffectRefRangId.InsertColCommandId: {
            operator = handleInsertCol(commandInfo as IInsertColCommand, range);
            break;
        }
        case EffectRefRangId.InsertRangeMoveDownCommandId: {
            operator = handleInsertRangeMoveDown(commandInfo as IInsertRangeMoveDownCommand, range);
            break;
        }
        case EffectRefRangId.InsertRangeMoveRightCommandId: {
            operator = handleInsertRangeMoveRight(commandInfo as IInsertRangeMoveRightCommand, range);
            break;
        }
        case EffectRefRangId.InsertRowCommandId: {
            operator = handleInsertRow(commandInfo as IInsertRowCommand, range);
            break;
        }
        case EffectRefRangId.MoveColsCommandId: {
            operator = handleMoveCols(commandInfo as IMoveColsCommand, range);
            break;
        }
        case EffectRefRangId.MoveRangeCommandId: {
            operator = handleMoveRange(commandInfo as IMoveRangeCommand, range);
            break;
        }
        case EffectRefRangId.MoveRowsCommandId: {
            operator = handleMoveRows(commandInfo as IMoveRowsCommand, range);
            break;
        }
        case EffectRefRangId.RemoveColCommandId: {
            operator = handleIRemoveCol(commandInfo as IRemoveRowColCommand, range);
            break;
        }
        case EffectRefRangId.RemoveRowCommandId: {
            operator = handleIRemoveRow(commandInfo as IRemoveRowColCommand, range);
            break;
        }
        case EffectRefRangId.ReorderRangeCommandId: {
            operator = handleReorderRange(commandInfo as IReorderRangeCommand, range);
            break;
        }
    }

    const resultRange = runRefRangeMutations(operator, range);
    return resultRange;
};

export const handleDefaultRangeChangeWithEffectRefCommandsSkipNoInterests = (range: IRange, commandInfo: ICommandInfo, deps: { selectionManagerService: SheetsSelectionsService }) => {
    const skipCommands = [DeleteRangeMoveLeftCommand.id, DeleteRangeMoveUpCommand.id];
    if (skipCommands.includes(commandInfo.id)) {
        return handleDefaultRangeChangeWithEffectRefCommands(range, commandInfo);
    }

    const effectRanges = getEffectedRangesOnCommand(commandInfo as EffectRefRangeParams, deps);
    if (effectRanges.some((effectRange) => Rectangle.intersects(effectRange, range))) {
        return handleDefaultRangeChangeWithEffectRefCommands(range, commandInfo);
    }

    return range;
};

export type MutationsAffectRange =
    ISheetCommandSharedParams
    | IRemoveSheetMutationParams
    | IMoveRowsMutationParams
    | IMoveColumnsMutationParams
    | IRemoveRowsMutationParams
    | IRemoveColMutationParams
    | IInsertColMutationParams
    | IInsertRowMutationParams
    | IMoveRangeMutationParams;

const ROW_AXIS_COMMANDS: string[] = [
    EffectRefRangId.InsertRowCommandId,
    EffectRefRangId.RemoveRowCommandId,
    EffectRefRangId.MoveRowsCommandId,
    EffectRefRangId.InsertRangeMoveDownCommandId,
    EffectRefRangId.DeleteRangeMoveUpCommandId,
];

const COLUMN_AXIS_COMMANDS: string[] = [
    EffectRefRangId.InsertColCommandId,
    EffectRefRangId.RemoveColCommandId,
    EffectRefRangId.MoveColsCommandId,
    EffectRefRangId.InsertRangeMoveRightCommandId,
    EffectRefRangId.DeleteRangeMoveLeftCommandId,
];

/**
 * A whole column/row/sheet range always covers the whole axis, so it does not follow concrete
 * coordinates on that axis: structural edits there keep the range anchored at 0 and only move its
 * end. Edits on the opposite axis still go through the regular coordinate based rules.
 *
 * @returns the adjusted ranges, or `undefined` when the regular logic should handle the command
 */
function handleWholeRangeCommand(targetRange: IRange, commandInfo: ICommandInfo): IRange[] | undefined {
    const coversAllRows = targetRange.rangeType === RANGE_TYPE.COLUMN || targetRange.rangeType === RANGE_TYPE.ALL;
    const coversAllColumns = targetRange.rangeType === RANGE_TYPE.ROW || targetRange.rangeType === RANGE_TYPE.ALL;
    if (!coversAllRows && !coversAllColumns) {
        return undefined;
    }
    // a typed range that still carries stale coordinates cannot be tracked reliably
    if ((coversAllRows && !Number.isFinite(targetRange.endRow)) || (coversAllColumns && !Number.isFinite(targetRange.endColumn))) {
        return undefined;
    }

    if (ROW_AXIS_COMMANDS.includes(commandInfo.id)) {
        return coversAllRows ? [adjustWholeRange(targetRange, true, commandInfo)] : undefined;
    }
    if (COLUMN_AXIS_COMMANDS.includes(commandInfo.id)) {
        return coversAllColumns ? [adjustWholeRange(targetRange, false, commandInfo)] : undefined;
    }
    if (commandInfo.id === EffectRefRangId.MoveRangeCommandId || commandInfo.id === EffectRefRangId.ReorderRangeCommandId) {
        // moving cells around never changes how much of an axis a whole range covers
        return [targetRange];
    }
    return undefined;
}

function adjustWholeRange(targetRange: IRange, isRow: boolean, commandInfo: ICommandInfo): IRange {
    const currentEnd = isRow ? targetRange.endRow : targetRange.endColumn;

    switch (commandInfo.id) {
        case EffectRefRangId.InsertRowCommandId:
        case EffectRefRangId.InsertColCommandId: {
            const params = commandInfo.params as IInsertRowCommandParams | IInsertColCommandParams;
            const count = isRow
                ? params.range.endRow - params.range.startRow + 1
                : params.range.endColumn - params.range.startColumn + 1;

            return isRow
                ? { ...targetRange, startRow: 0, endRow: currentEnd + count }
                : { ...targetRange, startColumn: 0, endColumn: currentEnd + count };
        }
        case EffectRefRangId.RemoveRowCommandId:
        case EffectRefRangId.RemoveColCommandId: {
            const params = commandInfo.params as IRemoveRowColCommandInterceptParams;
            const removedRanges = params.ranges ?? (params.range ? [params.range] : []);
            const intervals: [number, number][] = removedRanges.map((range) => (isRow ? [range.startRow, range.endRow] : [range.startColumn, range.endColumn]));
            const removedCount = mergeIntervals(intervals).reduce((total, [start, end]) => {
                const overlap = Math.min(end, currentEnd) - Math.max(start, 0) + 1;
                return total + Math.max(0, overlap);
            }, 0);

            return isRow
                ? { ...targetRange, startRow: 0, endRow: Math.max(0, currentEnd - removedCount) }
                : { ...targetRange, startColumn: 0, endColumn: Math.max(0, currentEnd - removedCount) };
        }
        default:
            // shifting cells along the axis keeps the whole axis covered
            return targetRange;
    }
}

export const handleCommonDefaultRangeChangeWithEffectRefCommands = (range: IRange, commandInfo: ICommandInfo): IRange[] => {
    const wholeRangeResult = handleWholeRangeCommand(range, commandInfo);
    if (wholeRangeResult) {
        return wholeRangeResult;
    }

    let operator: IOperator[] = [];
    switch (commandInfo.id) {
        case EffectRefRangId.DeleteRangeMoveLeftCommandId: {
            return handleDeleteRangeMoveLeftCommon(commandInfo as IDeleteRangeMoveLeftCommand, range);
        }
        case EffectRefRangId.DeleteRangeMoveUpCommandId: {
            return handleDeleteRangeMoveUpCommon(commandInfo as IDeleteRangeMoveUpCommand, range);
        }
        case EffectRefRangId.InsertRangeMoveDownCommandId: {
            return handleInsertRangeMoveDownCommon(commandInfo as IInsertRangeMoveDownCommand, range);
        }
        case EffectRefRangId.InsertRangeMoveRightCommandId: {
            return handleInsertRangeMoveRightCommon(commandInfo as IInsertRangeMoveRightCommand, range);
        }
        case EffectRefRangId.InsertColCommandId: {
            return handleInsertColCommon(commandInfo as IInsertColCommand, range);
        }
        case EffectRefRangId.InsertRowCommandId: {
            return handleInsertRowCommon(commandInfo as IInsertRowCommand, range);
        }
        case EffectRefRangId.MoveColsCommandId: {
            return handleMoveColsCommon(commandInfo as IMoveColsCommand, range);
        }
        case EffectRefRangId.MoveRangeCommandId: {
            return handleMoveRangeCommon(commandInfo as IMoveRangeCommand, range);
        }
        case EffectRefRangId.MoveRowsCommandId: {
            return handleMoveRowsCommon(commandInfo as IMoveRowsCommand, range);
        }
        case EffectRefRangId.ReorderRangeCommandId: {
            return handleReorderRangeCommon(commandInfo as IReorderRangeCommand, range);
        }
        case EffectRefRangId.RemoveColCommandId: {
            operator = handleIRemoveCol(commandInfo as IRemoveRowColCommand, range);
            break;
        }
        case EffectRefRangId.RemoveRowCommandId: {
            return handleRemoveRowCommon(commandInfo.params as IRemoveRowColCommandInterceptParams, range);
        }
    }
    const resultRange = runRefRangeMutations(operator, range);
    return resultRange ? [resultRange] : [];
};

export const handleCommonRangeChangeWithEffectRefCommandsSkipNoInterests = (range: IRange, commandInfo: ICommandInfo, deps: { selectionManagerService: SheetsSelectionsService }) => {
    const skipCommands = [DeleteRangeMoveLeftCommand.id, DeleteRangeMoveUpCommand.id, InsertRangeMoveDownCommand.id, InsertRangeMoveRightCommandId];
    if (skipCommands.includes(commandInfo.id)) {
        return handleCommonDefaultRangeChangeWithEffectRefCommands(range, commandInfo);
    }

    const effectRanges = getEffectedRangesOnCommand(commandInfo as EffectRefRangeParams, deps);
    if (effectRanges.some((effectRange) => Rectangle.intersects(effectRange, range))) {
        return handleCommonDefaultRangeChangeWithEffectRefCommands(range, commandInfo);
    }

    return range;
};

/**
 * This function should work as a pure function.
 *
 * @pure
 * @param range
 * @param mutation
 * @returns the adjusted range
 */

export function adjustRangeOnMutation(range: Readonly<IRange>, mutation: IMutationInfo<MutationsAffectRange>): Nullable<IRange> {
    // we map mutation params to corresponding
    const { id, params } = mutation;
    let baseRangeOperator: {
        length: number;
        step: number;
        type?: OperatorType;
    } | null | IOperator[] = {
        length: 0,
        step: 0,
        type: OperatorType.Unknown,
    };
    switch (id) {
        case RemoveSheetMutation.id:
            baseRangeOperator.type = OperatorType.Delete;
            break;
        case MoveRowsMutation.id:
            baseRangeOperator = handleBaseMoveRowsCols(
                { start: (params as IMoveRowsMutationParams).sourceRange.startRow, end: (params as IMoveRowsMutationParams).sourceRange.endRow },
                { start: (params as IMoveRowsMutationParams).targetRange.startRow, end: (params as IMoveRowsMutationParams).targetRange.endRow },
                { start: range.startRow, end: range.endRow }
            );
            baseRangeOperator.type = OperatorType.VerticalMove;
            break;
        case MoveColsMutation.id:
            baseRangeOperator = handleBaseMoveRowsCols(
                { start: (params as IMoveColumnsMutationParams).sourceRange.startColumn, end: (params as IMoveColumnsMutationParams).sourceRange.endColumn },
                { start: (params as IMoveColumnsMutationParams).targetRange.startColumn, end: (params as IMoveColumnsMutationParams).targetRange.endColumn },
                { start: range.startColumn, end: range.endColumn }
            );
            baseRangeOperator.type = OperatorType.HorizontalMove;
            break;
        case RemoveColMutation.id:
            baseRangeOperator = handleBaseRemoveRange((params as IRemoveColMutationParams).range, range);
            if (baseRangeOperator) {
                baseRangeOperator.type = OperatorType.HorizontalMove;
            } else {
                baseRangeOperator = { step: 0, length: 0, type: OperatorType.Delete };
            }
            break;
        case RemoveRowMutation.id:
            baseRangeOperator = handleBaseRemoveRange(rotateRange((params as IRemoveRowsMutationParams).range), rotateRange(range));
            if (baseRangeOperator) {
                baseRangeOperator.type = OperatorType.VerticalMove;
            } else {
                baseRangeOperator = { step: 0, length: 0, type: OperatorType.Delete };
            }
            break;
        case InsertRowMutation.id:
            baseRangeOperator = handleBaseInsertRange(rotateRange((params as IInsertRowMutationParams).range), rotateRange(range));
            baseRangeOperator.type = OperatorType.VerticalMove;
            break;
        case InsertColMutation.id:
            baseRangeOperator = handleBaseInsertRange((params as IInsertColMutationParams).range, range);
            baseRangeOperator.type = OperatorType.HorizontalMove;
            break;
        case MoveRangeMutation.id:
            {
                const fromRange = (params as IMoveRangeMutationParams).fromRange || new ObjectMatrix((params as IMoveRangeMutationParams).from).getRange();
                const toRange = (params as IMoveRangeMutationParams).toRange || new ObjectMatrix((params as IMoveRangeMutationParams).to).getRange();
                baseRangeOperator = handleBaseMoveRange(
                    fromRange,
                    toRange,
                    range
                );
            }
            break;
        default:
            break;
    }
    if (baseRangeOperator) {
        return Array.isArray(baseRangeOperator) ? runRefRangeMutations(baseRangeOperator, range) : runRefRangeMutations([baseRangeOperator as IOperator], range);
    } else {
        return range;
    }
}

// eslint-disable-next-line max-lines-per-function, complexity
export function getEffectedRangesOnCommand(command: EffectRefRangeParams, deps: { selectionManagerService: SheetsSelectionsService }) {
    const { selectionManagerService } = deps;
    switch (command.id) {
        case EffectRefRangId.MoveColsCommandId: {
            const params = command.params!;
            return [
                params.fromRange,
                {
                    ...params.toRange,
                    startColumn: params.toRange.startColumn - 0.5,
                    endColumn: params.toRange.endColumn - 0.5,
                },
            ];
        }
        case EffectRefRangId.MoveRowsCommandId: {
            const params = command.params!;
            return [
                params.fromRange,
                {
                    ...params.toRange,
                    startRow: params.toRange.startRow - 0.5,
                    endRow: params.toRange.startRow - 0.5,
                },
            ];
        }
        case EffectRefRangId.MoveRangeCommandId: {
            const params = command;
            return [params.params!.fromRange, params.params!.toRange];
        }
        case EffectRefRangId.InsertRowCommandId: {
            const params = command;
            const range: IRange = params.params!.range;
            return [
                {
                    ...range,
                    startRow: range.startRow - 0.5,
                    endRow: range.endRow - 0.5,
                },
            ];
        }
        case EffectRefRangId.InsertColCommandId: {
            const params = command;
            const range: IRange = params.params!.range;
            return [
                {
                    ...range,
                    startColumn: range.startColumn - 0.5,
                    endColumn: range.endColumn - 0.5,
                },
            ];
        }
        case EffectRefRangId.RemoveRowCommandId: {
            const params = command;
            const range: IRange = params.params!.range;
            return [range];
        }
        case EffectRefRangId.RemoveColCommandId: {
            const params = command;
            const range: IRange = params.params!.range;
            return [range];
        }
        case EffectRefRangId.DeleteRangeMoveUpCommandId:
        case EffectRefRangId.InsertRangeMoveDownCommandId: {
            const params = command;
            const range = params.params?.range || selectionManagerService.getCurrentSelections()?.map((s) => s.range)?.[0];
            if (!range) {
                return [];
            }
            return [range];
        }
        case EffectRefRangId.DeleteRangeMoveLeftCommandId:
        case EffectRefRangId.InsertRangeMoveRightCommandId: {
            const params = command;
            const range = params.params?.range || selectionManagerService.getCurrentSelections()?.map((s) => s.range)?.[0];
            if (!range) {
                return [];
            }
            return [range];
        }
        case EffectRefRangId.ReorderRangeCommandId: {
            const params = command;
            const { range, order } = params.params!;
            const effectRanges = [];
            for (let row = range.startRow; row <= range.endRow; row++) {
                if (row in order) {
                    effectRanges.push({
                        startRow: row,
                        endRow: row,
                        startColumn: range.startColumn,
                        endColumn: range.endColumn,
                    });
                }
            }
            return effectRanges;
        }
    }
}

export function getEffectedRangesOnMutation(mutation: IMutationInfo<MutationsAffectRange>) {
    switch (mutation.id) {
        case MoveColsMutation.id: {
            const params = mutation.params as IMoveColumnsMutationParams;
            return [
                params.sourceRange,
                {
                    ...params.targetRange,
                    startColumn: params.targetRange.startColumn - 0.5,
                    endColumn: params.targetRange.startColumn - 0.5,
                },
            ];
        }
        case MoveRowsMutation.id: {
            const params = mutation.params as IMoveRowsMutationParams;
            return [
                params.sourceRange,
                {
                    ...params.targetRange,
                    startRow: params.targetRange.startRow - 0.5,
                    endRow: params.targetRange.startRow - 0.5,
                },
            ];
        }

        case MoveRangeMutation.id: {
            const params = mutation.params as IMoveRangeMutationParams;
            return [new ObjectMatrix(params.from.value).getRange(), new ObjectMatrix(params.to.value).getRange()];
        }
        case InsertColMutation.id: {
            const params = mutation.params as IInsertColMutationParams;
            const range: IRange = params.range;
            return [
                {
                    ...range,
                    startColumn: range.startColumn - 0.5,
                    endColumn: range.startColumn - 0.5,
                },
            ];
        }
        case InsertRowMutation.id: {
            const params = mutation.params as IInsertRowMutationParams;
            const range: IRange = params.range;
            return [
                {
                    ...range,
                    startRow: range.startRow - 0.5,
                    endRow: range.startRow - 0.5,
                },
            ];
        }
        case RemoveColMutation.id: {
            const params = mutation.params as IRemoveColMutationParams;
            const range: IRange = params.range;
            return [range];
        }
        case RemoveRowMutation.id: {
            const params = mutation.params as IRemoveRowsMutationParams;
            const range: IRange = params.range;
            return [range];
        }
        default:
            break;
    }
}

// eslint-disable-next-line max-lines-per-function, complexity
export function getSeparateEffectedRangesOnCommand(accessor: IAccessor, command: EffectRefRangeParams): {
    unitId: string;
    subUnitId: string;
    ranges: IRange[];
} | undefined {
    const univerInstanceService = accessor.get(IUniverInstanceService);

    switch (command.id) {
        case EffectRefRangId.MoveColsCommandId: {
            const params = command.params as IMoveColsCommandParams;
            const target = getSheetCommandTarget(univerInstanceService, params);
            if (!target) return;

            const { unitId, subUnitId } = target;
            const { fromRange, toRange } = params;

            return {
                unitId,
                subUnitId,
                ranges: [
                    fromRange,
                    {
                        ...toRange,
                        startColumn: fromRange.startColumn < toRange.startColumn ? fromRange.endColumn + 1 : toRange.startColumn,
                        endColumn: fromRange.startColumn < toRange.startColumn ? toRange.endColumn - 1 : fromRange.startColumn - 1,
                    },
                ],
            };
        }
        case EffectRefRangId.MoveRowsCommandId: {
            const params = command.params as IMoveRowsCommandParams;
            const target = getSheetCommandTarget(univerInstanceService, params);
            if (!target) return;

            const { unitId, subUnitId } = target;
            const { fromRange, toRange } = params;

            return {
                unitId,
                subUnitId,
                ranges: [
                    fromRange,
                    {
                        ...toRange,
                        startRow: fromRange.startRow < toRange.startRow ? fromRange.endRow + 1 : toRange.startRow,
                        endRow: fromRange.startRow < toRange.startRow ? toRange.endRow - 1 : fromRange.startRow - 1,
                    },
                ],
            };
        }
        case EffectRefRangId.MoveRangeCommandId: {
            const params = command.params as IMoveRangeCommandParams;
            const target = getSheetCommandTarget(univerInstanceService);
            if (!target) return;

            const { unitId, subUnitId } = target;
            const { fromRange, toRange } = params;

            return {
                unitId,
                subUnitId,
                ranges: [fromRange, toRange],
            };
        }
        case EffectRefRangId.InsertRowCommandId: {
            const params = command.params as IInsertRowCommandParams;
            const target = getSheetCommandTarget(univerInstanceService, params);
            if (!target) return;

            const { worksheet, unitId, subUnitId } = target;
            const { range } = params;

            return {
                unitId,
                subUnitId,
                ranges: [
                    ...range.startRow > 0
                        ? [{
                            ...range,
                            startRow: range.startRow - 1,
                            endRow: range.endRow - 1,
                        }]
                        : [],
                    {
                        ...range,
                        startRow: range.startRow,
                        endRow: worksheet.getRowCount() - 1,
                    },
                ],
            };
        }
        case EffectRefRangId.InsertColCommandId: {
            const params = command.params as IInsertColCommandParams;
            const target = getSheetCommandTarget(univerInstanceService, params);
            if (!target) return;

            const { worksheet, unitId, subUnitId } = target;
            const { range } = params;

            return {
                unitId,
                subUnitId,
                ranges: [
                    ...range.startColumn > 0
                        ? [{
                            ...range,
                            startColumn: range.startColumn - 1,
                            endColumn: range.endColumn - 1,
                        }]
                        : [],
                    {
                        ...range,
                        startColumn: range.startColumn,
                        endColumn: worksheet.getColumnCount() - 1,
                    },
                ],
            };
        }
        case EffectRefRangId.RemoveRowCommandId: {
            const params = command.params as IRemoveRowColCommandInterceptParams;
            const target = getSheetCommandTarget(univerInstanceService, params);
            if (!target) return;

            const { worksheet, unitId, subUnitId } = target;
            const { range } = params;

            return {
                unitId,
                subUnitId,
                ranges: [
                    range,
                    {
                        ...range,
                        startRow: range.endRow + 1,
                        endRow: worksheet.getRowCount() - 1,
                    },
                ],
            };
        }
        case EffectRefRangId.RemoveColCommandId: {
            const params = command.params as IRemoveRowColCommandInterceptParams;
            const target = getSheetCommandTarget(univerInstanceService, params);
            if (!target) return;

            const { worksheet, unitId, subUnitId } = target;
            const { range } = params;

            return {
                unitId,
                subUnitId,
                ranges: [
                    range,
                    {
                        ...range,
                        startColumn: range.endColumn + 1,
                        endColumn: worksheet.getColumnCount() - 1,
                    },
                ],
            };
        }
        case EffectRefRangId.DeleteRangeMoveUpCommandId:
        case EffectRefRangId.InsertRangeMoveDownCommandId: {
            const params = command.params as IDeleteRangeMoveUpCommandParams | IInsertRangeMoveDownCommandParams;
            const target = getSheetCommandTarget(univerInstanceService);
            if (!target) return;

            const { worksheet, unitId, subUnitId } = target;
            const { range } = params;

            return {
                unitId,
                subUnitId,
                ranges: [
                    range,
                    {
                        ...range,
                        startRow: range.endRow + 1,
                        endRow: worksheet.getRowCount() - 1,
                    },
                ],
            };
        }
        case EffectRefRangId.DeleteRangeMoveLeftCommandId:
        case EffectRefRangId.InsertRangeMoveRightCommandId: {
            const params = command.params as IDeleteRangeMoveLeftCommandParams | IInsertRangeMoveRightCommandParams;
            const target = getSheetCommandTarget(univerInstanceService);
            if (!target) return;

            const { worksheet, unitId, subUnitId } = target;
            const { range } = params;

            return {
                unitId,
                subUnitId,
                ranges: [
                    range,
                    {
                        ...range,
                        startColumn: range.endColumn + 1,
                        endColumn: worksheet.getColumnCount() - 1,
                    },
                ],
            };
        }
        case EffectRefRangId.ReorderRangeCommandId: {
            const params = command.params as IReorderRangeCommandParams;
            const target = getSheetCommandTarget(univerInstanceService);
            if (!target) return;

            const { unitId, subUnitId } = target;
            const { range, order } = params;

            const effectRanges = [];
            for (let row = range.startRow; row <= range.endRow; row++) {
                if (row in order) {
                    effectRanges.push({
                        startRow: row,
                        endRow: row,
                        startColumn: range.startColumn,
                        endColumn: range.endColumn,
                    });
                }
            }

            return {
                unitId,
                subUnitId,
                ranges: effectRanges,
            };
        }
    }
}