import './index';

describe('Worker', () => {
    describe('Component vnWorkerCalendar', () => {
        let $httpBackend;
        let $httpParamSerializer;
        let $scope;
        let controller;
        let year = Date.vnNew().getFullYear();

        beforeEach(ngModule('worker'));

        beforeEach(inject(($componentController, $rootScope, _$httpParamSerializer_, _$httpBackend_) => {
            $scope = $rootScope.$new();
            $httpBackend = _$httpBackend_;
            $httpParamSerializer = _$httpParamSerializer_;
            const $element = angular.element('<vn-worker-calendar></vn-worker-calendar>');
            controller = $componentController('vnWorkerCalendar', {$element, $scope});
            controller.isSubordinate = true;
            controller.absenceType = {id: 1, name: 'Holiday', code: 'holiday', rgb: 'red'};
            controller.$params.id = 1106;
            controller._worker = {id: 1106};
            controller.card = {
                hasWorkCenter: true
            };
        }));

        describe('year() getter', () => {
            it(`should return the year number of the calendar date`, () => {
                expect(controller.year).toEqual(year);
            });
        });

        describe('year() setter', () => {
            it(`should set the year of the calendar date`, () => {
                jest.spyOn(controller, 'refresh').mockReturnValue(Promise.resolve());

                const previousYear = year - 1;
                controller.year = previousYear;

                expect(controller.year).toEqual(previousYear);
                expect(controller.date.getFullYear()).toEqual(previousYear);
                expect(controller.refresh).toHaveBeenCalledWith();
            });
        });

        describe('businessId() setter', () => {
            it(`should set the contract id and then call to the refresh method`, () => {
                jest.spyOn(controller, 'refresh').mockReturnValue(Promise.resolve());

                controller.businessId = 1106;

                expect(controller.refresh).toHaveBeenCalledWith();
            });
        });

        describe('months property', () => {
            it(`should return an array of twelve months length`, () => {
                const started = new Date(year, 0, 1);
                const ended = new Date(year, 11, 1);

                expect(controller.months.length).toEqual(12);
                expect(controller.months[0]).toEqual(started);
                expect(controller.months[11]).toEqual(ended);
            });
        });

        describe('worker() setter', () => {
            it(`should perform a get query and set the reponse data on the model`, () => {
                controller.getIsSubordinate = jest.fn();
                controller.getActiveContract = jest.fn();

                let today = Date.vnNew();
                let tomorrow = new Date(today.getTime());
                tomorrow.setDate(tomorrow.getDate() + 1);

                let yesterday = new Date(today.getTime());
                yesterday.setDate(yesterday.getDate() - 1);

                controller.worker = {id: 1107};

                expect(controller.getIsSubordinate).toHaveBeenCalledWith();
                expect(controller.getActiveContract).toHaveBeenCalledWith();
            });
        });

        describe('getIsSubordinate()', () => {
            it(`should return whether the worker is a subordinate`, () => {
                $httpBackend.expect('GET', `Workers/1106/isSubordinate`).respond(true);
                controller.getIsSubordinate();
                $httpBackend.flush();

                expect(controller.isSubordinate).toBe(true);
            });
        });

        describe('getActiveContract()', () => {
            it(`should return the current contract and then set the businessId property`, () => {
                jest.spyOn(controller, 'refresh').mockReturnValue(Promise.resolve());

                $httpBackend.expect('GET', `Workers/1106/activeContract`).respond({businessFk: 1106});
                controller.getActiveContract();
                $httpBackend.flush();

                expect(controller.businessId).toEqual(1106);
            });
        });

        describe('getContractHolidays()', () => {
            it(`should return the worker holidays amount and then set the contractHolidays property`, () => {
                const today = Date.vnNew();
                const year = today.getFullYear();

                const serializedParams = $httpParamSerializer({year});
                $httpBackend.expect('GET', `Workers/1106/holidays?${serializedParams}`).respond({totalHolidays: 28});
                controller.getContractHolidays();
                $httpBackend.flush();

                expect(controller.contractHolidays).toEqual({totalHolidays: 28});
            });
        });

        describe('formatDay()', () => {
            it(`should set the day element style`, () => {
                const today = Date.vnNew();

                controller.events[today.getTime()] = {
                    name: 'Holiday',
                    color: '#000'
                };

                const dayElement = angular.element('<div><section></section></div>')[0];
                const dayNumber = dayElement.firstElementChild;

                controller.formatDay(today, dayElement);

                expect(dayNumber.title).toEqual('Holiday');
                expect(dayNumber.style.backgroundColor).toEqual('rgb(0, 0, 0)');
            });
        });

        describe('pick()', () => {
            it(`should set the absenceType property to null if they match with the current one`, () => {
                const absenceType = {id: 1, name: 'Holiday'};
                controller.absenceType = absenceType;
                controller.pick(absenceType);

                expect(controller.absenceType).toBeNull();
            });

            it(`should set the absenceType property`, () => {
                const absenceType = {id: 1, name: 'Holiday'};
                const expectedAbsence = {id: 2, name: 'Leave of absence'};
                controller.absenceType = absenceType;
                controller.pick(expectedAbsence);

                expect(controller.absenceType).toEqual(expectedAbsence);
            });
        });

        describe('onSelection()', () => {
            it(`should show an snackbar message if no absence type is selected`, () => {
                jest.spyOn(controller.vnApp, 'showMessage').mockReturnThis();

                const $event = {};
                const $days = [];
                controller.absenceType = null;
                controller.onSelection($event, $days);

                expect(controller.vnApp.showMessage).toHaveBeenCalledWith('Choose an absence type from the right menu');
            });

            it(`should call to the create() method`, () => {
                jest.spyOn(controller, 'create').mockReturnThis();

                const selectedDay = Date.vnNew();
                const $event = {
                    target: {
                        closest: () => {
                            return {$ctrl: {}};
                        }
                    }
                };
                const $days = [selectedDay];
                controller.absenceType = {id: 1};
                controller.onSelection($event, $days);

                expect(controller.create).toHaveBeenCalledWith(jasmine.any(Object), selectedDay);
            });

            it(`should call to the delete() method`, () => {
                jest.spyOn(controller, 'delete').mockReturnThis();

                const selectedDay = Date.vnNew();
                const expectedEvent = {
                    dated: selectedDay,
                    type: 'holiday',
                    absenceId: 1
                };
                const $event = {
                    target: {
                        closest: () => {
                            return {$ctrl: {}};
                        }
                    }
                };
                const $days = [selectedDay];
                controller.events[selectedDay.getTime()] = expectedEvent;
                controller.absenceType = {id: 1, code: 'holiday'};
                controller.onSelection($event, $days);

                expect(controller.delete).toHaveBeenCalledWith(jasmine.any(Object), selectedDay, expectedEvent);
            });

            it(`should call to the edit() method`, () => {
                jest.spyOn(controller, 'edit').mockReturnThis();

                const selectedDay = Date.vnNew();
                const expectedEvent = {
                    dated: selectedDay,
                    type: 'leaveOfAbsence',
                    absenceId: 1
                };
                const $event = {
                    target: {
                        closest: () => {
                            return {$ctrl: {}};
                        }
                    }
                };
                const $days = [selectedDay];
                controller.events[selectedDay.getTime()] = expectedEvent;
                controller.absenceType = {id: 1, code: 'holiday'};
                controller.onSelection($event, $days);

                expect(controller.edit).toHaveBeenCalledWith(jasmine.any(Object), expectedEvent);
            });
        });

        describe('create()', () => {
            it(`should make a HTTP POST query and then call to the repaintCanceller() method`, () => {
                jest.spyOn(controller, 'repaintCanceller').mockReturnThis();

                const dated = Date.vnNew();
                const calendarElement = {};
                const expectedResponse = {id: 10};

                $httpBackend.expect('POST', `Workers/1106/createAbsence`).respond(200, expectedResponse);
                controller.create(calendarElement, dated);
                $httpBackend.flush();

                const createdEvent = controller.events[dated.getTime()];
                const absenceType = controller.absenceType;

                expect(createdEvent.absenceId).toEqual(expectedResponse.id);
                expect(createdEvent.color).toEqual(absenceType.rgb);
                expect(controller.repaintCanceller).toHaveBeenCalled();
            });
        });

        describe('edit()', () => {
            it(`should make a HTTP PATCH query and then call to the repaintCanceller() method`, () => {
                jest.spyOn(controller, 'repaintCanceller').mockReturnThis();

                const event = {absenceId: 10};
                const calendarElement = {};
                const newAbsenceType = {
                    id: 2,
                    name: 'Leave of absence',
                    code: 'leaveOfAbsence',
                    rgb: 'purple'
                };
                controller.absenceType = newAbsenceType;

                const expectedParams = {absenceId: 10, absenceTypeId: 2};
                $httpBackend.expect('PATCH', `Workers/1106/updateAbsence`, expectedParams).respond(200);
                controller.edit(calendarElement, event);
                $httpBackend.flush();

                expect(event.name).toEqual(newAbsenceType.name);
                expect(event.color).toEqual(newAbsenceType.rgb);
                expect(event.type).toEqual(newAbsenceType.code);
                expect(controller.repaintCanceller).toHaveBeenCalled();
            });
        });

        describe('delete()', () => {
            it(`should make a HTTP DELETE query and then call to the repaintCanceller() method`, () => {
                jest.spyOn(controller, 'repaintCanceller').mockReturnThis();

                const expectedParams = {absenceId: 10};
                const calendarElement = {};
                const selectedDay = Date.vnNew();
                const expectedEvent = {
                    dated: selectedDay,
                    type: 'leaveOfAbsence',
                    absenceId: 10
                };

                controller.events[selectedDay.getTime()] = expectedEvent;

                const serializedParams = $httpParamSerializer(expectedParams);
                $httpBackend.expect('DELETE', `Workers/1106/deleteAbsence?${serializedParams}`).respond(200);
                controller.delete(calendarElement, selectedDay, expectedEvent);
                $httpBackend.flush();

                const event = controller.events[selectedDay.getTime()];

                expect(event).toBeUndefined();
                expect(controller.repaintCanceller).toHaveBeenCalled();
            });
        });

        describe('repaintCanceller()', () => {
            it(`should cancell the callback execution timer`, () => {
                jest.spyOn(window, 'clearTimeout');
                jest.spyOn(window, 'setTimeout');

                const timeoutId = 90;
                controller.canceller = timeoutId;

                controller.repaintCanceller(() => {
                    return 'My callback';
                });

                expect(window.clearTimeout).toHaveBeenCalledWith(timeoutId);
                expect(window.setTimeout).toHaveBeenCalledWith(jasmine.any(Function), 500);
            });
        });

        describe('refresh()', () => {
            it(`should make a HTTP GET query and then call to the onData() method`, () => {
                jest.spyOn(controller, 'onData').mockReturnThis();

                const expecteResponse = [{id: 1}];
                const expectedParams = {workerFk: controller.worker.id, year: year};
                const serializedParams = $httpParamSerializer(expectedParams);
                $httpBackend.expect('GET', `Calendars/absences?${serializedParams}`).respond(200, expecteResponse);
                controller.refresh();
                $httpBackend.flush();

                expect(controller.onData).toHaveBeenCalledWith(expecteResponse);
            });
        });
    });
});