import DataUnit from "../../src/dataunit/DataUnit";
import { DataType } from "../../src/dataunit/metadata/DataType";
import { Sort, SortingProvider, SortMode } from "../../src/dataunit/metadata/UnitMetadata";
import { ExecutionContext } from "../../src/dataunit/state/action/DataUnitAction";
import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
import { recordsTest } from "./resources/records";

describe('Records selection', () => {
    let dataUnit: DataUnit;

    beforeEach(() => {
        jest.clearAllMocks();
        window.requestAnimationFrame = (functionCallback: Function) => functionCallback();
        ({ dataUnit } = createDataUnitMock());
    });

    describe('getSelectionInfo', () => {
        it('should return selection records', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            const response = dataUnit.getSelectionInfo();
            expect(response).toStrictEqual(expect.objectContaining({ records: [recordsTest[0]] }));
        });

        it('should get all records', async () => {
            await dataUnit.loadData();
            const allRecodsLoader = jest.fn().mockReturnValue(recordsTest);
            dataUnit.allRecordsLoader = allRecodsLoader;
            dataUnit.selectFirst();
            const response = dataUnit.getSelectionInfo();
            const allRecords = response.getAllRecords?.();
            expect(allRecodsLoader).toHaveBeenCalledWith(dataUnit);
            expect(allRecords).toStrictEqual(recordsTest);
        });

        it('should return empty array when loader return invalid value', async () => {
            await dataUnit.loadData();
            const allRecodsLoader = jest.fn();
            dataUnit.allRecordsLoader = allRecodsLoader;
            dataUnit.selectFirst();
            const response = dataUnit.getSelectionInfo();
            const allRecords = response.getAllRecords?.();
            expect(allRecodsLoader).toHaveBeenCalledWith(dataUnit);
            expect(allRecords).toStrictEqual([]);
        });

        it('should return empty array when not has a loader', async () => {
            await dataUnit.loadData();
            dataUnit.allRecordsLoader = undefined;
            dataUnit.selectFirst();
            const response = dataUnit.getSelectionInfo();
            const allRecords = response.getAllRecords?.();
            expect(allRecords).toStrictEqual([]);
        });

        it('should return sortable records', async () => {
            const sortingProvider: SortingProvider = {
                getSort: () => {
                    const sort: Sort = {
                        field: 'column_name_1',
                        dataType: DataType.TEXT,
                        mode: SortMode.DESC,
                    };
                    return [sort];
                },
            }
            dataUnit.sortingProvider = sortingProvider;
            await dataUnit.loadMetadata();
            await dataUnit.loadData();
            const allRecodsLoader = jest.fn().mockReturnValue(recordsTest);
            dataUnit.allRecordsLoader = allRecodsLoader;
            dataUnit.selectFirst();
            const response = dataUnit.getSelectionInfo();
            const allRecords = response.getAllRecords?.();
            expect(allRecodsLoader).toHaveBeenCalledWith(dataUnit);
            expect(allRecords).toStrictEqual(recordsTest);
        });
    });

    describe('selectAllRecords', () => {
        it('should select all records', async () => {
            await dataUnit.loadData();
            await dataUnit.selectAllRecords();
            const response = dataUnit.getSelectionInfo();
            expect(response).toStrictEqual(expect.objectContaining({ records: recordsTest }));
        });
    });

    describe('unSelectAllRecords', () => {
        it('should remove all records selection', async () => {
            await dataUnit.loadData();
            await dataUnit.selectAllRecords();
            await dataUnit.unSelectAllRecords();
            const response = dataUnit.getSelectionInfo();
            expect(response).toStrictEqual(expect.objectContaining({ records: [] }));
        });
    });

    describe('clearSelection', () => {
        it('should remove all records selection', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            dataUnit.clearSelection();
            const response = dataUnit.getSelectionInfo();
            expect(response).toStrictEqual(expect.objectContaining({ records: [] }));
        });
    });

    describe('updatePageSelection', () => {
        it('should set records selection', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            const response = await dataUnit.updatePageSelection([recordsTest[4].__record__id__]);
            expect(response).toStrictEqual(expect.objectContaining({ records: [recordsTest[4]] }));
        });

        it('should remove all records selection', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            const response = await dataUnit.updatePageSelection([]);
            expect(response).toStrictEqual(expect.objectContaining({ records: [] }));
        });

        it('should remove all records selection', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            const response = await dataUnit.updatePageSelection();
            expect(response).toStrictEqual(expect.objectContaining({ records: [recordsTest[0]] }));
        });
    });

    describe('hasNext', () => {
        it('should return true when has a next record', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            const response = dataUnit.hasNext();
            expect(response).toBeTruthy();
        });

        it('should return false when not has a next record', async () => {
            await dataUnit.loadData();
            dataUnit.selectLast();
            const response = dataUnit.hasNext();
            expect(response).toBeFalsy();
        });
    });

    describe('hasPrevious', () => {
        it('should return true when has a prevous record', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            const response = dataUnit.hasPrevious();
            expect(response).toBeFalsy();
        });

        it('should return false when not has a prevous record', async () => {
            await dataUnit.loadData();
            dataUnit.selectLast();
            const response = dataUnit.hasPrevious();
            expect(response).toBeTruthy();
        });
    });

    describe('nextRecord', () => {
        it('should change selection to second record when has a next in the same page', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            await dataUnit.nextRecord();
            const response = dataUnit.getSelectionInfo();
            expect(response.records).toStrictEqual([recordsTest[1]]);
        });

        it('should change selection to second record when not has a next in the same page', async () => {
            dataUnit.pageSize = 2;
            await dataUnit.loadData();
            dataUnit.selectLast();
            await dataUnit.nextRecord();
            const response = dataUnit.getSelectionInfo();
            expect(response.records).toStrictEqual([recordsTest[2]]);
        });

        it('should call executionCtx', async () => {
            dataUnit.pageSize = 2;
            await dataUnit.loadData();
            dataUnit.selectLast();
            const executionCtx: ExecutionContext = {
                before: jest.fn((value) => value),
            }
            await dataUnit.nextRecord(executionCtx);
            const response = dataUnit.getSelectionInfo();
            expect(response.records).toStrictEqual([recordsTest[2]]);
            expect(executionCtx.before).toHaveBeenCalled();
        });
    });

    describe('previousRecord', () => {
        it('should change selection to first record when has a previous in the same page', async () => {
            await dataUnit.loadData();
            dataUnit.selectLast();
            await dataUnit.previousRecord();
            const response = dataUnit.getSelectionInfo();
            expect(response.records).toStrictEqual([recordsTest[3]]);
        });

        it('should change selection to first record when not has a previous in the same page', async () => {
            dataUnit.pageSize = 2;
            await dataUnit.loadData();
            await dataUnit.gotoPage(1);
            dataUnit.selectFirst();
            await dataUnit.previousRecord();
            const response = dataUnit.getSelectionInfo();
            expect(response.records).toStrictEqual([recordsTest[1]]);
        });

        it('should call executionCtx', async () => {
            dataUnit.pageSize = 2;
            await dataUnit.loadData();
            await dataUnit.gotoPage(1);
            dataUnit.selectFirst();
            const executionCtx: ExecutionContext = {
                before: jest.fn((value) => value),
            }
            await dataUnit.previousRecord(executionCtx);
            const response = dataUnit.getSelectionInfo();
            expect(response.records).toStrictEqual([recordsTest[1]]);
            expect(executionCtx.before).toHaveBeenCalled();
        });
    });
});