import { IBaseAction, ICustomAction, TrackActionOption, TrackEntityType } from '@medici/types';
import type { SDKInitConfig, PlatformType, SDKConfigType } from './sdk';
import type { IHistory } from './history';
import { collect } from './collector';
// import cloneDeep from 'lodash-es/cloneDeep';
import { cloneDeep } from '@medici/utils';

import { SDK } from './sdk';

export class BaseTrack implements IBaseAction, ICustomAction {
    protected _platform: PlatformType;
    protected _config: SDKInitConfig;
    protected _history: IHistory;
    protected _endPoint: string;
    protected _appId: string;
    private _timeOut: ReturnType<typeof setTimeout>;

    constructor(params: SDKConfigType) {
        this._config = Object.assign({ user: '', version: '' }, params.config);
        this._platform = params.platform;
        this._appId = params.appId;
        this._endPoint = params.endPoint;
    }
    get _stopTrack() {
        return SDK._stopTrack;
    }

    get trackUrl() {
        return this._endPoint + '/tracking/log/save';
    }

    get trackPageViewUrl() {
        return this._endPoint + '/tracking/log/save';
    }

    private toTrackEntity(params: TrackEntityType): TrackEntityType {
        const entity = {
            appId: this._appId,
            module: params.module,
            type: params.type,
            url: params.url || this._history.playload.url,
            eventType: params.eventType,
            referrer: params.referrer || this._history.currentRef,
            requestData: params.requestData,
        };
        if (params.language) {
            entity['language'] = params.language;
        }
        if (params.networkType) {
            entity['networkType'] = params.networkType;
        }
        if (params.userId) {
            entity['userId'] = params.userId;
        }
        return entity;
    }

    public trackView(url: string, referrer: string, uuid: string): Promise<XMLHttpRequestResponseType> {
        console.log('BaseTrack-trackView', url, referrer, uuid);
        if (!this._stopTrack) {
            this._history.playload.url = url;
            const historyPlayload = cloneDeep(this._history.playload);
            // const payload = Object.assign(historyPlayload, {
            //     ...this._config,
            //     referrer: this._history.currentRef,
            //     url: url,
            // });
            const payload: TrackEntityType = {
                module: 'pageview',
                url: url,
                type: 'pageview',
                eventType: 'pageview',
                language: historyPlayload.language,
                userId: this._config.user,
            };
            console.log('send-playload', payload);
            return collect(this.trackPageViewUrl, 'pageview', this.toTrackEntity(payload));
        }
    }

    public trackEvent(event_name: string, event_data: string, url?: string, uuid?: string): Promise<XMLHttpRequestResponseType> {
        if (!this._stopTrack) {
            console.log('BaseTrack-TrackEvent', event_name, event_data, url, uuid);
            this._history.playload.url = url;
            const historyPlayload = cloneDeep(this._history.playload);
            // const payload = Object.assign(historyPlayload, {
            //     referrer: this._history.currentRef,
            //     event_name: event_name,
            //     url: url,
            //     event_data: event_data,
            //     ...this._config,
            // });

            const payload: TrackEntityType = {
                module: event_name,
                url: url,
                type: 'event',
                eventType: event_data,
                language: historyPlayload.language,
                userId: this._config.user,
            };
            console.log('send-playload', payload);
            return collect(this.trackPageViewUrl, 'event', this.toTrackEntity(payload));
        }
    }

    public track(trackActionName: string, trackActionOption?: TrackActionOption): Promise<XMLHttpRequestResponseType> {
        if (!this._stopTrack) {
            const historyPlayload = cloneDeep(this._history.playload);
            const trackObj = cloneDeep(trackActionOption);
            delete trackObj.eventType;
            delete trackObj.maxWaitTime;

            const payload: TrackEntityType = {
                module: trackActionName,
                type: 'track',
                eventType: trackActionOption.eventType,
                requestData: Object.assign({ screen: historyPlayload.screen }, trackObj, this._config),
                language: historyPlayload.language,
                networkType: trackActionOption.networkType,
                userId: this._config.user,
            };
            // this.toTrackEntity(payload);
            return collect(this.trackUrl, 'track', this.toTrackEntity(payload));
        }
    }

    public startTrack(trackActionName: string, trackActionOption?: TrackActionOption): Promise<XMLHttpRequestResponseType> {
        if (!this._stopTrack) {
            const historyPlayload = cloneDeep(this._history.playload);
            const trackObj = cloneDeep(trackActionOption);
            delete trackObj.eventType;
            delete trackObj.maxWaitTime;

            const payload: TrackEntityType = {
                module: trackActionName,
                type: 'start_track',
                eventType: trackActionOption.eventType,
                requestData: Object.assign({}, trackObj, this._config),
                language: historyPlayload.language,
                networkType: trackActionOption.networkType,
                userId: this._config.user,
            };
            if (trackActionOption.maxWaitTime) {
                this._timeOut = setTimeout(() => {
                    this.endTrack(trackActionName, trackActionOption);
                }, trackActionOption.maxWaitTime);
            }
            return collect(this.trackUrl, 'period_track', this.toTrackEntity(payload));
        }
    }

    public endTrack(trackActionName: string, trackActionOption?: TrackActionOption): Promise<XMLHttpRequestResponseType> {
        this._timeOut && clearTimeout(this._timeOut);
        if (!this._stopTrack) {
            const historyPlayload = cloneDeep(this._history.playload);
            const trackObj = cloneDeep(trackActionOption);
            delete trackObj.eventType;
            delete trackObj.maxWaitTime;

            const payload: TrackEntityType = {
                module: trackActionName,
                type: 'end_track',
                eventType: trackActionOption.eventType,
                requestData: Object.assign({}, trackObj, this._config),
                language: historyPlayload.language,
                networkType: trackActionOption.networkType,
                userId: this._config.user,
            };
            return collect(this.trackUrl, 'period_track', this.toTrackEntity(payload));
        }
    }
}