import DataUnit from "../../src/dataunit/DataUnit";
import { SelectionMode } from "../../src/dataunit/interfaces/dataUnit";
import ErrorException from "../../src/exceptions/ErrorException";
import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
import { recordsTest } from "./resources/records";

describe('Records manager', () => {
    let dataUnit: DataUnit;
    let dataLoaderMock = jest.fn();
    let metadataLoaderMock = jest.fn();

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

    describe('removeRecords', () => {
        it('should remove first record', async () => {
            await dataUnit.loadData();
            await dataUnit.removeRecords(["test_1"], [recordsTest[0]]);
            expect(dataUnit.records).toStrictEqual(recordsTest.slice(1, recordsTest.length));
        });

        it('should remove first record with loader', async () => {
            dataUnit.removeLoader = jest.fn((_, ids) => new Promise<string[]>(resolve => resolve(ids)))
            await dataUnit.loadData();
            await dataUnit.removeRecords(["test_1"], [recordsTest[0]]);
            expect(dataUnit.records).toStrictEqual(recordsTest.slice(1, recordsTest.length));
            expect(dataUnit.removeLoader).toHaveBeenCalled();
        });

        it('should remove two record with loader', async () => {
            dataUnit.removeLoader = jest.fn((_, ids) => new Promise<string[]>(resolve => resolve(ids)))
            await dataUnit.loadData();
            await dataUnit.removeRecords(["test_2", "test_1"], [recordsTest[1], recordsTest[0]]);
            expect(dataUnit.records).toStrictEqual(recordsTest.slice(2, recordsTest.length));
            expect(dataUnit.removeLoader).toHaveBeenCalled();
        });

        it('should remove last', async () => {
            dataUnit.removeLoader = jest.fn((_, ids) => new Promise<string[]>(resolve => resolve(ids)))
            await dataUnit.loadData();
            await dataUnit.removeRecords(["test_5"], [recordsTest[4]]);
            expect(dataUnit.records).toStrictEqual(recordsTest.slice(0, 4));
        });

        it('should handle error dataLoader', async () => {
            dataUnit.removeLoader = jest.fn().mockRejectedValue(new Error("Error test"));
            const removeRecords = async () => await dataUnit.removeRecords(["test_1"], [recordsTest[0]]);
            await expect(removeRecords()).rejects.toBeInstanceOf(ErrorException);
        });
    });

    describe('removeSelectedRecords', () => {
        it('should remove first record', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            const response = await dataUnit.removeSelectedRecords();
            expect(dataUnit.records).toStrictEqual(recordsTest.slice(1, recordsTest.length));
            expect(response).toStrictEqual(["test_1"]);
        });

        it('should remove last record', async () => {
            await dataUnit.loadData();
            dataUnit.selectLast();
            const response = await dataUnit.removeSelectedRecords();
            expect(dataUnit.records).toStrictEqual(recordsTest.slice(0, 4));
            expect(response).toStrictEqual(["test_5"]);
        });

        it('should ignore when not has a record selected', async () => {
            await dataUnit.loadData();
            const response = await dataUnit.removeSelectedRecords();
            expect(dataUnit.records).toStrictEqual(recordsTest);
            expect(response).toStrictEqual([]);
        });

        it('should throw error when all records is selected', async () => {
            await dataUnit.loadData();
            await dataUnit.setSelection(SelectionMode.ALL_RECORDS);
            const removeSelectedRecords = async () => await dataUnit.removeSelectedRecords();
            await expect(removeSelectedRecords()).rejects.toBeInstanceOf(Error);
        });
    });

    describe('copySelected', () => {
        it('should copy first record', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            dataUnit.copySelected();
            expect(dataUnit.records.length).toBe(recordsTest.length + 1);
            expect(dataUnit.records[dataUnit.records.length - 1].__record__id__).toBe("NEW_0");
            expect(dataUnit.records[dataUnit.records.length - 1].__record__source__id__).toBe("test_1");
            expect(dataUnit.records[dataUnit.records.length - 1].__copy__).toBeTruthy();
            expect(dataUnit.records[dataUnit.records.length - 1]).toStrictEqual(expect.objectContaining({
                column_name_1: 'column_value_1',
                column_name_2: 1,
            }));
        });

        it('should copy last record', async () => {
            await dataUnit.loadData();
            dataUnit.selectLast();
            dataUnit.copySelected();
            expect(dataUnit.records[dataUnit.records.length - 1].__record__source__id__).toBe("test_5");
        });

        it('should ignore when not has a record selected', async () => {
            await dataUnit.loadData();
            dataUnit.copySelected();
            expect(dataUnit.records).toStrictEqual(recordsTest);
        });

        it('should ignore when not has records', async () => {
            dataUnit.copySelected();
            expect(dataUnit.records).toStrictEqual([]);
        });

        it('should throw error when all records is selected', async () => {
            await dataUnit.loadData();
            await dataUnit.setSelection(SelectionMode.ALL_RECORDS);
            expect(() => dataUnit.copySelected()).toThrow("Erro interno: Impossível copiar os registros selecionados pois a seleção atual é virtual.");
        });
    });

    describe('hasCopiedRecord', () => {
        it('should be true when has new records', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            dataUnit.copySelected();
            const hasCopiedRecord = dataUnit.hasCopiedRecord();
            expect(hasCopiedRecord).toBeTruthy();
        });

        it('should be false when not have any record', async () => {
            dataUnit.copySelected();
            const hasCopiedRecord = dataUnit.hasCopiedRecord();
            expect(hasCopiedRecord).toBeFalsy();
        });

        it('should be false when not have any new record', async () => {
            await dataUnit.loadData();
            const hasCopiedRecord = dataUnit.hasCopiedRecord();
            expect(hasCopiedRecord).toBeFalsy();
        });

        it('should be false when has new value created', async () => {
            await dataUnit.addRecord();
            const hasCopiedRecord = dataUnit.hasCopiedRecord();
            expect(hasCopiedRecord).toBeFalsy();
        });
    });

    describe('reloadCurrentRecord', () => {
        it('should return empty array when not has recordLoader', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            const response = await dataUnit.reloadCurrentRecord();
            expect(response).toStrictEqual([]);
        });

        it('should return empty array when not has dataLoader', async () => {
            dataUnit.dataLoader = undefined;
            dataUnit.recordLoader = jest.fn().mockResolvedValue({ records: recordsTest });
            const response = await dataUnit.reloadCurrentRecord();
            expect(response).toStrictEqual([]);
        });

        it('should call dataLoader to fech records', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            const recordLoader = jest.fn().mockResolvedValue(recordsTest);
            dataUnit.recordLoader = recordLoader;

            const response = await dataUnit.reloadCurrentRecord();
            expect(response).toStrictEqual(recordsTest);
            expect(recordLoader).toHaveBeenCalledWith(dataUnit, ["test_1"]);
        });

        it('should handle error recordLoader', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            const recordLoader = jest.fn().mockRejectedValue(new Error("Error test"));
            dataUnit.recordLoader = recordLoader;

            const reloadCurrentRecord = () => dataUnit.reloadCurrentRecord();
            await expect(reloadCurrentRecord).rejects.toBeInstanceOf(ErrorException);
        });
    });

    describe('getModifiedRecords', () => {
        it('should return record that has been modified', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            dataUnit.setFieldValue('column_name_1', 'new_value');
            const response = dataUnit.getModifiedRecords();
            expect(response).toStrictEqual([{ ...recordsTest[0], column_name_1: 'new_value' }]);
        });

        it('should return empty when not has any record modified', async () => {
            await dataUnit.loadData();
            const response = dataUnit.getModifiedRecords();
            expect(response).toStrictEqual([]);
        });
    });

    describe('getAddedRecords', () => {
        it('should return the new record has been created', async () => {
            await dataUnit.loadData();
            await dataUnit.addRecord();
            const response = dataUnit.getAddedRecords();
            expect(response).toStrictEqual([{ "__record__id__": "NEW_0", }]);
        });

        it('should return undefined when not has any new record', async () => {
            await dataUnit.loadData();
            const response = dataUnit.getAddedRecords();
            expect(response).toBeUndefined();
        });
    });

    describe('getLastLoadRequest', () => {
        it('should return a empty request', async () => {
            await dataUnit.loadData();
            const response = dataUnit.getLastLoadRequest();
            expect(response).toStrictEqual({
                filters: undefined,
                keepSelection: undefined,
                parentRecordId: undefined,
                sort: [],
                source: undefined,
            });
        });

        it('should return a fully example request', async () => {
            const params = {
                checkLastFilter: true,
                keepSelection: true,
                quickFilter: {
                    filter: {
                        expression: 'test',
                        name: 'test',
                        params: []
                    },
                    term: 'test',
                },
                selectFirstRecord: true,
                source: 'test'
            }
            await dataUnit.loadDataWithParams(params);
            const response = dataUnit.getLastLoadRequest();
            expect(response).toStrictEqual({
                filters: [params.quickFilter.filter],
                keepSelection: true,
                quickFilter: params.quickFilter,
                parentRecordId: undefined,
                sort: [],
                source: 'test'
            });
        });
    });

    describe('clearDataUnit', () => {
        it('should clean all records', async () => {
            await dataUnit.loadData();
            expect(dataUnit.records).toStrictEqual(recordsTest);
            dataUnit.clearDataUnit();
            expect(dataUnit.records).toStrictEqual([]);
        });
    });

    describe('cancelEdition', () => {
        it('should cancel edition', async () => {
            await dataUnit.loadData();
            dataUnit.selectFirst();
            dataUnit.setFieldValue('column_name_1', 'new_value');
            const response = await dataUnit.cancelEdition();
            expect(dataUnit.isDirty()).toBeFalsy();
            expect(response).toBeTruthy();
        });

        it('should cancel edition in child dataUnits', async () => {
            const parentDataUnit = new DataUnit();
            const childDataUnit = parentDataUnit.getChildDataunit('test');
            dataLoaderMock = jest.fn().mockResolvedValue({ records: recordsTest });
            childDataUnit.dataLoader = dataLoaderMock;
            parentDataUnit.dataLoader = dataLoaderMock;
            await childDataUnit.loadData();
            await parentDataUnit.loadData();

            childDataUnit.selectFirst();
            await childDataUnit.setFieldValue('column_name_1', 'new_value');
            await parentDataUnit.setFieldValue('column_name_1', 'new_value');

            const response = await parentDataUnit.cancelEdition();
            expect(childDataUnit.isDirty()).toBeFalsy();
            expect(parentDataUnit.isDirty()).toBeFalsy();
            expect(response).toBeTruthy();
        });

        it('should load data when cancel edition in child dataUnits and has a record selected', async () => {
            const parentDataUnit = new DataUnit();
            const childDataUnit = parentDataUnit.getChildDataunit('test');
            dataLoaderMock = jest.fn().mockResolvedValue({ records: recordsTest });
            childDataUnit.dataLoader = dataLoaderMock;
            parentDataUnit.dataLoader = dataLoaderMock;
            await childDataUnit.loadData();
            await parentDataUnit.loadData();

            parentDataUnit.selectFirst();
            childDataUnit.selectFirst();
            await childDataUnit.setFieldValue('column_name_1', 'new_value');
            await parentDataUnit.setFieldValue('column_name_1', 'new_value');

            const response = await parentDataUnit.cancelEdition();
            expect(childDataUnit.isDirty()).toBeFalsy();
            expect(parentDataUnit.isDirty()).toBeFalsy();
            expect(response).toBeTruthy();
            expect(dataLoaderMock).toHaveBeenCalled();
        });
    });
});