// 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 { ExchangeComponent } from './exchange.component';
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 { IPackage } from '../../../shared/modal/common';
import { cartDataResponse, packagesData, packageData } from '../../../shared/spec.constants';
import * as Constants from '../../../shared/constants';
import { packageMockData, cartData, validateCartResponse, financeOrderCalculateResponse } from '../../../shared/mock-data';
import { TradeinService } from '../../../services/tradein.service';
import { LoggingService } from '../../../services/logging.service';
import { CheckoutService } from '../../../services/checkout.service';
import { HttpClient, HttpHandler } from '@angular/common/http';
describe('Exchange Component', () => {
    let exchangeObject: ExchangeComponent;
    let fixture: ComponentFixture<ExchangeComponent>;
    let dataStub: CartServiceStub;
    let spyNavigate: any;
    beforeEach((() => {
        TestBed.configureTestingModule({
            providers: [
                SharedService,
                LookupService,
                UserService,
                CartService,
                CustomerService,
                CheckoutService,
                CatalogService,
                TradeinService,
                LoggingService,
                HttpClient, HttpHandler
            ],
            imports: [
                FormsModule,
                RouterTestingModule
            ],
            declarations: [ExchangeComponent]
        });
        fixture = TestBed.createComponent(ExchangeComponent);
        exchangeObject = fixture.componentInstance;
        dataStub = fixture.debugElement.injector.get(CartService);
        TestBed.compileComponents();
        TestBed.get(SharedService);
        let cartService = TestBed.get(CartService);
        TestBed.get(UserService);
        spyNavigate = spyOn(exchangeObject.router, 'navigate');
        exchangeObject['cart'] = cartData;
    }));

    // tests here
    it('should be created', () => {
        expect(exchangeObject).toBeTruthy();
    });
    it('All methods are defined', async(() => {
        expect(exchangeObject.isActivePackage).toBeDefined();
        expect(exchangeObject.activePackage).toBeDefined();
        expect(exchangeObject.isValidPackage).toBeDefined();
        expect(exchangeObject.getReturnPackages).toBeDefined();
        expect(exchangeObject.getPackages).toBeDefined();
        expect(exchangeObject.checkoutNow).toBeDefined();
    }));
    it('determining active package is working fine', fakeAsync(() => {
        spyOn(exchangeObject.cartService, 'setCart')
        expect(exchangeObject.isActivePackage(1234, 1234)).toEqual(true);
    }));
    /*   it('setting active package is working fine', fakeAsync(() => {
          exchangeObject.activePackage(454564, 48489);
          expect(exchangeObject.cart.activePackageId).toEqual(454564);
          expect(exchangeObject.cart.activeLineId).toEqual(48489);
      })); */
    it('checking package validity is working fine', fakeAsync(() => {
        const packagee: IPackage = packageMockData[0];
        const packageValidityStatus = exchangeObject.isValidPackage(packagee);
        expect(packageValidityStatus).toBeTruthy();
    }));
    /*   it('checking if method return active package', fakeAsync(() => {
          exchangeObject.activePackage(1234, 1234);
          exchangeObject['returnCart'] = exchangeObject['cart'];
          expect(exchangeObject.returnCart.activePackageId).toEqual(1234);
          expect(exchangeObject.returnCart.activeLineId).toEqual(1234);
      })); */

    it('should getpackages matching package', async(() => {
        exchangeObject.cart.packages = packagesData;
        expect(exchangeObject.getPackages('data')).toEqual([exchangeObject.cart.packages[0]]);
    }));
    // it('should return matching package', async(() => {
    //     exchangeObject.returnCart = cartData;
    //     expect(exchangeObject.getReturnPackages('voice')).toEqual(exchangeObject.cart.packages);
    // }));
    it('should resolve checkout test data', fakeAsync(() => {
        const spy = spyOn(dataStub, 'validateCart').and.returnValue(
            Observable.of(financeOrderCalculateResponse)
        );
        const spy_1 = spyOn(dataStub, 'calculate').and.returnValue(
            Observable.of(financeOrderCalculateResponse)
        );
        exchangeObject.checkoutNow();
        fixture.detectChanges();
        expect(exchangeObject.karmaTestResult).toEqual(financeOrderCalculateResponse);
    }));
    it('should resolve Sync cart  test data', fakeAsync(() => {
        const spy = spyOn(dataStub, 'getCartSummary').and.returnValue(
            Observable.of(cartDataResponse)
        );
        exchangeObject.syncCartUpdates(20045);
        fixture.detectChanges();
        expect(exchangeObject.karmaTestResult).toEqual(cartDataResponse);
    }));
    it('Navigates to shopping cart', fakeAsync(() => {
        exchangeObject.showShoppingCart();
        expect(spyNavigate).toHaveBeenCalledWith(['/home/fullcart']);
    }));
    it('activeReturnPackage functionality is working fine', fakeAsync(() => {
        exchangeObject.returnCart = cartData;
        exchangeObject.activeReturnPackage(12345, 12345);
        expect(exchangeObject.returnCart.activePackageId).toEqual(12345);
        expect(exchangeObject.returnCart.activeLineId).toEqual(12345);
    }));
    it('isReturnActivePackage functionality is working fine', fakeAsync(() => {
        exchangeObject.returnCart = cartData;
        const status = exchangeObject.isReturnActivePackage(1234, 1234);
        expect(status).toBeTruthy();
    }));
    it('getDisplayFinanceType is working fine', fakeAsync(() => {
        const status = exchangeObject.getDisplayFinanceType('LOAN');
        expect(status).toEqual('-EIP');
    }));
    it('should resolve get cart summary test data', fakeAsync(() => {
        const spy = spyOn(dataStub, 'getCartSummary').and.returnValue(
            Observable.of(cartDataResponse)
        );
        exchangeObject.updateCartSummary(20045);
        fixture.detectChanges();
        expect(exchangeObject.karmaTestResult).toEqual(cartDataResponse);
    }));
    it('should resolve delete accessory test data', fakeAsync(() => {
        exchangeObject.storeId = Constants.STORE_ID_CD;
        const spy = spyOn(dataStub, 'deleteAccessory').and.returnValue(
            Observable.of(packageData)
        );
        exchangeObject.deleteAccessory(123, 12345, 1234);
        fixture.detectChanges();
        expect(exchangeObject.karmaTestResult).toEqual(packageData);
    }));
    it('should resolve delete device test data', fakeAsync(() => {
        exchangeObject.storeId = Constants.STORE_ID_CD;
        const spy = spyOn(dataStub, 'deleteDevice').and.returnValue(
            Observable.of(packageData)
        );
        exchangeObject.deleteDevice(48919643, 0, 1920141);
        fixture.detectChanges();
        expect(exchangeObject.karmaTestResult).toEqual(packageData);
    }));
    it('should resolve convert full price test data', fakeAsync(() => {
        const spy = spyOn(dataStub, 'convertFullPrice').and.returnValue(
            Observable.of(cartData)
        );
        exchangeObject.convertFullPrice(1920141);
        fixture.detectChanges();
        expect(exchangeObject.karmaTestResult).toEqual(cartData);
    }));
});