import { HighlightMock } from './../../../../../../app2Mocks/app2/pipes/highlightMock';
import { OrderByObjectMock } from './../../../../../../app2Mocks/app2/pipes/orderByObjectMock';
/* Migreringsbeslut: denna test behöver Chrome headless eller PhantomJs + es6-shim för att kunna köras */
/**
 * @ngdoc fbDropPlusSpec
 * @name fasit.tests.#fbFormDropPlusSpec
 * @fbDropPlusSpec
 *
 * @description
 * Test för directivet fbDropPlus
 *
 */

import { FbFormDropPlusComponent } from './fb-form-drop-plus.component';
import { ComponentFixture, TestBed, ComponentFixtureAutoDetect } from '@angular/core/testing';
import { DebugElement, NO_ERRORS_SCHEMA, Component } from '@angular/core';
import {HttpClient} from '@angular/common/http';
import { TranslateModule, TranslateLoader } from '@ngx-translate/core';
import { TranslateHttpLoader } from '@ngx-translate/http-loader';
import { FbCoreModule } from '@fb/core/core.module';
import { FbCommonPipesModule } from '@fb/common';

declare const angular: angular.IAngularStatic;
const DROP_PLUS_VAR: string = 'Hej';

@Component({
  selector: 'fb-test-component-wrapper',
  template: `
    <fb-form-drop-plus
      [model]="dropPlusVar"
      [label]="'Fordon'"
      [placeholder]="'Välj fordon'"
      [key]="'taco'">
    </fb-form-drop-plus>`
})
class TestComponentWrapperComponent {
  dropPlusVar: fb.ChangeTrack<string>;
  constructor() {
      this.dropPlusVar = new fb.ChangeTrack(DROP_PLUS_VAR);
  }
}


let comp: FbFormDropPlusComponent;
let fixture: ComponentFixture<TestComponentWrapperComponent>;
let de: DebugElement;
let el: HTMLElement;
let $scope: ng.IScope;
let dropPlusService: fb.IMockDropPlusService;
let dropPlusListMock: fb.List<fb.DropPlus>;


describe('FbFormDropPlusComponent', description);

function description(): void {
    beforeEach(initAngularJs);
    beforeEach(initAngular);
    beforeEach(init);
    afterEach(() => {
        $scope.$destroy();
    });
    run();
}

function createTranslateLoader(http: HttpClient): TranslateHttpLoader {
    return new TranslateHttpLoader(http, '../app/Languages/', '.json');
}

function initAngularJs(): void {
    angular.mock.module('fasit', 'fbMocks' /*,'configModelMock'*/);
    angular.mock.inject(($rootScope: fb.IRootScope, $injector: fb.IRootScope) => {
        $scope = $rootScope.$new();
        dropPlusService = ($injector as any).get('dropPlusService');
        dropPlusListMock = ($injector as any).get('getDropPlus');
    });
}

function initAngular(): void {
    TestBed.configureTestingModule({
        imports: [
            FbCoreModule,
            FbCommonPipesModule,
            TranslateModule.forRoot({
                loader: {
                    provide: TranslateLoader,
                    useFactory: (createTranslateLoader),
                    deps: [HttpClient]
                }
            })
        ],
        declarations: [
            TestComponentWrapperComponent,
            FbFormDropPlusComponent,
            OrderByObjectMock,
            HighlightMock
        ],
        providers: [
            {
                provide: ComponentFixtureAutoDetect,
                useValue: true
            },
            {
                provide: 'DropPlusService',
                useValue: dropPlusService
            }
        ],
        schemas: [NO_ERRORS_SCHEMA]
    })
    .overrideTemplate(FbFormDropPlusComponent, './fb-form-drop-plus.component.html')
    .compileComponents()
    .then(
        (data) => { console.log(data); }
    ).catch(reason => { throw reason; });
}

function init(): void {
    fixture = TestBed.createComponent(TestComponentWrapperComponent);
    comp = fixture.debugElement.children[0].componentInstance;
    de = fixture.debugElement;
    el = de.nativeElement;
    fixture.detectChanges();
}

function run(): void {
    describe('Jobb mot servicen', () => {
        it('Hämtar rätt', () => {
            $scope.$digest();
            dropPlusService.resolve(fb.RequestType.GET, 'taco', dropPlusListMock);
            $scope.$digest();
            // tslint:disable-next-line:no-string-literal
            const list: fb.List<fb.DropPlus> = comp['list'];
            expect(list.length).toBe(2);
        });

        it('Lägger till rätt', () => {
            const dpService: fb.IMockDropPlusService = fixture.debugElement.injector.get('DropPlusService');
            spyOn(dpService, 'add').and.returnValue({ $promise: { then: () => { return; } } });
            comp.model.value = 'Hej';
            comp.add();
            $scope.$digest();
            expect(dpService.add).toHaveBeenCalled();
            expect((dpService.add as any).calls.argsFor(0)[0].DropPlusTyp.value).toBe('taco');
            expect((dpService.add as any).calls.argsFor(0)[0].Vaerde.value).toBe('Hej');
        });

        it('Tar bort rätt', () => {
            const dpService: fb.IMockDropPlusService = fixture.debugElement.injector.get('DropPlusService');
            const spy: jasmine.Spy = spyOn(dpService, 'remove');
            spy.and.returnValue({ $promise: { then: () => { return; } } });
            $scope.$digest();
            const dp: fb.DropPlus = new fb.DropPlus({
                DropPlusId: 7,
                DropPlusTyp: ''
            });
            comp.delete(dp);
            $scope.$digest();
            expect(spy).toHaveBeenCalledWith(dp);
        });
    });

    describe('Click events', () => {
        beforeEach(() => {
            dropPlusService.resolve(fb.RequestType.GET, 'taco', dropPlusListMock);
            $scope.$digest();
        });

        it('select', () => {

            // tslint:disable-next-line:no-string-literal
            const list: fb.List<fb.DropPlus> = comp['list'];
            const firstElement: fb.DropPlus = list[0];
            spyOn(comp as any, 'filterList'); // Private
            spyOn(comp as any, 'blurList'); // Private

            $scope.$digest();

            expect(comp.model.value).not.toBe(firstElement);
            comp.select(firstElement);
            expect(comp.model.value).toBe(firstElement.Vaerde.value);

            // tslint:disable-next-line:no-string-literal
            expect(comp['filterList']).toHaveBeenCalled();

            // tslint:disable-next-line:no-string-literal
            expect(comp['blurList']).toHaveBeenCalled();
        });

        it('lägg till', () => {
            spyOn(comp as any, 'filterList'); // private
            spyOn(comp as any, 'blurList'); // private

            comp.model = new fb.ChangeTrack('heja');
            comp.model.root = {
                applyValue: () => { return; }
            } as any;
            comp.add();

            dropPlusService.resolve(fb.RequestType.ADD, '', dropPlusListMock);
            $scope.$digest();

            // tslint:disable-next-line:no-string-literal
            expect(comp['filterList']).toHaveBeenCalled();

            // tslint:disable-next-line:no-string-literal
            expect(comp['blurList']).toHaveBeenCalled();
        });
    });
}