import {
    Component,
    OnInit,
} from '@angular/core';

import {
    ApiKeyHeaderGenerationService,
    AutoNewLineService,
    BrowserDetectorService,
    CookieStorageService,
    CurrentEnvironmentService,
    FormPostService,
    KiteBasketService,
    KiteCheckoutService,
    LocationService,
    MaxTextLengthService,
    PIGService,
    QueryStringService,
    ReplacePropsFromQueryStringService,
    SegmentTrackingService,
    UniversalAnalyticsTrackingService,
} from './../../../../src/helpers/services/index';

import {
    KiteCatalogService,
} from './../../../../src/helpers/services/kite-catalog/kite-catalog.service';

import {
    BrandSettingsInterface,
    PIG_FILL_MODES,
    PIGImageMetaInterface,
    PIGLayerImageInterface,
    PIGResponseInterface,
} from './../../../../src/models/index';

declare const analytics;

export {
    analytics,
};

@Component({
    providers: [
        {
            provide: 'brandSettings',
            useValue: {
                publishableKey:
                    'pk_live_605f5643f65599624ee886c0ee39474812537df9',
                testPublishableKey:
                    'pk_test_5c0f2c5bd8e176e44bd4fa65b8c2cc7abea07842',
                universalAnalyticsToken: 'UA-115797413-1',
            } as BrandSettingsInterface,
        },
        {
            provide: 'segmentAnalytics',
            useValue: analytics,
        },
        ApiKeyHeaderGenerationService,
        AutoNewLineService,
        CurrentEnvironmentService,
        FormPostService,
        KiteBasketService,
        KiteCheckoutService,
        KiteCatalogService,
        LocationService,
        MaxTextLengthService,
        PIGService,
        SegmentTrackingService,
        QueryStringService,
        ReplacePropsFromQueryStringService,
        UniversalAnalyticsTrackingService,
        BrowserDetectorService,
        CookieStorageService,
    ],
    selector: 'helper-services-component',
    templateUrl: './helper-services.component.template.pug',
})
export class HelperServicesComponent implements OnInit {
    public pigProgress = 0;
    public pigResponse: PIGResponseInterface;
    public renderedImageUrl: string;
    public pigLayerImageInterface: PIGLayerImageInterface;
    public pigImageMeta: PIGImageMetaInterface[][];
    public browserName: string;
    public browserVersion: string;
    public authApiKeyHeader: string;
    public cookieValue: string;

    constructor(
        private _pigService: PIGService,
        private _segmentTrackingService: SegmentTrackingService,
        private _universalAnalyticsTrackingService:
            UniversalAnalyticsTrackingService,
        private _browserDetectorService: BrowserDetectorService,
        private _kiteCheckoutService: KiteCheckoutService,
        private _apiKeyHeaderGenerationService: ApiKeyHeaderGenerationService,
        private _cookieStorageService: CookieStorageService,
        private _kiteBasketService: KiteBasketService,
        private _locationService: LocationService,
        private _formPostService: FormPostService,
        private _queryStringService: QueryStringService,
        private _replacePropsFromQueryStringService:
            ReplacePropsFromQueryStringService,
        private _maxTextLengthService: MaxTextLengthService,
        private _kiteCatalogService: KiteCatalogService,
    ) {}

    public ngOnInit() {
        this.setupPIGData();
    }

    public setupPIGData() {
        this.renderedImageUrl = this._pigService.getRenderedImage({
            backgroundColor: '0B6623',
            fillMode: PIG_FILL_MODES.FIT,
            filters: 'invert',
            format: 'jpg',
            imageUrl: 'https://s3.amazonaws.com/kiteshopify/' +
                'e2f57aa4-10a4-47e4-a87a-99bf8c4730dc_preview.jpeg',
            mirror: true,
            padding: 10,
            rotateDegrees: 10,
            scale: 1.5,
            size: {
                height: 200,
                width: 200,
            },
            templateId: 'aa_mens_tshirt',
            translateX: 20,
            translateY: 20,
            variantName: 'black',
        });
    }

    public uploadToPIG(files: FileList) {
        this._pigService.upload$(files.item(0)).subscribe((resp) => {
            if (typeof resp === 'number') {
                this.pigProgress = resp;
            } else {
                this.pigResponse = resp;
            }
        });
    }

    public getPIGLayerComponents() {
        this._pigService.getLayerComponents$(
            'aa_mens_tshirt',
            'black',
        ).subscribe((resp) => {
            this.pigLayerImageInterface = resp;
        });
    }

    public getImageMeta() {
        this._pigService.getUploadedImageMeta$(
            'https://s3.amazonaws.com/kiteshopify/'
                + 'cada5b6b-d52d-4142-a4e8-18ad4483af41.jpeg',
        ).subscribe(
            (resp: PIGImageMetaInterface) => {
                // tslint:disable-next-line
                console.log('PIG Service getUploadedImageMeta$ called');
                this.pigImageMeta = Object.entries(resp);
            },
        );
    }

    public sendUniversalAnalyticsEvent() {
        this._universalAnalyticsTrackingService.sendEvent({
            name: 'testEvent',
            properties: {
                testEventProp: 'propValue',
            },
        });
    }

    public sendSegmentTrackEvent() {
        this._segmentTrackingService.sendEvent({
            callback: () => {
                // tslint:disable-next-line
                console.log('segment test event');
            },
            name: 'testEvent',
            options: {
               testEventOption: 'optionValue',
            },
            properties: {
                testEventProp: 'propValue',
            },
        });
    }

