/*
******************************************************************************
* Copyright © 2018 PTA GmbH.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
*
*     http://www.eclipse.org/legal/epl-v10.html
*
******************************************************************************
*/
import { ComponentFixture, TestBed, async, fakeAsync, tick, inject } from '@angular/core/testing';
import { AbstractMockObservableService } from '../../testing/abstract-mock-observable.service';
import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
import { MockComponent } from '../../testing/mock.component';
import { registerLocaleData } from '@angular/common';
import localeDe from '@angular/common/locales/de';
import { FormsModule } from '@angular/forms';
import { Router } from '@angular/router';
import { SessionContext } from './../../common/session-context';
import { Globals } from '../../common/globals';
import { CustomCalendarComponent } from './calendar.component';
import { CustomDateFormatter } from './custom-date-formatter-provider';
import { GridMeasureService } from '../../services/grid-measure.service';
import { UserSettingsService } from '../../services/user-settings.service';
import { RoleAccessHelperService } from '../../services/jobs/role-access-helper.service';
import { RoleAccess } from '../../model/role-access';
import { GridMeasure } from '../../model/grid-measure';
import { UserSettings } from './../../model/user-settings';
import { USERS } from './../../test-data/users';

import {
  startOfDay,
  endOfDay,
  subDays,
  addDays,
  endOfMonth,
  isSameDay,
  isSameMonth,
  addHours
} from 'date-fns';

import {
  CalendarEventTitleFormatter,
  CalendarModule,
  CalendarEvent,
  CalendarEventAction,
  CalendarEventTimesChangedEvent,
  CalendarDateFormatter,
  CalendarDayModule,
  CalendarWeekViewComponent,
  CalendarMonthViewComponent,
  CalendarDayViewComponent
} from 'angular-calendar';
import { ModeValidator } from '../helpers/mode-validator';
import { MessageServiceCustom } from '../../services/message.service';
import { CalendarEntry } from '../../model/calendar-entry';
import { CALENDARENTRY } from '../../test-data/calendar-entry';

class FakeRouter {
  navigate(commands: any[]) {
    return commands[0];
  }
}

