import DataUnit from "../../src/dataunit/DataUnit";
import { DUActionInterceptor } from "../../src/dataunit/interfaces/dataUnit";
import { DataType } from "../../src/dataunit/metadata/DataType";
import { FieldDescriptor } from "../../src/dataunit/metadata/UnitMetadata";
import { Action } from "../../src/dataunit/state/action/DataUnitAction";
import { createDataUnitMock } from "./loader/utils/createDataUnitMock";

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

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

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

        it('should not create a new record when suppressCreateNewRecord is true', async () => {
            await dataUnit.setFieldValue('column_name_1', 'new_value_1', undefined, { suppressCreateNewRecord: true });
            const hasNewRecord = dataUnit.hasNewRecord();
            expect(hasNewRecord).toBeFalsy();
        });

        it('should resolve promise with false when value is the same', async () => {
            dataUnit.selectFirst();
            const response = await dataUnit.setFieldValue('column_name_1', 'column_value_1');
            expect(response).toBeFalsy();
        });

        it('should handle with promise values', async () => {
            const dataChanged = jest.fn();
            const interceptors: DUActionInterceptor = {
                interceptAction: (action) => {
                    if (action.type === Action.DATA_CHANGED) {
                        dataChanged();
                    }
                    return action;
                }
            }
            dataUnit.addInterceptor(interceptors);
            dataUnit.selectFirst();
            const promiseValue = new Promise((resolve) => resolve('promise_value'));
            const response = await dataUnit.setFieldValue('column_name_1', promiseValue);

            expect(response).toBeTruthy();
            expect(dataChanged).toHaveBeenCalled();
        });

        it('should return false when value is the same', async () => {
            dataUnit["areEquivalentValues"] = () => false;
            dataUnit.selectFirst();
            const response = await dataUnit.setFieldValue('column_name_1', 'column_value_1');
            expect(response).toBeFalsy();
        });
    });

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

        it('should set readOnly to true', async () => {
            dataUnit.disableField('column_name_1');
            const field = dataUnit.getField('column_name_1');
            expect(field?.readOnly).toBeTruthy();
        });

        it('should set readOnly to true when readonly is undefined', async () => {
            dataUnit.disableField('column_name_2');
            const field = dataUnit.getField('column_name_2');
            expect(field?.readOnly).toBeTruthy();
        });

        it('should not set readOnly when field metadata not exist', async () => {
            dataUnit.disableField('column_none');
            const field = dataUnit.getField('column_none');
            expect(field).toBeUndefined();
        });
    });

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

        it('should set readOnly to false', async () => {
            dataUnit.enableField('column_name_1');
            const field = dataUnit.getField('column_name_1');
            expect(field?.readOnly).toBeFalsy();
        });

        it('should set readOnly to false when readonly is undefined', async () => {
            dataUnit.enableField('column_name_2');
            const field = dataUnit.getField('column_name_2');
            expect(field?.readOnly).toBeFalsy();
        });

        it('should not set readOnly when field metadata not exist', async () => {
            dataUnit.enableField('column_none');
            const field = dataUnit.getField('column_none');
            expect(field).toBeUndefined();
        });
    });

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

        it('should set visible to false', async () => {
            dataUnit.hideField('column_name_1', { visibleOnConfig: true });
            const field = dataUnit.getField('column_name_1');
            expect(field?.visible).toBeFalsy();
            expect(field?.properties?.visibleOnConfig).toBeTruthy();
        });

        it('should set visible to false when visible is undefined', async () => {
            dataUnit.hideField('column_name_2', { visibleOnConfig: true });
            const field = dataUnit.getField('column_name_2');
            expect(field?.visible).toBeFalsy();
        });

        it('should handle with options undefined', async () => {
            dataUnit.hideField('column_name_3', undefined);
            const field = dataUnit.getField('column_name_3');

            expect(field?.visible).toBeFalsy();
            expect(field?.properties?.visibleOnConfig).toBeUndefined();
            expect(field?.properties).toBeUndefined();
        });

        it('should not set visible when field metadata not exist', async () => {
            dataUnit.hideField('column_none', { visibleOnConfig: true });
            const field = dataUnit.getField('column_none');
            expect(field).toBeUndefined();
        });
    });

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

        it('should set visible to true', async () => {
            dataUnit.showField('column_name_3');
            const field = dataUnit.getField('column_name_3');
            expect(field?.visible).toBeTruthy();
        });

        it('should set visible to true when visible is undefined', async () => {
            dataUnit.showField('column_name_2');
            const field = dataUnit.getField('column_name_2');
            expect(field?.visible).toBeTruthy();
        });

        it('should not set visible when field metadata not exist', async () => {
            dataUnit.showField('column_none');
            const field = dataUnit.getField('column_none');
            expect(field).toBeUndefined();
        });
    });

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

        it('should add field standAlone to metadata', async () => {
            const field: FieldDescriptor = {
                name: 'new_field',
                label: 'New field',
                dataType: DataType.TEXT,
            }
            dataUnit.addField(field);
            expect(dataUnit.metadata.fields).toStrictEqual(expect.arrayContaining([{ ...field, standAlone: true }]));
        });
    });

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

        it('should return number type', async () => {
            const response = dataUnit.valueFromString('column_name_2', '100');
            expect(response).toEqual(100);
        });

        it('should return boolean type', async () => {
            const response = dataUnit.valueFromString('column_name_3', 'true');
            expect(response).toEqual(true);
        });

        it('should return value without any format when not has a metadata to field', async () => {
            const response = dataUnit.valueFromString('column_none', 'true');
            expect(response).toEqual('true');
        });
    });

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

        it('should return string from the number type', async () => {
            const response = dataUnit.valueToString('column_name_2', 100);
            expect(response).toEqual('100');
        });

        it('should return string from the boolean type', async () => {
            const response = dataUnit.valueToString('column_name_3', true);
            expect(response).toEqual('true');
        });

        it('should return string value when not has a metadata to field', async () => {
            const response = dataUnit.valueToString('column_none', true);
            expect(response).toEqual('true');
        });
    });

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

        it('should return string with number format from the number type', async () => {
            const response = dataUnit.getFormattedValue('column_name_2', 100);
            expect(response).toEqual('100,00');
        });

        it('should return string from the boolean type', async () => {
            const response = dataUnit.getFormattedValue('column_name_3', true);
            expect(response).toEqual('Sim');
        });

        it('should return empty string when value is undefined and not has any record selected', async () => {
            const response = dataUnit.getFormattedValue('column_name_1');
            expect(response).toEqual('');
        });

        it('should return value in string when value is undefined and has a record selected', async () => {
            dataUnit.selectFirst();
            const response = dataUnit.getFormattedValue('column_name_1');
            expect(response).toEqual('column_value_1');
        });

        it('should return value in string formated when receive a string', async () => {
            const response = dataUnit.getFormattedValue('column_name_2', '123');
            expect(response).toEqual('123,00');
        });

        it('should return value in string with any formated when dont has a metadata field', async () => {
            const response = dataUnit.getFormattedValue('column_none', '123');
            expect(response).toEqual('123');
        });

        it('should return string value when not has a metadata to field', async () => {
            const response = dataUnit.getFormattedValue('column_none', true);
            expect(response).toEqual('true');
        });
    });

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

        it('should return string with number format from the number type', async () => {
            dataUnit.addSourceFieldValue('column_name_1', 'column_name_2');
            const response = dataUnit.getSourceFieldValue('column_name_1');
            expect(response).toEqual('column_name_2');
        });
    });
});