import { getDefaultColumnWidth, reorderData } from './dataTable.helper';
import { ColumnConfig } from './dataTable.types';

interface MockData {
  numberValue?: number;
  dateValue?: string;
  stringValue?: string;
  booleanValue?: boolean;
}

const columnConfig: ColumnConfig<MockData>[] = [
  {
    columnName: 'Number',
    getValue: (item) => item.numberValue,
    align: 'left',
    cellType: 'number',
  },
  {
    columnName: 'Date',
    getValue: (item) => item.dateValue,
    align: 'left',
    cellType: 'date',
  },
  {
    columnName: 'String',
    getValue: (item) => item.stringValue,
    align: 'left',
    cellType: 'text',
  },
  {
    columnName: 'Boolean',
    getValue: (item) => item.booleanValue,
    align: 'left',
    cellType: 'boolean',
  },
];

describe('reorderData tests', () => {
  it('sorts numbers', () => { 
    const ascendingData = [ ... Array(50).keys() ].map((item): MockData => ({ numberValue: item }));
    const descendingData = [ ... ascendingData ].reverse();

    const sortedAscending = reorderData([ ...descendingData ], (item) => item.numberValue, 'number', true);
    const sortedDescending = reorderData([ ...ascendingData ], (item) => item.numberValue, 'number', false);
    
    expect(sortedAscending).toEqual(ascendingData);
    expect(sortedDescending).toEqual(descendingData);
  });

  it('sorts dates', () => {
    const ascendingData = [ ... Array(25).keys() ].map((item): MockData => ({ dateValue: `2020-06-${item+1}` }));
    const descendingData = [ ... ascendingData ].reverse();

    const sortedAscending = reorderData([ ...descendingData ], (item) => item.dateValue, 'date', true);
    const sortedDescending = reorderData([ ...ascendingData ], (item) => item.dateValue, 'date', false);
    
    expect(sortedAscending).toEqual(ascendingData);
    expect(sortedDescending).toEqual(descendingData);
  });

  it('sorts strings', () => {
    const ascendingData = [ 'a', 'b', 'c', 'd', 'e', 'f' ].map((item): MockData => ({ stringValue: item }));
    const descendingData = [ ...ascendingData ].reverse();

    const sortedAscending = reorderData([ ...descendingData ], (item) => item.stringValue, 'text', true);
    const sortedDescending = reorderData([ ...ascendingData ], (item) => item.stringValue, 'text', false);
    
    expect(sortedAscending).toEqual(ascendingData);
    expect(sortedDescending).toEqual(descendingData);
  });

  it('sorts booleans', () => {
    const ascendingData = [ false, false, true, true, true ].map((item): MockData => ({ booleanValue: item }));
    const descendingData = [ ...ascendingData ].reverse();

    const sortedAscending = reorderData([ ...descendingData ], (item) => item.booleanValue, 'boolean', true);
    const sortedDescending = reorderData([ ...ascendingData ], (item) => item.booleanValue, 'boolean', false);
    
    expect(sortedAscending).toEqual(ascendingData);
    expect(sortedDescending).toEqual(descendingData);
  });
});

describe('getDefaultColumnWidth tests', () => {
  it('calculates expected value without fixed widths', () => {
    const result = getDefaultColumnWidth(columnConfig);
    expect(result).toEqual(25);
  });

  it('calculates expected value with fixed widths', () => {
    const customColumnConfig: ColumnConfig<MockData>[] = [
      ...columnConfig,
      {
        columnName: 'Test1',
        getValue: (item) => item.booleanValue,
        align: 'left',
        cellType: 'boolean',
        width: 7,
      },
      {
        columnName: 'Test2',
        getValue: (item) => item.booleanValue,
        align: 'left',
        cellType: 'boolean',
        width: 5,
      },
    ];

    const result = getDefaultColumnWidth(customColumnConfig);
    expect(result).toEqual(22);
  });
});