// import { Component, OnInit, OnDestroy } from '@angular/core';
// import { Router, ActivatedRoute } from '@angular/router';
import { Observable } from 'rxjs/Rx';
// import { DebugElement } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { TestBed, async, fakeAsync, ComponentFixture } from '@angular/core/testing';
import { RouterTestingModule } from '@angular/router/testing';
import { SharedService } from '../../../shared/shared.service';
import { CartServiceStub } from '../../../services/cart.service.stub';
import { UserService } from '../../../services/user.service';
import { CartService } from '../../../services/cart.service';
import { CustomerService } from '../../../services/customer.service';
import { LookupService } from '../../../services/lookup.service';
import { CatalogService } from '../../../services/catalog.service';
import { RegularComponent } from './regular.component';
import {
    deletePackageResponse,
    deleteRatePlanResponse,
    packageData, cartDataResponse, packagesData
} from '../../../shared/mock-data';
import { IPackage } from '../../../shared/modal/common';
import * as Constants from '../../../shared/constants';
import { packageMockData, userMockData, cartData } from '../../../shared/mock-data';
import { PopupComponent } from '../../../shared/popup/popup.component';
import { TradeinService } from '../../../services/tradein.service';
import { LoggingService } from '../../../services/logging.service';
import CartUtils from '../../../shared/cart.utils';
import { CheckoutService } from '../../../services/checkout.service';
import { HttpClient, HttpHandler } from '@angular/common/http';

