import DataUnit from "../../src/dataunit/DataUnit";
import { DataType } from "../../src/dataunit/metadata/DataType";
import { SortMode } from "../../src/dataunit/metadata/UnitMetadata";
import { createDataUnitMock } from "./loader/utils/createDataUnitMock";
import { recordsTest } from "./resources/records";

describe('Info manager', () => {
    let dataUnit: DataUnit;

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

    describe('getters and setters', () => {
        it('should return dataUnit uuid', () => {
            const response = dataUnit.dataUnitId;
            expect(response).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
        });

        it('should return isWaitingToReload', () => {
            let response = dataUnit.isWaitingToReload();
            expect(response).toBeFalsy();
            dataUnit.setWaitingToReload(true);
            response = dataUnit.isWaitingToReload();
            expect(response).toBeTruthy();
        });

        it('should return cancelPagination', () => {
            let response = dataUnit.cancelPagination;
            expect(response).toBeFalsy();
            dataUnit.cancelPagination = true;
            response = dataUnit.cancelPagination;
            expect(response).toBeTruthy();
        });

        it('should return isMultipleEdition', () => {
            let response = dataUnit.isMultipleEdition;
            expect(response).toBeFalsy();
            dataUnit.isMultipleEdition = true;
            response = dataUnit.isMultipleEdition;
            expect(response).toBeTruthy();
        });

        it('should return defaultSorting', () => {
            const sort = {
                dataType: DataType.BOOLEAN,
                field: 'test',
                mode: SortMode.ASC,
            };
            let response = dataUnit.getSort();
            expect(response).toStrictEqual([]);
            dataUnit.defaultSorting = [sort];
            response = dataUnit.getSort();
            expect(response).toStrictEqual([sort]);
        });

        it('should return pageSize', () => {
            let response = dataUnit.pageSize;
            expect(response).toBe(0);
            dataUnit.pageSize = 10;
            response = dataUnit.pageSize;
            expect(response).toBe(10);
        });
    });

    describe('waitingForChange', () => {
        it('should return true for changes field', () => {
            dataUnit.startChange('column_name_1', {
                blocking: true,
                waitmessage: 'test',
            });
            const properties = dataUnit.waitingForChange('column_name_1');
            expect(properties).toBeTruthy();
        });

        it('should return false for no changes field', () => {
            const properties = dataUnit.waitingForChange('column_name_2');
            expect(properties).toBeFalsy();
        });
    });

    describe('getInvalidMessage', () => {
        beforeEach(async () => {
            await dataUnit.loadMetadata();
            await dataUnit.loadData();
        });

        it('should return error message from field', () => {
            const messageTest = 'Error message';
            dataUnit.setInvalidField('column_name_1', messageTest, 'test_1');
            const message = dataUnit.getInvalidMessage('test_1', 'column_name_1');
            expect(message).toBe(messageTest);
        });

        it('should return undefined when not has any error', () => {
            const message = dataUnit.getInvalidMessage('test_1', 'column_name_2');
            expect(message).toBeUndefined();
        });
    });

    describe('isDirty', () => {
        beforeEach(async () => {
            await dataUnit.loadMetadata();
            await dataUnit.loadData();
        });

        it('should return true when has data not saved', async () => {
            dataUnit.selectFirst();
            await dataUnit.setFieldValue('column_name_1', 'new_value');
            const isDirty = dataUnit.isDirty();
            expect(isDirty).toBeTruthy();
        });

        it('should return true when dataUnit child not has data pending', async () => {
            dataUnit.getChildDataunit('test');
            const childDataUnit = dataUnit.getChildDataunit('test');
            childDataUnit.selectFirst();
            await childDataUnit.setFieldValue('column_name_1', 'new_value');
            const isDirty = dataUnit.isDirty();
            expect(isDirty).toBeTruthy();
        });

        it('should return false when dataUnit child has data not saved and ignoreChildren', async () => {
            const childDataUnit = new DataUnit('test', dataUnit);
            childDataUnit.selectFirst();
            await childDataUnit.setFieldValue('column_name_1', 'new_value');
            const isDirty = dataUnit.isDirty(true);
            expect(isDirty).toBeFalsy();
        });
    });

    describe('hasDirtyRecords', () => {
        beforeEach(async () => {
            await dataUnit.loadMetadata();
            await dataUnit.loadData();
            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
            dataUnit.saveLoader = saveLoaderMock;
        });

        it('should return true when any record has data not saved', async () => {
            dataUnit.selectFirst();
            await dataUnit.setFieldValue('column_name_1', 'new_value');
            dataUnit.clearSelection();
            let isDirty = dataUnit.hasDirtyRecords();
            expect(isDirty).toBeTruthy();
            dataUnit.selectLast();
            await dataUnit.setFieldValue('column_name_1', 'new_value');
            dataUnit.clearSelection();
            isDirty = dataUnit.hasDirtyRecords();
            expect(isDirty).toBeTruthy();
        });

        it('should return false when data has be saved', async () => {
            dataUnit.selectFirst();
            await dataUnit.setFieldValue('column_name_1', 'new_value');
            await dataUnit.saveData();
            const isDirty = dataUnit.hasDirtyRecords();
            expect(isDirty).toBeFalsy();
        });
    });

    describe('isNewRecord', () => {
        beforeEach(async () => {
            await dataUnit.loadMetadata();
            await dataUnit.loadData();
        });

        it('should return false when record is not new', async () => {
            dataUnit.selectFirst();
            const recordSelected = dataUnit.getSelectedRecord();
            const isNewRecord = dataUnit.isNewRecord(recordSelected?.__record__id__!);
            expect(isNewRecord).toBeFalsy();
        });

        it('should return true when record is new', async () => {
            await dataUnit.addRecord();
            const recordSelected = dataUnit.getSelectedRecord();
            const isNewRecord = dataUnit.isNewRecord(recordSelected?.__record__id__!);
            expect(isNewRecord).toBeTruthy();
        });
    });

    describe('canUndo', () => {
        beforeEach(async () => {
            await dataUnit.loadMetadata();
            await dataUnit.loadData();
            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
            dataUnit.saveLoader = saveLoaderMock;
        });

        it('should return true when changes can undo', async () => {
            await dataUnit.addRecord();
            const canUndo = dataUnit.canUndo();
            expect(canUndo).toBeTruthy();
        });

        it('should return true when field value changes can undo', async () => {
            dataUnit.selectFirst();
            await dataUnit.setFieldValue('column_name_1', 'new_value');
            const canUndo = dataUnit.canUndo();
            expect(canUndo).toBeTruthy();
        });

        it('should return false when changes can not undo', async () => {
            dataUnit.selectFirst();
            await dataUnit.setFieldValue('column_name_1', 'new_value');
            await dataUnit.saveData();
            const canUndo = dataUnit.canUndo();
            expect(canUndo).toBeFalsy();
        });
    });

    describe('canRedo', () => {
        beforeEach(async () => {
            await dataUnit.loadMetadata();
            await dataUnit.loadData();
            const saveLoaderMock = jest.fn().mockResolvedValue(recordsTest);
            dataUnit.saveLoader = saveLoaderMock;
        });

        it('should return true when changes can redo', async () => {
            await dataUnit.addRecord();
            const canUndo = dataUnit.canUndo();
            expect(canUndo).toBeTruthy();
            dataUnit.undo();
            const canRedo = dataUnit.canRedo();
            expect(canRedo).toBeTruthy();
        });

        it('should return true when field value changes can redo', async () => {
            dataUnit.selectFirst();
            await dataUnit.setFieldValue('column_name_1', 'new_value');
            const canUndo = dataUnit.canUndo();
            expect(canUndo).toBeTruthy();
            dataUnit.undo();
            const canRedo = dataUnit.canRedo();
            expect(canRedo).toBeTruthy();
        });

        it('should return false when changes can not redo', () => {
            const canRedo = dataUnit.canRedo();
            expect(canRedo).toBeFalsy();
        });
    });

    describe('toString', () => {
        it('should return dataUnit name', () => {
            const name = dataUnit.toString();
            expect(name).toContain('dataunit?');
        });
    });
});