describe('CustomCalendarComponent', () => {
  registerLocaleData(localeDe);
  let component: CustomCalendarComponent;
  let fixture: ComponentFixture<CustomCalendarComponent>;
  const calendarEntries: CalendarEntry[] = JSON.parse(JSON.stringify(CALENDARENTRY));
  let routerStub: FakeRouter;
  let sessionContext;

  routerStub = {
    navigate: jasmine.createSpy('navigate').and.callThrough()
  };

  class GridmeasureToEventHelper {
    public createEventsFromSingleGridMeasures(singleGMs: CalendarEntry[], mode: string) {
      const events: CalendarEvent<GridMeasure>[] = new Array<CalendarEvent>();
      const editAction = <CalendarEventAction>{
        label: '<i class="glyphicon glyphicon-pencil"></i>'
      };
      const viewAction = <CalendarEventAction>{
        label: '<i class="glyphicon glyphicon-eye-open"></i>'
      };
      singleGMs.forEach(singleGM => {
        if (!singleGM.plannedStarttimSinglemeasure || !singleGM.plannedEndtimeSinglemeasure) {
          console.log('No valide date values for ' + singleGM.singleGridMeasureTitle);
          console.log('Planned End Time Gridmeasure ' + singleGM.plannedEndtimeSinglemeasure);
          console.log('Start Time First Sequence: ' + singleGM.plannedStarttimSinglemeasure);
        } else {
          events.push(<CalendarEvent><GridMeasure>{
            id: singleGM.gridMeasureId,
            title: singleGM.singleGridMeasureTitle || 'TITLE NOT DEFINED',
            start: new Date(singleGM.plannedStarttimSinglemeasure),
            end: new Date(singleGM.plannedEndtimeSinglemeasure),
            color: {
              primary: '#ad2121',
              secondary: '#FAE3E3'
            },
            draggable: true,
            actions: [mode === 'edit' ? editAction : viewAction],
            resizable: {
              beforeStart: true,
              afterEnd: true
            },
            meta: singleGM
          });
        }
      });
      return events;
    }
  }

  class MockGridMeasureService extends AbstractMockObservableService {
    getGridMeasures() {
      return this;
    }
    getCalender() {
      return this;
    }
  }

  class MockUserSettingService extends AbstractMockObservableService {
    savedUserSettings: UserSettings;
    getUserSettings(gridId: string) {
      return this;
    }
    setUserSettings(userSettings: UserSettings) {
      this.savedUserSettings = userSettings;
      return this;
    }
  }

  let mockUserSettingService;
  let roleAccessHelper: RoleAccessHelperService;
  let mockGridMeasureService;

  beforeEach(async(() => {
    sessionContext = new SessionContext();
    mockGridMeasureService = new MockGridMeasureService();
    mockUserSettingService = new MockUserSettingService();
    roleAccessHelper = new RoleAccessHelperService();

    sessionContext.setCurrUser(USERS[1]);
    sessionContext.setAllUsers(USERS);

    TestBed.configureTestingModule({
      imports: [
        FormsModule,
        BrowserAnimationsModule,
        CalendarModule.forRoot({
          dateFormatter: {
            provide: CalendarDateFormatter,
            useClass: CustomDateFormatter
          }
        })

      ],
      declarations: [
        CustomCalendarComponent,
        MockComponent({ selector: 'input', inputs: ['options'] }),
        MockComponent({ selector: 'app-grid-measures', inputs: ['gridId', 'withEditButtons'] }),
        MockComponent({ selector: 'app-loading-spinner', inputs: [] }),
        MockComponent({
          selector: 'app-buttons-container',
          inputs: ['activeButtons', 'isValidForm', 'isValidForSave', 'isReadOnlyForm', 'gridMeasureStatusId']
        })
      ],
      providers: [
        MessageServiceCustom,
        ModeValidator,
        { provide: SessionContext, useValue: sessionContext },
        { provide: Router, useValue: routerStub },
        { provide: GridMeasureService, useValue: mockGridMeasureService },
        { provide: RoleAccessHelperService, useValue: roleAccessHelper },
        { provide: UserSettingsService, useValue: mockUserSettingService },
        { provide: CalendarDateFormatter, useClass: CustomDateFormatter }
      ]
    }).compileComponents();
  })
  );

  let eventTitle: CalendarEventTitleFormatter;
  beforeEach(
    inject([CalendarEventTitleFormatter], _eventTitle_ => {
      eventTitle = _eventTitle_;
    })
  );

  beforeEach(fakeAsync(() => {
    fixture = TestBed.createComponent(CustomCalendarComponent);
    tick();
    component = fixture.componentInstance;
    component.currDate = new Date('2017-01-15');
    sessionContext.setCurrUser(USERS[1]);
    sessionContext.setAllUsers(USERS);
    fixture.detectChanges();

    // we need to init the component and the path... because of OnInit
    mockGridMeasureService.content = JSON.parse(JSON.stringify(CALENDARENTRY[0]));
    const roleAcess: RoleAccess = {
      editRoles: [{
        name: 'planned-policies-measureplanner',
        gridMeasureStatusIds: [
          0,
          1
        ]
      }, {
        name: 'planned-policies-superuser',
        gridMeasureStatusIds: [
          0,
          1
        ]
      }, {
        name: 'planned-policies-measureapplicant',
        gridMeasureStatusIds: [
          0,
          1
        ]
      }],
      controls: [{
        gridMeasureStatusId: 0,
        activeButtons: [
          'save',
          'apply',
          'cancel'
        ],
        inactiveFields: [
          'titeldermassnahme'
        ]
      },
      {
        gridMeasureStatusId: 1,
        activeButtons: [
          'save',
          'cancel',
          'forapproval'
        ],
        inactiveFields: [
          'titeldermassnahme'
        ]
      }],
      stornoSection:
      {
        'stornoRoles': [
          'planned-policies-measureapplicant',
          'planned-policies-measureplanner',
          'planned-policies-measureapprover',
          'planned-policies-requester',
          'planned-policies-clearance'
        ]
      },
      duplicateSection:
      {
        'duplicateRoles': [
          'planned-policies-measureapplicant'
        ]
      }

    };
    roleAccessHelper.init(roleAcess);


  }));

  it('should create', () => {
    expect(component).toBeTruthy();
  });

  it('should generate the day view', () => {
    const fixtureDayView: ComponentFixture<CalendarDayViewComponent> = TestBed.createComponent(CalendarDayViewComponent);
    fixtureDayView.componentInstance.viewDate = new Date('2017-01-15');
    fixtureDayView.componentInstance.events = [
      {
        start: new Date('2017-01-15'),
        title: 'Test grid-measure',
        color: {
          primary: '',
          secondary: ''
        }
      }
    ];
    fixtureDayView.componentInstance.ngOnChanges({ viewDate: {}, events: {} });
    expect(fixtureDayView.componentInstance.view.events.length).toBe(1);
    expect(fixtureDayView.componentInstance.view.events[0].event).toBe(
      fixtureDayView.componentInstance.events[0]
    );
    expect(fixtureDayView.componentInstance.hours.length).toBe(24);

  });

  it('should generate the week view', () => {
    const fixtureWeekView: ComponentFixture<CalendarWeekViewComponent> = TestBed.createComponent(CalendarWeekViewComponent);
    fixtureWeekView.componentInstance.viewDate = new Date('2017-01-15');
    fixtureWeekView.componentInstance.events = [
      {
        start: new Date('2017-01-15'),
        title: 'Test grid-measure',
        color: {
          primary: '',
          secondary: ''
        }
      }
    ];
    fixtureWeekView.componentInstance.ngOnChanges({ viewDate: {}, events: {} });
    expect(fixtureWeekView.componentInstance.view.eventRows.length).toBe(1);
    expect(fixtureWeekView.componentInstance.view.eventRows[0].row[0].event).toBe(
      fixtureWeekView.componentInstance.events[0]
    );

  });

  it('should generate the month view', () => {
    const fixtureMonthView: ComponentFixture<CalendarMonthViewComponent> = TestBed.createComponent(CalendarMonthViewComponent);
    fixtureMonthView.componentInstance.viewDate = new Date('2017-01-15');
    fixtureMonthView.componentInstance.events = [
      {
        start: new Date('2017-01-15'),
        end: new Date('2017-01-20'),
        title: 'Test grid-measure',
        color: {
          primary: '',
          secondary: ''
        }
      }
    ];
    fixtureMonthView.componentInstance.ngOnChanges({ viewDate: {}, events: {} });
    expect(fixtureMonthView.componentInstance.events.length).toBe(1);
    expect(fixtureMonthView.componentInstance.events[0]).toBe(
      fixtureMonthView.componentInstance.events[0]
    );

  });

  xit('should navigate to grid-measure-detail for in edit-mode', (() => {
    mockGridMeasureService.content = JSON.parse(JSON.stringify(CALENDARENTRY[0]));
    component.events = new GridmeasureToEventHelper().createEventsFromSingleGridMeasures(calendarEntries, 'edit');
    fixture.detectChanges();
    fixture.whenStable().then(() => {
      fixture.detectChanges();
      console.log('component.events[0] : ' + component.events[0]);
      const calEvent: CalendarEvent<GridMeasure> = component.events[0];
      console.log('calEvent : ' + calEvent);

      component.eventClicked('edit', calEvent);

      expect(routerStub.navigate).toHaveBeenCalledWith(['/gridMeasureDetail/', 1111, 'edit']);
    });
  }));

  xit('should check if there are grid measure for actual day and show them', async(() => {
    component.events.push(<CalendarEvent><GridMeasure>{
      id: 1,
      title: 'TITLE',
      start: new Date('2017-01-12'),
      end: new Date('2017-01-18')
    });
    fixture.detectChanges();
    component.currDate = new Date('2017-01-16');
    spyOn((component as any), 'showGridMeasuresIfThere').and.callThrough();
    (component as any).showGridMeasuresIfThere();
    fixture.whenRenderingDone().then(() => {
      fixture.detectChanges();
      expect((component as any).showGridMeasuresIfThere).toHaveBeenCalled();
      expect(component.activeDayIsOpen).toBeTruthy();
    });

  }));

  xit('should check if there are grid measure for actual day(no event actual) and dont show them', async(() => {
    component.events.push(<CalendarEvent><GridMeasure>{
      id: 1,
      title: 'TITLE',
      start: new Date('2017-01-12'),
      end: new Date('2017-01-18')
    });
    fixture.detectChanges();
    component.currDate = new Date('2017-01-25');
    spyOn((component as any), 'showGridMeasuresIfThere').and.callThrough();
    (component as any).showGridMeasuresIfThere();
    fixture.whenRenderingDone().then(() => {
      fixture.detectChanges();
      expect((component as any).showGridMeasuresIfThere).toHaveBeenCalled();
      expect(component.activeDayIsOpen).toBeFalsy();
    });

  }));

  xit('should leave open the gm dialog in month overview if there are events', async(() => {
    const events: CalendarEvent<GridMeasure>[] = new Array<CalendarEvent>();
    events.push(<CalendarEvent><GridMeasure>{
      id: 1,
      title: 'TITLE',
      start: new Date('2017-01-12'),
      end: new Date('2017-01-18')
    });
    fixture.detectChanges();
    component.activeDayIsOpen = true;
    component.currDate = new Date('2017-01-16');
    const date = new Date('2017-01-16');
    spyOn(component, 'dayClicked').and.callThrough();
    fixture.detectChanges();
    component.dayClicked({ date, events });
    fixture.whenRenderingDone().then(() => {
      fixture.detectChanges();
      expect(component.dayClicked).toHaveBeenCalled();
      expect(component.activeDayIsOpen).toBeFalsy();
    });

  }));

  xit('should close gm dialog if there are no events', async(() => {
    const events: CalendarEvent<GridMeasure>[] = new Array<CalendarEvent>();
    fixture.detectChanges();
    component.activeDayIsOpen = true;
    component.currDate = new Date('2017-01-16');
    const date = new Date('2017-01-16');
    spyOn(component, 'dayClicked').and.callThrough();
    fixture.detectChanges();
    component.dayClicked({ date, events });
    fixture.whenRenderingDone().then(() => {
      fixture.detectChanges();
      expect(component.dayClicked).toHaveBeenCalled();
      expect(component.activeDayIsOpen).toBeFalsy();
    });

  }));

  xit('should open gm dialog if there are events and not even open', async(() => {
    const events: CalendarEvent<GridMeasure>[] = new Array<CalendarEvent>();
    events.push(<CalendarEvent><GridMeasure>{
      id: 1,
      title: 'TITLE',
      start: new Date('2017-01-12'),
      end: new Date('2017-01-18')
    });
    fixture.detectChanges();
    component.activeDayIsOpen = false;
    component.currDate = new Date('2017-01-17');
    const date = new Date('2017-01-17');
    spyOn(component, 'dayClicked').and.callThrough();
    fixture.detectChanges();
    component.dayClicked({ date, events });
    fixture.whenRenderingDone().then(() => {
      fixture.detectChanges();
      expect(component.dayClicked).toHaveBeenCalled();
      expect(component.activeDayIsOpen).toBeTruthy();
    });

  }));

  xit('should check the action of an event and navigate there with edit', async(() => {
    const events: CalendarEvent<GridMeasure>[] = new Array<CalendarEvent>();
    events.push(<CalendarEvent><GridMeasure>{
      id: 1,
      title: 'TITLE',
      start: new Date('2017-01-12'),
      end: new Date('2017-01-18')
    });
    fixture.detectChanges();
    component.activeDayIsOpen = false;
    spyOn(component, 'eventClicked').and.callThrough();
    fixture.detectChanges();
    component.eventClicked(Globals.MODE.EDIT, events[0]);
    fixture.whenRenderingDone().then(() => {
      fixture.detectChanges();
      expect(routerStub.navigate).toHaveBeenCalledWith(['/gridMeasureDetail/', events[0].id, Globals.MODE.EDIT]);
    });

  }));

});