// import {Conne}
describe('Regular Component', () => {
    let regularObject: RegularComponent;
    let fixture: ComponentFixture<RegularComponent>;
    let dataStub: CartServiceStub;
    let spyNavigate: any;
    beforeEach(async(() => {
        TestBed.configureTestingModule({
            providers: [
                SharedService,
                LookupService,
                UserService,
                CartService,
                CustomerService,
                CheckoutService,
                CatalogService,
                TradeinService,
                LoggingService,
                HttpClient, HttpHandler
            ],
            imports: [
                FormsModule,
                RouterTestingModule
            ],
            declarations: [RegularComponent, PopupComponent]
        });
        fixture = TestBed.createComponent(RegularComponent);
        regularObject = fixture.componentInstance;
        dataStub = fixture.debugElement.injector.get(CartService);
        TestBed.compileComponents();
        TestBed.get(SharedService);
        TestBed.get(CartService);
        TestBed.get(UserService);
        spyNavigate = spyOn(regularObject.router, 'navigate');
        regularObject.cartService.cart = cartData;
        regularObject.cart = cartData;
        regularObject['user'] = userMockData;
    }));

    // tests here
    it('should be created', () => {
        expect(regularObject).toBeTruthy();
    });
    it('All methods are defined', async(() => {
        expect(regularObject.deleteAccessory).toBeDefined();
    }));
    it('should resolve delete package test data', fakeAsync(() => {
        const spy = spyOn(dataStub, 'deletePackageDetails').and.returnValue(
            Observable.of(deletePackageResponse)
        );
        regularObject.deletePackage('voice', 48919251, 0);
        fixture.detectChanges();
        expect(regularObject.karmaTestResult).toEqual(deletePackageResponse);
    }));
    it('should resolve delete rateplan test data', fakeAsync(() => {
        let deleteRatePlanStub = fixture.debugElement.injector.get(CartService);
        regularObject.storeId = Constants.STORE_ID_CD;

        const spy = spyOn(deleteRatePlanStub, 'deleteRateplan').and.returnValue(
            Observable.of(deleteRatePlanResponse)
        );
        regularObject.deleteRateplan(123456);
        fixture.detectChanges();
        expect(regularObject.karmaTestResult).toEqual(deleteRatePlanResponse);
    }));
    it('Package is created correctly', fakeAsync(() => {
        spyOn(regularObject, 'createAPackage');
        regularObject.addAPackage('voice');
        expect(regularObject.createAPackage).toHaveBeenCalledWith(12345, 'voice');
    }));
    it('should resolve delete device test data', fakeAsync(() => {
        regularObject.storeId = Constants.STORE_ID_CD;

        const spy = spyOn(dataStub, 'createCartDetails').and.returnValue(
            Observable.of(packageData)
        );
        regularObject.deleteDevice(48919643, 0, 1920141);
        fixture.detectChanges();
        expect(regularObject.karmaTestResult).toEqual(packageData);
    }));
    it('should resolve copy cart test data', fakeAsync(() => {
        const spy = spyOn(dataStub, 'copyPackage').and.returnValue(
            Observable.of(packageData)
        );
        regularObject.copyPackage();
        fixture.detectChanges();
        expect(regularObject.karmaTestResult).toEqual(packageData);
    }));
    it('should resolve delete feature test data', fakeAsync(() => {
        regularObject.storeId = Constants.STORE_ID_CD;

        const spy = spyOn(dataStub, 'deleteFeature').and.returnValue(
            Observable.of(packageData)
        );
        regularObject.deleteFeature(1234);
        fixture.detectChanges();
        expect(regularObject.karmaTestResult).toEqual(packageData);
    }));
    it('should resolve delete accessory test data', fakeAsync(() => {
        regularObject.storeId = Constants.STORE_ID_CD;

        const spy = spyOn(dataStub, 'deleteAccessory').and.returnValue(
            Observable.of(packageData)
        );
        regularObject.deleteAccessory(123);
        fixture.detectChanges();
        expect(regularObject.karmaTestResult).toEqual(packageData);
    }));
    it('should resolve checkout test data', fakeAsync(() => {
        regularObject.sharedService.tradeInValidate = true;
        const spy = spyOn(dataStub, 'validateCart').and.returnValue(
            Observable.of(cartDataResponse)
        );
        regularObject.checkoutNow();
        fixture.detectChanges();
        expect(regularObject.karmaTestResult).toEqual(cartDataResponse);
    }));
    it('should resolve package creation test data', fakeAsync(() => {
        regularObject['appDefault'] = {
            creditType: 'CC',
            loanCrp: 1,
            leaseCrp: 101,
            maxVoiceLines: 1,
            maxDataLines: 1
        };
        const spy = spyOn(regularObject.sharedService, 'addLogging').and.returnValue(
            Observable.of(packagesData)
        );
        regularObject.createAPackage(20045, 'accessory');
        fixture.detectChanges();
        expect(regularObject.sharedService.showSpinner).toBeTruthy();
    }));
    it('should resolve get cart summary test data', fakeAsync(() => {
        const spy = spyOn(regularObject.sharedService, 'showSpinner').and.returnValue(
            Observable.of(cartData)
        );
        regularObject.updateCartSummary(20045);
        fixture.detectChanges();
        expect(regularObject.sharedService.showSpinner).toBeTruthy();
    }));
    it('should resolve Sync cart  test data', fakeAsync(() => {
        const spy = spyOn(dataStub, 'getCartSummary').and.returnValue(
            Observable.of(cartDataResponse)
        );
        regularObject.syncCartUpdates(20045);
        fixture.detectChanges();
        expect(regularObject.karmaTestResult).toEqual(cartDataResponse);
    }));
    /*it('setting active package is working fine', fakeAsync(() => {
        regularObject.activePackage(454564, 48489);
        expect(regularObject.cart.activePackageId).toEqual(454564);
        expect(regularObject.cart.activeLineId).toEqual(48489);
    }));*/
    it('determining active package is working fine', fakeAsync(() => {
        spyOn(regularObject.cartService, 'setCart')
        let cartObject = JSON.parse(JSON.stringify(cartData));
        cartObject.activePackageId = null;
        regularObject.cartService.setCart(cartObject);
        regularObject.activePackage(454564, 48489);
        expect(regularObject.cartService.setCart).toHaveBeenCalledWith(regularObject['cart']);
    }));

    it('should return matching package', async(() => {
        // expect(regularObject.getPackages('accessory')).toEqual([regularObject.cart.packages[0]]);
        const packages = cartData.packages;
        expect(regularObject.getPackages('accessory')[0]).toEqual(packages[1]);

    }));
    it('checking package validity is working fine', fakeAsync(() => {
        const packagee: IPackage = packageMockData[0];
        const packageValidityStatus = regularObject.isValidPackage(packagee);
        expect(packageValidityStatus).toBeTruthy();
    }));
    it('getDisplayFinanceType is working fine', fakeAsync(() => {
        const status = regularObject.getDisplayFinanceType('LOAN');
        expect(status).toEqual('-EIP');
    }));
    it('line name is retrieved correctly', async(() => {
        const pckge = regularObject.getLineName(regularObject.cart.packages[0]);
        expect(pckge['type']).toEqual('Accessory');
    }));
    it('fullcart navigation is working correctly', async(() => {
        regularObject.showShoppingCart();
        expect(spyNavigate).toHaveBeenCalledWith(['/home/fullcart']);
    }));
    it('should resolve convert full price test data', fakeAsync(() => {
        const spy = spyOn(dataStub, 'convertFullPrice').and.returnValue(
            Observable.of(cartData)
        );
        regularObject.convertFullPrice(1920141);
        fixture.detectChanges();
        expect(regularObject.karmaTestResult).toEqual(cartData);
    }));
});