import { insertCell, deleteCell } from './column';
import { dissoc, removeNils } from 'valor-app-utils';

describe('insertCell', () => {
  // row1与row2相邻
  const row1 = {
    id: 1,
    cellIds: [31, null, 33, null],
  };
  const cells2 = {
    31: {
      id: 31,
      rowId: 1,
      value: 1,
      dataType: 'number',
      type: 'numeric',
      colspan: 2,
    },
    33: {
      id: 33,
      rowId: 1,
      value: 1,
      dataType: 'number',
      type: 'numeric',
      colspan: 2,
    },
  };
  const baseCell = {
    dataType: 'number',
    value: 0,
    formulaDisabled: false,
    type: 'numeric',
  };

  it('插入到row1行0列, forceMergePolicy=[], 不合并', () => {
    const result = dissoc(insertCell(row1, null, [1, 1, 1, 1, 1], cells2, 0, null, [], true), [
      'sourceCell',
    ]);
    const expected = {
      insertedCell: {
        id: 'randomid1',
        ...baseCell,
        rowId: 1,
        locked: false,
      },
      updatedCell: null,
      updatedRow: { ...row1, cellIds: ['randomid1', ...row1.cellIds] },
    };
    expect(removeNils(result!, { recursive: true })).toEqual(
      removeNils(expected, { recursive: true }),
    );
  });
  it('插入到row1, j=2列, forceMergePolicy=[], 不合并', () => {
    const result = dissoc(insertCell(row1, null, [1, 1, 1, 1, 1], cells2, 2, null, [], true), [
      'sourceCell',
    ]);
    const expected = {
      insertedCell: { id: `randomid1`, ...baseCell, rowId: 1, locked: false },
      updatedCell: null,
      updatedRow: {
        ...row1,
        cellIds: [31, null, `randomid1`, 33, null],
      },
    };
    expect(removeNils(result!, { recursive: true })).toEqual(
      removeNils(expected, { recursive: true }),
    );
  });
  it('插入到row1, j=2列, forceMergePolicy=[left], 需强制合并', () => {
    const result = dissoc(insertCell(row1, null, [1, 1, 1, 1, 1], cells2, 2, 'left', [], true), [
      'sourceCell',
    ]);
    const expected = {
      insertedCell: null,
      updatedCell: {
        old: { id: 31, value: 1, dataType: 'number', type: 'numeric', colspan: 2, rowId: 1 },
        new: { id: 31, value: 1, dataType: 'number', type: 'numeric', colspan: 3, rowId: 1 },
      },
      updatedRow: {
        ...row1,
        cellIds: [31, null, null, 33, null],
      },
    };
    expect(removeNils(result!, { recursive: true })).toEqual(
      removeNils(expected, { recursive: true }),
    );
  });
  it('插入到row1, j=1列, forceMergePolicy=[*], 自动合并', () => {
    const result = dissoc(insertCell(row1, null, [1, 1, 1, 1, 1], cells2, 2, 'left', [], true), [
      'sourceCell',
    ]);
    const expected = {
      insertedCell: null,
      updatedCell: {
        old: { id: 31, value: 1, dataType: 'number', type: 'numeric', colspan: 2, rowId: 1 },
        new: { id: 31, value: 1, dataType: 'number', type: 'numeric', colspan: 3, rowId: 1 },
      },
      updatedRow: {
        ...row1,
        cellIds: [31, null, null, 33, null],
      },
    };
    expect(removeNils(result!, { recursive: true })).toEqual(
      removeNils(expected, { recursive: true }),
    );
  });

  // row2与row3相邻
  const row2 = {
    id: 3,
    cellIds: [31, null, 33, null],
    type: 'body' as any,
  };
  const row3 = {
    id: 4,
    cellIds: [null, null, null, null],
    type: 'body' as any,
  };
  it('插入到row3, j=4列, j=4在上行是一个新单元格', () => {
    // 这里的left已经没有意义了
    const result = dissoc(insertCell(row3, null, [2, 0, 2, 0, 1], {}, 4, 'left', [], true), [
      'sourceCell',
    ]);
    const expected = {
      insertedCell: { id: `randomid4`, ...baseCell, rowId: 4 },
      updatedCell: {},
      updatedRow: {
        ...row3,
        cellIds: [null, null, null, null, 'randomid4'],
      },
    };
    expect(removeNils(result!, { recursive: true })).toEqual(
      removeNils(expected, { recursive: true }),
    );
  });
  it('插入到row3, j=3列, j=3在上行被合并了', () => {
    // 这里的left已经没有意义了
    const result = dissoc(insertCell(row3, null, [2, 0, 3, 0, 0], {}, 3, 'left', [], true), [
      'sourceCell',
    ]);
    const expected = {
      insertedCell: null,
      updatedCell: {},
      updatedRow: {
        ...row3,
        cellIds: [null, null, null, null, null],
      },
    };
    expect(removeNils(result!, { recursive: true })).toEqual(
      removeNils(expected, { recursive: true }),
    );
  });

  // row5与row6相邻
  const row5 = {
    id: 5,
    cellIds: [31, null, 33, null],
  };
  const row6 = {
    id: 6,
    cellIds: [41, null, null, null],
  };
  const cells6 = {
    41: {
      id: 41,
      value: 1,
      dataType: 'number',
      type: 'numeric',
      colspan: 2,
      rowId: 6,
    },
  };
  it('插入到row6, j=4列, j=4在上行是一个新单元格', () => {
    // 这里的left已经没有意义了
    const result = dissoc(insertCell(row6, null, [2, 0, 2, 0, 1], cells6, 4, 'left', [], true), [
      'sourceCell',
    ]);
    const expected = {
      insertedCell: { id: `randomid6`, ...baseCell, rowId: 6, locked: false },
      updatedCell: {},
      updatedRow: {
        ...row6,
        cellIds: [41, null, null, null, 'randomid6'],
      },
    };
    expect(removeNils(result!, { recursive: true })).toEqual(
      removeNils(expected, { recursive: true }),
    );
  });
  it('插入到row6, j=3列, j=3在上行被合并了', () => {
    // 这里的left已经没有意义了
    const result = dissoc(insertCell(row6, null, [2, 0, 3, 0, 0], {}, 3, 'left', [], true), [
      'sourceCell',
    ]);
    const expected = {
      insertedCell: null,
      updatedCell: {},
      updatedRow: {
        ...row6,
        cellIds: [41, null, null, null, null],
      },
    };
    expect(removeNils(result!, { recursive: true })).toEqual(
      removeNils(expected, { recursive: true }),
    );
  });
});

