jest.mock('../../../../src/utils/ColumnFilterManager', () => ({
  ColumnFilterManager: {
    getColumnFilters: jest.fn(),
    getFilterFunction: jest.fn(),
  },
}));

jest.mock('../../../../src/utils/SortingUtils', () => {
  return {
    __esModule: true, // Indica que este módulo possui uma exportação padrão
    default: {
      getSortingFunction: jest.fn(),
    },
  };
});


import { DataUnitLoaderUtils } from '../../../../src/dataunit/loader/utils/dataUnitLoaderUtils';
import { IColumnFilter } from '../../../../src/utils/ColumnFilterManager';
import { Record } from '../../../../src/dataunit/interfaces/dataUnit';
import { Filter, Sort, SortMode } from '../../../../src/dataunit/metadata/UnitMetadata';
import { DataType } from '../../../../src/dataunit/metadata/DataType';
import { ColumnFilterManager } from '../../../../src/utils/ColumnFilterManager';
import SortingUtils from '../../../../src/utils/SortingUtils';


describe('Utility Functions', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });

  describe('applyFilter', () => {
    it('should return the original records if no filters are provided', () => {
      const records: Record[] = [{ __record__id__: '1' }, { __record__id__: '2' }];
      const filters: Filter[] = [];
      const columnFilterMock = new Map<string, IColumnFilter>();

      (ColumnFilterManager.getColumnFilters as jest.Mock).mockReturnValue(columnFilterMock);
      (ColumnFilterManager.getFilterFunction as jest.Mock).mockReturnValue(undefined);

      const result = DataUnitLoaderUtils.applyFilter(records, {} as any, filters);

      expect(result).toEqual(records);
      expect(ColumnFilterManager.getColumnFilters).toHaveBeenCalledWith(filters, '');
    });

    it('should filter records based on provided filters', () => {
      const records: Record[] = [{ __record__id__: '1' }, { __record__id__: '2' }];
      const filters: Filter[] = [{ name: 'test', expression: '1' }];
      const columnFilterMock = new Map<string, IColumnFilter>();
      columnFilterMock.set('test', { columnName: 'name', ...filters[0] } as IColumnFilter);

      (ColumnFilterManager.getColumnFilters as jest.Mock).mockReturnValue(columnFilterMock);
      (ColumnFilterManager.getFilterFunction as jest.Mock).mockReturnValue((record: Record) => record.__record__id__ === '1');

      const result = DataUnitLoaderUtils.applyFilter(records, {} as any, filters);

      expect(result).toEqual([{ __record__id__: '1' }]);
      expect(ColumnFilterManager.getFilterFunction).toHaveBeenCalledWith({}, Array.from(columnFilterMock.values()));
    });
  });

  describe('buildPaginationInfo function', () => {
    it('should return correct pagination info with default values', () => {

      const result = DataUnitLoaderUtils.buildPaginationInfo({
        recordsLength: 0,
        offset: 0,
        recordsPerPage: 5,
      });

      expect(result).toEqual({
        currentPage: 0,
        firstRecord: 0,
        lastRecord: 0,
        total: 0,
        hasMore: false,
      });
    });

    it('should redosLenth as same size as recordsPerPage', () => {
      const result = DataUnitLoaderUtils.buildPaginationInfo({
        recordsLength: 10,
        offset: 0,
        recordsPerPage: 10,
      });

      expect(result).toEqual({
        currentPage: 0,
        firstRecord: 1,
        lastRecord: 10,
        total: 10,
        hasMore: false,
      });
    });


    it('should handle case when totalRecordsLength and offset 0', () => {
      const result = DataUnitLoaderUtils.buildPaginationInfo({
        recordsLength: 10,
        offset: 0,
        recordsPerPage: 5,
      });

      expect(result).toEqual({
        currentPage: 0,
        firstRecord: 1,
        lastRecord: 5,
        total: 10,
        hasMore: true,
      });
    });

    it('should handle case when currentPageLength is less than totalRecordsLength and lastPage', () => {
      const result = DataUnitLoaderUtils.buildPaginationInfo({
        recordsLength: 10,
        offset: 5,
        recordsPerPage: 5,
      });

      expect(result).toEqual({
        currentPage: 1,
        firstRecord: 6,
        lastRecord: 10,
        total: 10,
        hasMore: false,
      });
    });
  });

  describe('applySorting function', () => {

    it('should return the original records if no sorting is provided', () => {
      const records: Record[] = [{ __record__id__: '1' }, { __record__id__: '2' }];
      const sorting: Sort[] = [];

      const result = DataUnitLoaderUtils.applySorting(records, {} as any, sorting);

      expect(result).toEqual(records);
      expect(SortingUtils.getSortingFunction).not.toHaveBeenCalled();
    });

    it('should sort records based on provided sorting criteria', () => {
      const records: Record[] = [{ __record__id__: '2' }, { __record__id__: '1' }];
      const sorting: Sort[] = [{ field: '__record__id__', mode: SortMode.ASC, dataType: DataType.TEXT }];

      const sortingFunction = (a: Record, b: Record) => (a.__record__id__ > b.__record__id__ ? 1 : -1);
      (SortingUtils.getSortingFunction as jest.Mock).mockReturnValue(sortingFunction);

      const result = DataUnitLoaderUtils.applySorting(records, {} as any, sorting);

      expect(result).toEqual([{ __record__id__: '1' }, { __record__id__: '2' }]);
      expect(SortingUtils.getSortingFunction).toHaveBeenCalledWith({}, sorting);
    });
  });


});