import { getRowWithCells_subtree, placeCells, splitCell, mergeCells } from './helper';
import { IColumn, IRow, IStoreState } from '../index.data';
import { normalizeCellIdMap, normalizeRows } from '../common/helper';
import * as R from 'rambda';
import { dissoc } from 'valor-app-utils';
import { makeStoreState } from '../SpreadSheetProvider/helper';

describe('getRowWithCells_subtree', () => {
  const state = {
    rows: [
      { id: 1, level: 1, i: 0, cellIds: [1, null] },
      { id: 2, level: 1, i: 1, cellIds: [null, null] },
      {
        id: 3,
        level: 2,
        i: 2,
        cellIds: [3, 5],
      },
      {
        id: 4,
        level: 3,
        i: 3,
        cellIds: [null, 4],
      },
    ],
    columns: [{ id: 0, width: 10, j: 0 }, { id: 1, width: 10, j: 1 }],
    cells: {
      1: { id: 1, rowspan: 2, colspan: 2, rowId: 1, i: 0, j: 0 },
      3: { id: 3, colspan: 2, rowId: 3, i: 2, j: 0 },
      4: { id: 4, rowId: 4, i: 3, j: 1 },
      5: { id: 5, rowId: 4, i: 2, j: 1 },
    },
  } as any;

  it('case0: 删除单行, 无子树', () => {
    const result = getRowWithCells_subtree(state, 0);

    const expected = [
      { id: 1, level: 1, i: 0, cells: [{ id: 1, rowspan: 2, colspan: 2, rowId: 1, i: 0, j: 0 }] },
    ];
    expect(result).toEqual(expected);
  });

  it('case0: 删除带子树的行', () => {
    const result = getRowWithCells_subtree(state, 1);

    const expected = [
      { id: 2, level: 1, i: 1, cells: [] },
      {
        id: 3,
        level: 2,
        i: 2,
        cells: [{ id: 3, colspan: 2, rowId: 3, i: 2, j: 0 }, { id: 5, rowId: 4, i: 2, j: 1 }],
      },
      { id: 4, level: 3, i: 3, cells: [{ id: 4, rowId: 4, i: 3, j: 1 }] },
    ];
    expect(result).toEqual(expected);
  });
});

////////////////////////////  合并单元格   ///////////////////////////
const _columns_: IColumn[] = [
  { width: 60, type: 'numeric' },
  { width: 60, type: 'numeric' },
  { width: 60, type: 'numeric' },
];
const _rows_ = [
  {
    id: 1,
    i: 0,
    type: 'body' as any,
    level: 1,
    area: 'flatten' as any,
    cells: [
      {
        id: 11,
        value: 1,
        rowId: 1,
        i: 0,
        j: 0,
        colspan: 3,
        rowspan: 2,
      },
      null,
      null,
    ],
  },
  {
    id: 2,
    i: 1,
    type: 'body' as any,
    area: 'flatten' as any,
    level: 1,
    cells: [null, null, null],
  },
  {
    id: 3,
    i: 2,
    type: 'body' as any,
    area: 'flatten' as any,
    cells: [
      {
        id: 31,
        value: 1,
        rowId: 3,
        i: 2,
        j: 0,
        formula: 'sumRight()',
        formulaDisabled: false,
      },
      {
        id: 32,
        value: 1,
        rowId: 3,
        i: 2,
        j: 1,
      },
      {
        id: 33,
        value: 1,
        rowId: 3,
        i: 2,
        j: 2,
      },
    ],
  },
];

const sheet = { rows: _rows_, columns: _columns_ };

const state = makeStoreState(sheet);

describe('placeCells', () => {
  it('case0', () => {
    const cell1 = { id: 'cell1' } as any;
    const cell2 = { id: 'cell2' } as any;
    const ij2cells = [{ i: 0, j: 0, cell: cell1 }, { i: 1, j: 1, cell: cell2 }];

    const newRows = R.clone(state.rows);
    newRows[0].cellIds![0] = 'cell1';
    newRows[1].cellIds![1] = 'cell2';
    const expected = {
      ...state,
      rows: newRows,
      cells: {
        ...dissoc(state.cells, [11 + '']),
        cell1: ij2cells[0].cell,
        cell2: ij2cells[1].cell,
      },
    };

    expect(placeCells(state, ij2cells)).toEqual(expected);
  });
});

describe('splitCell', () => {
  it('case0', () => {
    const result = splitCell(state, 11, null as any);
    expect(Object.keys(result.newState.cells!).length).toEqual(9);
    expect(result.newState.cells!['11'].colspan).toEqual(1);
    expect(result.newState.cells!['11'].rowspan).toEqual(1);
    expect(Object.values(result.newState.cells!).filter(it => it.rowId === 2).length).toEqual(3);
    expect(result.undoContext).toEqual([
      { i: 0, j: 0, cell: state.cells[11] },
      { i: 0, j: 1, cell: null },
      { i: 0, j: 2, cell: null },
      { i: 1, j: 0, cell: null },
      { i: 1, j: 1, cell: null },
      { i: 1, j: 2, cell: null },
    ]);
  });
});

describe('mergeCell', () => {
  it('case0', () => {
    const result = mergeCells(state, [31, 33], null as any);
    expect(Object.keys(result.newState.cells!).length).toEqual(2);
    expect(result.newState.cells!['31'].colspan).toEqual(3);
    expect(result.newState.cells!['31'].rowspan).toEqual(1);
    expect(Object.values(result.newState.cells!).filter(it => it.rowId === 3).length).toEqual(1);
    expect(result.undoContext).toEqual([
      { i: 2, j: 0, cell: state.cells[31] },
      { i: 2, j: 1, cell: state.cells[32] },
      { i: 2, j: 2, cell: state.cells[33] },
    ]);
  });
});