    public sendSegmentPageEvent(category?: string) {
        this._segmentTrackingService.sendPage({
            callback: () => {
                // tslint:disable-next-line
                console.log('segment test page');
            },
            category,
            name: 'testPage',
            options: {
               testPageOption: 'optionValue',
            },
            properties: {
                testPageProp: 'propValue',
            },
        });
    }

    public detectBrowser() {
        const browserDetails = this._browserDetectorService.getBrowserDetails();

        this.browserName = browserDetails.name;
        this.browserVersion = browserDetails.version;
    }

    public goToCheckout() {
        this._kiteCheckoutService.checkout.basket.addItem({
            asset: this._pigService.getRenderedImage({
                imageUrl: 'https://s3.amazonaws.com/kiteshopify/' +
                    'e2f57aa4-10a4-47e4-a87a-99bf8c4730dc_preview.jpeg',
                mirror: false,
                renderPrintImage: true,
                rotateDegrees: 90,
                scale: 1.5,
                templateId: 'canvasframed_12x12',
                translateX: 5,
                translateY: 10,
                variantName: 'cover',
            }),
            templateId: 'canvasframed_12x12',
        });
        this._kiteCheckoutService.checkout.startCheckoutJourney({
            partnerName: 'canon',
            style: {
                logo: 'https://checkout.kite.ly/static/images/canon_logo.png',
                primaryColor: '#c0921b',
            },
        });
    }

    public getApiKeyHeader() {
        this.authApiKeyHeader =
            this._apiKeyHeaderGenerationService
            .getProductRequestHeaders().get('Authorization');
    }

    public setSessionCookie() {
        this._cookieStorageService.set(
            'foo',
            'bar',
            undefined,
        );
    }

    public setPersistentCookie() {
        const expiry = new Date(Date.now() + 1800000);

        this._cookieStorageService.set(
            'lorem',
            'ipsum',
            expiry,
        );
    }

    public getCookie() {
        const cookie = this._cookieStorageService.get('foo');

        if (cookie) {
            this.cookieValue = `Cookie value : ${cookie}`;
        } else {
            this.cookieValue = `Cookie 'foo' could not be found`;
        }
    }

    public getBasket() {
        this._kiteBasketService.getBasket$().subscribe((resp) => {
            // tslint:disable-next-line
            console.log('Got basket', resp);
        });
    }

    public setBasket() {
        this._kiteBasketService.setBasket$({
            collectorImages: [],
            lineItems: [{
                id: '1',
                images: [{
                    filters: '',
                    mirror: false,
                    rotate_degrees: 0,
                    borderWidth: 0,
                    borderUnit: null,
                    scale: 1,
                    tx: 0,
                    ty: 0,
                    url_full: 'https://s3.amazonaws.com/kiteshopify/' +
                        'e2f57aa4-10a4-47e4-a87a-99bf8c4730dc_preview.jpeg',
                    url_preview: 'https://s3.amazonaws.com/kiteshopify/' +
                    'e2f57aa4-10a4-47e4-a87a-99bf8c4730dc_preview.jpeg',
                }],
                templateId: 'a3_poster',
            }],
        }).subscribe(() => {
            // tslint:disable-next-line
            console.log('added to basket');
        });
    }

    public clearBasket() {
        this._kiteBasketService.clearBasket$().subscribe(() => {
            // tslint:disable-next-line
            console.log('basket cleared');
        });
    }

    public getDefaultCurrencyCode() {
        this._locationService.getDefaultCurrencyCode(
            'http://checkout.kite.ly/user/country/',
        ).subscribe((defaultCurrencyCode) => {
            // tslint:disable-next-line
            console.log('default currency code is', defaultCurrencyCode);
        });
    }

    public getDefaultLanguage() {
        this._locationService.getDefaultLanguage()
        .subscribe((defaultLanguage) => {
            // tslint:disable-next-line
            console.log('default language is', defaultLanguage);
        });
    }

    public getMeasurementSystem() {
        this._locationService.getMeasurementSystem()
        .subscribe((defaultMeasurementSystem) => {
            // tslint:disable-next-line
            console.log(
                'default measurement system is',
                defaultMeasurementSystem,
            );
        });
    }

    public formPost() {
        this._formPostService.formPost('http://google.com', '{ "test": 123 }');
    }

    public getQueryString() {
        // tslint:disable-next-line
        console.log(this._queryStringService.getQueryStringKey('test'));
    }

    public clearQueryStrings() {
        this._queryStringService.clearQueryStrings();
    }

    public convertPropertyNameToQueryStringKey() {
        // tslint:disable-next-line
        console.log(
            this._queryStringService
                .convertPropertyNameToQueryStringKey('testPropertyName'),
        );
    }

    public replacePropsWithMatchingQueryStringProps() {
        const testObj = {
            innerObj: {
                  innerProp: 'innerPropVal',
            },
            testProp: 'testPropVal',
        };
        const result = this._replacePropsFromQueryStringService
            .replacePropsWithMatchingQueryStringProps(
                testObj,
            );
        // tslint:disable-next-line
        console.log('Converted object', result);
    }

    public getMaxTextLength() {
        const maxTextLength = this._maxTextLengthService.getMaximumTextLength(
            '12px',
            'Arial',
            19,
        );
        // tslint:disable-next-line
        console.log('Max text length is', maxTextLength);
    }

    public getSlugForTemplate() {
        this._kiteCatalogService.getSlugForTemplate$('mens_tshirt_uk')
            .subscribe(

                // tslint:disable-next-line
                (resp) => console.log(resp),
            );
    }

    public getContentForSlug() {
        this._kiteCatalogService.getContentForSlug$('softstyle-tshirt')
            .subscribe(
                // tslint:disable-next-line
                (resp) => console.log(resp),
            );
    }
}