describe('deleteCell', () => {
  const row1 = {
    id: 1,
    cellIds: [31, null, 33, null],
  };
  const cells1 = {
    31: {
      id: 31,
      rowId: 1,
      value: 1,
      dataType: 'number',
      type: 'numeric',
      colspan: 1,
    },
    // 32: 被上行rowspan
    33: {
      id: 33,
      rowId: 1,
      value: 1,
      dataType: 'number',
      type: 'numeric',
      colspan: 2,
    },
    // 33: 被33colspan
  };

  const baseCell = {
    dataType: 'number',
    value: 0,
    formulaDisabled: false,
    type: 'numeric',
    rowId: 1,
  };

  it('删除第1列', () => {
    const result = deleteCell(row1, cells1, 0, true);
    const expected = {
      updatedCell: null,
      deletedCell: cells1[31],
      insertedCell: null,
      updatedRow: { ...row1, cellIds: [null, 33, null] },
    };
    expect(removeNils(result!, { recursive: true })).toEqual(
      removeNils(expected, { recursive: true }),
    );
  });

  it('删除第2列', () => {
    const result = deleteCell(row1, cells1, 1, true);
    const expected = {
      updatedCell: null,
      deletedCell: null,
      insertedCell: null,
      updatedRow: { ...row1, cellIds: [31, 33, null] },
    };
    expect(removeNils(result!, { recursive: true })).toEqual(
      removeNils(expected, { recursive: true }),
    );
  });

  it('删除第3列', () => {
    const result = deleteCell(row1, cells1, 2, true);
    const expected = {
      updatedCell: null,
      deletedCell: cells1[33],
      insertedCell: { id: 'randomid1', ...baseCell, colspan: 1, value: 1, locked: false },
      updatedRow: { ...row1, cellIds: [31, null, 'randomid1'] },
    };
    expect(removeNils(result!, { recursive: true })).toEqual(
      removeNils(expected, { recursive: true }),
    );
  });

  it('删除第4列', () => {
    const result = deleteCell(row1, cells1, 3, true);
    const expected = {
      updatedCell: { old: cells1[33], new: { ...cells1[33], colspan: 1 } },
      deletedCell: null,
      insertedCell: null,
      updatedRow: { ...row1, cellIds: [31, null, 33] },
    };
    expect(removeNils(result!, { recursive: true })).toEqual(
      removeNils(expected, { recursive: true }),
    );
  });
});