import { ISyncManagerCS } from './types';

import { submitterManagerFactory } from './submitters/submitterManager';

import { IReadinessManager } from '../readiness/types';

import { IStorageSync } from '../storages/types';

import { IPushManager } from './streaming/types';

import { IPollingManager, IPollingManagerCS } from './polling/types';

import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';

import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';

import { isConsentGranted } from '../consent';

import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';

import { ISdkFactoryContextSync } from '../sdkFactory/types';

import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';

import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';

/**

* Online SyncManager factory.

* Can be used for server-side API, and client-side API with or without multiple clients.

*

* @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing

* `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.

* @param pushManagerFactory - optional to build a SyncManager with or without streaming support

*/

export function syncManagerOnlineFactory(

pollingManagerFactory?: (params: ISdkFactoryContextSync) => IPollingManager,

pushManagerFactory?: (params: ISdkFactoryContextSync, pollingManager: IPollingManager) => IPushManager | undefined,

): (params: ISdkFactoryContextSync) => ISyncManagerCS {

/**

* SyncManager factory for modular SDK

*/

return function (params: ISdkFactoryContextSync): ISyncManagerCS {

const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } }, telemetryTracker, storage, readiness } = params;

/** Polling Manager */

const pollingManager = pollingManagerFactory && pollingManagerFactory(params);

/** Push Manager */

const pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?

pushManagerFactory(params, pollingManager) :

undefined;

/** Submitter Manager */

// It is not inyected as push and polling managers, because at the moment it is required

const submitterManager = submitterManagerFactory(params);

/** Sync Manager logic */

function startPolling() {

if (pollingManager!.isRunning()) {

log.info(SYNC_CONTINUE_POLLING);

} else {

log.info(SYNC_START_POLLING);

pollingManager!.start();

telemetryTracker.streamingEvent(SYNC_MODE_UPDATE, POLLING);

}

}

function stopPollingAndSyncAll() {

log.info(SYNC_STOP_POLLING);

// if polling, stop

if (pollingManager!.isRunning()) {

pollingManager!.stop();

telemetryTracker.streamingEvent(SYNC_MODE_UPDATE, STREAMING);

}

// fetch splits and segments. There is no need to catch this promise (it is always resolved)

pollingManager!.syncAll();

}

if (pushManager) {

pushManager.on(PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);

pushManager.on(PUSH_SUBSYSTEM_DOWN, startPolling);

}

let running = false; // flag that indicates whether the syncManager has been started (true) or stopped (false)

let startFirstTime = true; // flag to distinguish calling the `start` method for the first time, to support pausing and resuming the synchronization

return {

// Exposed for fine-grained control of synchronization.

// E.g.: user consent, app state changes (Page hide, Foreground/Background, Online/Offline).

pollingManager,

pushManager,

submitterManager,

/**

* Method used to start the syncManager for the first time, or resume it after being stopped.

*/

start() {

running = true;

// @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved

submitterManager.start(!isConsentGranted(settings));

return Promise.resolve(storage.validateCache ? storage.validateCache() : { initialCacheLoad: true /* Fallback: assume initial load when validateCache doesn't exist */ }).then((cacheMetadata) => {

if (!running) return;

if (startFirstTime) {

// Emits SDK_READY_FROM_CACHE

if (!cacheMetadata.initialCacheLoad) {

readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);

}

}

// start syncing splits and segments

if (pollingManager) {

// If synchronization is disabled pushManager and pollingManager should not start

if (syncEnabled) {

if (pushManager) {

// Doesn't call `syncAll` when the syncManager is resuming

if (startFirstTime) {

pollingManager.syncAll();

}

pushManager.start();

} else {

pollingManager.start();

}

} else {

if (startFirstTime) {

pollingManager.syncAll();

}

}

}

startFirstTime = false;

});

},

/**

* Method used to stop/pause the syncManager.

*/

stop() {

running = false;

// stop syncing

if (pushManager) pushManager.stop();

if (pollingManager && pollingManager.isRunning()) pollingManager.stop();

// stop periodic data recording (events, impressions, telemetry).

submitterManager.stop();

},

isRunning() {

return running;

},

flush() {

return submitterManager.execute(!isConsentGranted(settings));

},

// [Only used for client-side]

// If polling and push managers are defined (standalone mode), they implement the interfaces for client-side

shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync) {

if (!pollingManager) return;

const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).add(matchingKey, readinessManager, storage);

if (syncEnabled && pushManager) pushManager.add(matchingKey, mySegmentsSyncTask);

if (running) {

if (syncEnabled) {

if (pushManager) {

if (pollingManager.isRunning()) {

// if doing polling, we must start the periodic fetch of data

if (usesSegmentsSync(storage)) mySegmentsSyncTask.start();

} else {

// if not polling, we must execute the sync task for the initial fetch

// of segments since `syncAll` was already executed when starting the main client

mySegmentsSyncTask.execute();

}

} else {

if (usesSegmentsSync(storage)) mySegmentsSyncTask.start();

}

} else {

if (!readinessManager.isReady()) mySegmentsSyncTask.execute();

}

}

return {

stop() {

// check in case `client.destroy()` has been invoked more than once for the same client

const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).get(matchingKey);

if (mySegmentsSyncTask) {

// stop syncing

if (pushManager) pushManager.remove(matchingKey);

if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();

(pollingManager as IPollingManagerCS).remove(matchingKey);

}

},

flush() { return Promise.resolve(); }

};

}

};

};

}