/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {merge, empty, of, from} from 'rxjs';
import {mapTo, filter, tap, ignoreElements, exhaustMap, switchMap, map, pluck, withLatestFrom, take, catchError, zip} from 'rxjs/operators';
import uniq from 'lodash/uniq';
import {uniqueName} from 'app/utils/uniqueName';
import {defaultNames} from '../defaultNames';

import {
    cachesActionTypes,
    clustersActionTypes,
    igfssActionTypes,
    modelsActionTypes,
    shortCachesActionTypes,
    shortClustersActionTypes,
    shortIGFSsActionTypes,
    shortModelsActionTypes
} from './reducer';

import {
    ADVANCED_SAVE_CACHE,
    ADVANCED_SAVE_CLUSTER,
    ADVANCED_SAVE_COMPLETE_CONFIGURATION,
    ADVANCED_SAVE_IGFS,
    ADVANCED_SAVE_MODEL,
    BASIC_SAVE,
    BASIC_SAVE_AND_DOWNLOAD,
    BASIC_SAVE_OK,
    COMPLETE_CONFIGURATION,
    CONFIRM_CLUSTERS_REMOVAL,
    CONFIRM_CLUSTERS_REMOVAL_OK,
    REMOVE_CLUSTER_ITEMS,
    REMOVE_CLUSTER_ITEMS_CONFIRMED
} from './actionTypes';

import {
    advancedSaveCompleteConfiguration,
    basicSaveErr,
    basicSaveOK,
    completeConfiguration,
    confirmClustersRemovalOK,
    removeClusterItemsConfirmed
} from './actionCreators';

import ConfigureState from '../services/ConfigureState';
import ConfigurationDownload from '../services/ConfigurationDownload';
import ConfigSelectors from './selectors';
import Clusters from '../services/Clusters';
import Caches from '../services/Caches';
import Models from '../services/Models';
import IGFSs from '../services/IGFSs';
import {Confirm} from 'app/services/Confirm.service';

export const ofType = (type) => (s) => s.pipe(filter((a) => a.type === type));

export default class ConfigEffects {
    static $inject = [
        'ConfigureState',
        'Caches',
        'IGFSs',
        'Models',
        'ConfigSelectors',
        'Clusters',
        '$state',
        'IgniteMessages',
        'IgniteConfirm',
        'Confirm',
        'ConfigurationDownload'
    ];

    /**
     * @param {ConfigureState} ConfigureState
     * @param {Caches} Caches
     * @param {IGFSs} IGFSs
     * @param {Models} Models
     * @param {ConfigSelectors} ConfigSelectors
     * @param {Clusters} Clusters
     * @param {object} $state
     * @param {object} IgniteMessages
     * @param {object} IgniteConfirm
     * @param {Confirm} Confirm
     * @param {ConfigurationDownload} ConfigurationDownload
     */
    constructor(ConfigureState, Caches, IGFSs, Models, ConfigSelectors, Clusters, $state, IgniteMessages, IgniteConfirm, Confirm, ConfigurationDownload) {
        this.ConfigureState = ConfigureState;
        this.ConfigSelectors = ConfigSelectors;
        this.IGFSs = IGFSs;
        this.Models = Models;
        this.Caches = Caches;
        this.Clusters = Clusters;
        this.$state = $state;
        this.IgniteMessages = IgniteMessages;
        this.IgniteConfirm = IgniteConfirm;
        this.Confirm = Confirm;
        this.configurationDownload = ConfigurationDownload;

        this.loadConfigurationEffect$ = this.ConfigureState.actions$.pipe(
            ofType('LOAD_COMPLETE_CONFIGURATION'),
            exhaustMap((action) => {
                return from(this.Clusters.getConfiguration(action.clusterID)).pipe(
                    switchMap(({data}) => of(
                        completeConfiguration(data),
                        {type: 'LOAD_COMPLETE_CONFIGURATION_OK', data}
                    )),
                    catchError((error) => of({
                        type: 'LOAD_COMPLETE_CONFIGURATION_ERR',
                        error: {
                            message: `Failed to load cluster configuration: ${error.data}.`
                        },
                        action
                    })));
            })
        );

        this.storeConfigurationEffect$ = this.ConfigureState.actions$.pipe(
            ofType(COMPLETE_CONFIGURATION),
            exhaustMap(({configuration: {cluster, caches, models, igfss}}) => of(...[
                cluster && {type: clustersActionTypes.UPSERT, items: [cluster]},
                caches && caches.length && {type: cachesActionTypes.UPSERT, items: caches},
                models && models.length && {type: modelsActionTypes.UPSERT, items: models},
                igfss && igfss.length && {type: igfssActionTypes.UPSERT, items: igfss}
            ].filter((v) => v)))
        );

        this.saveCompleteConfigurationEffect$ = this.ConfigureState.actions$.pipe(
            ofType(ADVANCED_SAVE_COMPLETE_CONFIGURATION),
            switchMap((action) => {
                const actions = [
                    {
                        type: modelsActionTypes.UPSERT,
                        items: action.changedItems.models
                    },
                    {
                        type: shortModelsActionTypes.UPSERT,
                        items: action.changedItems.models.map((m) => this.Models.toShortModel(m))
                    },
                    {
                        type: igfssActionTypes.UPSERT,
                        items: action.changedItems.igfss
                    },
                    {
                        type: shortIGFSsActionTypes.UPSERT,
                        items: action.changedItems.igfss
                    },
                    {
                        type: cachesActionTypes.UPSERT,
                        items: action.changedItems.caches
                    },
                    {
                        type: shortCachesActionTypes.UPSERT,
                        items: action.changedItems.caches.map(Caches.toShortCache)
                    },
                    {
                        type: clustersActionTypes.UPSERT,
                        items: [action.changedItems.cluster]
                    },
                    {
                        type: shortClustersActionTypes.UPSERT,
                        items: [Clusters.toShortCluster(action.changedItems.cluster)]
                    }
                ].filter((a) => a.items.length);

                return merge(
                    of(...actions),
                    from(Clusters.saveAdvanced(action.changedItems)).pipe(
                        switchMap((res) => {
                            return of(
                                {type: 'EDIT_CLUSTER', cluster: action.changedItems.cluster},
                                {type: 'ADVANCED_SAVE_COMPLETE_CONFIGURATION_OK', changedItems: action.changedItems}
                            );
                        }),
                        catchError((res) => {
                            return of({
                                type: 'ADVANCED_SAVE_COMPLETE_CONFIGURATION_ERR',
                                changedItems: action.changedItems,
                                action,
                                error: {
                                    message: `Failed to save cluster "${action.changedItems.cluster.name}": ${res.data}.`
                                }
                            }, {
                                type: 'UNDO_ACTIONS',
                                actions
                            });
                        })
                    )
                );
            })
        );

        this.addCacheToEditEffect$ = this.ConfigureState.actions$.pipe(
            ofType('ADD_CACHE_TO_EDIT'),
            switchMap(() => this.ConfigureState.state$.pipe(this.ConfigSelectors.selectCacheToEdit('new'), take(1))),
            map((cache) => ({type: 'UPSERT_CLUSTER_ITEM', itemType: 'caches', item: cache}))
        );

        this.errorNotificationsEffect$ = this.ConfigureState.actions$.pipe(
            filter((a) => a.error),
            tap((action) => this.IgniteMessages.showError(action.error)),
            ignoreElements()
        );

        this.loadUserClustersEffect$ = this.ConfigureState.actions$.pipe(
            ofType('LOAD_USER_CLUSTERS'),
            exhaustMap((a) => {
                return from(this.Clusters.getClustersOverview()).pipe(
                    switchMap(({data}) => of(
                        {type: shortClustersActionTypes.SET, items: data},
                        {type: `${a.type}_OK`}
                    )),
                    catchError((error) => of({
                        type: `${a.type}_ERR`,
                        error: {
                            message: `Failed to load clusters: ${error.data}`
                        },
                        action: a
                    }))
                );
            })
        );

        this.loadAndEditClusterEffect$ = ConfigureState.actions$.pipe(
            ofType('LOAD_AND_EDIT_CLUSTER'),
            withLatestFrom(this.ConfigureState.state$.pipe(this.ConfigSelectors.selectShortClustersValue())),
            exhaustMap(([a, shortClusters]) => {
                if (a.clusterID === 'new') {
                    return of(
                        {
                            type: 'EDIT_CLUSTER',
                            cluster: {
                                ...this.Clusters.getBlankCluster(),
                                name: uniqueName(defaultNames.cluster, shortClusters)
                            }
                        },
                        {type: 'LOAD_AND_EDIT_CLUSTER_OK'}
                    );
                }
                return this.ConfigureState.state$.pipe(
                    this.ConfigSelectors.selectCluster(a.clusterID),
                    take(1),
                    switchMap((cluster) => {
                        if (cluster) {
                            return of(
                                {type: 'EDIT_CLUSTER', cluster},
                                {type: 'LOAD_AND_EDIT_CLUSTER_OK'}
                            );
                        }
                        return from(this.Clusters.getCluster(a.clusterID)).pipe(
                            switchMap(({data}) => of(
                                {type: clustersActionTypes.UPSERT, items: [data]},
                                {type: 'EDIT_CLUSTER', cluster: data},
                                {type: 'LOAD_AND_EDIT_CLUSTER_OK'}
                            )),
                            catchError((error) => of({
                                type: 'LOAD_AND_EDIT_CLUSTER_ERR',
                                error: {
                                    message: `Failed to load cluster: ${error.data}.`
                                }
                            }))
                        );
                    })
                );
            })
        );

        this.loadCacheEffect$ = this.ConfigureState.actions$.pipe(
            ofType('LOAD_CACHE'),
            exhaustMap((a) => {
                return this.ConfigureState.state$.pipe(
                    this.ConfigSelectors.selectCache(a.cacheID),
                    take(1),
                    switchMap((cache) => {
                        if (cache)
                            return of({type: `${a.type}_OK`, cache});

                        return from(this.Caches.getCache(a.cacheID)).pipe(
                            switchMap(({data}) => of(
                                {type: 'CACHE', cache: data},
                                {type: `${a.type}_OK`, cache: data}
                            ))
                        );
                    }),
                    catchError((error) => of({
                        type: `${a.type}_ERR`,
                        error: {
                            message: `Failed to load cache: ${error.data}.`
                        }
                    }))
                );
            })
        );

        this.storeCacheEffect$ = this.ConfigureState.actions$.pipe(
            ofType('CACHE'),
            map((a) => ({type: cachesActionTypes.UPSERT, items: [a.cache]}))
        );

        this.loadShortCachesEffect$ = ConfigureState.actions$.pipe(
            ofType('LOAD_SHORT_CACHES'),
            exhaustMap((a) => {
                if (!(a.ids || []).length)
                    return of({type: `${a.type}_OK`});

                return this.ConfigureState.state$.pipe(
                    this.ConfigSelectors.selectShortCaches(),
                    take(1),
                    switchMap((items) => {
                        if (!items.pristine && a.ids && a.ids.every((_id) => items.value.has(_id)))
                            return of({type: `${a.type}_OK`});

                        return from(this.Clusters.getClusterCaches(a.clusterID)).pipe(
                            switchMap(({data}) => of(
                                {type: shortCachesActionTypes.UPSERT, items: data},
                                {type: `${a.type}_OK`}
                            ))
                        );
                    }),
                    catchError((error) => of({
                        type: `${a.type}_ERR`,
                        error: {
                            message: `Failed to load caches: ${error.data}.`
                        },
                        action: a
                    }))
                );
            })
        );

        this.loadIgfsEffect$ = this.ConfigureState.actions$.pipe(
            ofType('LOAD_IGFS'),
            exhaustMap((a) => {
                return this.ConfigureState.state$.pipe(
                    this.ConfigSelectors.selectIGFS(a.igfsID),
                    take(1),
                    switchMap((igfs) => {
                        if (igfs)
                            return of({type: `${a.type}_OK`, igfs});

                        return from(this.IGFSs.getIGFS(a.igfsID)).pipe(
                            switchMap(({data}) => of(
                                {type: 'IGFS', igfs: data},
                                {type: `${a.type}_OK`, igfs: data}
                            ))
                        );
                    }),
                    catchError((error) => of({
                        type: `${a.type}_ERR`,
                        error: {
                            message: `Failed to load IGFS: ${error.data}.`
                        }
                    }))
                );
            })
        );

        this.storeIgfsEffect$ = this.ConfigureState.actions$.pipe(
            ofType('IGFS'),
            map((a) => ({type: igfssActionTypes.UPSERT, items: [a.igfs]}))
        );

        this.loadShortIgfssEffect$ = ConfigureState.actions$.pipe(
            ofType('LOAD_SHORT_IGFSS'),
            exhaustMap((a) => {
                if (!(a.ids || []).length) {
                    return of(
                        {type: shortIGFSsActionTypes.UPSERT, items: []},
                        {type: `${a.type}_OK`}
                    );
                }
                return this.ConfigureState.state$.pipe(
                    this.ConfigSelectors.selectShortIGFSs(),
                    take(1),
                    switchMap((items) => {
                        if (!items.pristine && a.ids && a.ids.every((_id) => items.value.has(_id)))
                            return of({type: `${a.type}_OK`});

                        return from(this.Clusters.getClusterIGFSs(a.clusterID)).pipe(
                            switchMap(({data}) => of(
                                {type: shortIGFSsActionTypes.UPSERT, items: data},
                                {type: `${a.type}_OK`}
                            ))
                        );
                    }),
                    catchError((error) => of({
                        type: `${a.type}_ERR`,
                        error: {
                            message: `Failed to load IGFSs: ${error.data}.`
                        },
                        action: a
                    }))
                );
            })
        );

        this.loadModelEffect$ = this.ConfigureState.actions$.pipe(
            ofType('LOAD_MODEL'),
            exhaustMap((a) => {
                return this.ConfigureState.state$.pipe(
                    this.ConfigSelectors.selectModel(a.modelID),
                    take(1),
                    switchMap((model) => {
                        if (model)
                            return of({type: `${a.type}_OK`, model});

                        return from(this.Models.getModel(a.modelID)).pipe(
                            switchMap(({data}) => of(
                                {type: 'MODEL', model: data},
                                {type: `${a.type}_OK`, model: data}
                            ))
                        );
                    }),
                    catchError((error) => of({
                        type: `${a.type}_ERR`,
                        error: {
                            message: `Failed to load domain model: ${error.data}.`
                        }
                    }))
                );
            })
        );

        this.storeModelEffect$ = this.ConfigureState.actions$.pipe(
            ofType('MODEL'),
            map((a) => ({type: modelsActionTypes.UPSERT, items: [a.model]}))
        );

        this.loadShortModelsEffect$ = this.ConfigureState.actions$.pipe(
            ofType('LOAD_SHORT_MODELS'),
            exhaustMap((a) => {
                if (!(a.ids || []).length) {
                    return of(
                        {type: shortModelsActionTypes.UPSERT, items: []},
                        {type: `${a.type}_OK`}
                    );
                }
                return this.ConfigureState.state$.pipe(
                    this.ConfigSelectors.selectShortModels(),
                    take(1),
                    switchMap((items) => {
                        if (!items.pristine && a.ids && a.ids.every((_id) => items.value.has(_id)))
                            return of({type: `${a.type}_OK`});

                        return from(this.Clusters.getClusterModels(a.clusterID)).pipe(
                            switchMap(({data}) => of(
                                {type: shortModelsActionTypes.UPSERT, items: data},
                                {type: `${a.type}_OK`}
                            ))
                        );
                    }),
                    catchError((error) => of({
                        type: `${a.type}_ERR`,
                        error: {
                            message: `Failed to load domain models: ${error.data}.`
                        },
                        action: a
                    }))
                );
            })
        );

        this.basicSaveRedirectEffect$ = this.ConfigureState.actions$.pipe(
            ofType(BASIC_SAVE_OK),
            tap((a) => this.$state.go('base.configuration.edit.basic', {clusterID: a.changedItems.cluster._id}, {location: 'replace', custom: {justIDUpdate: true}})),
            ignoreElements()
        );

        this.basicDownloadAfterSaveEffect$ = this.ConfigureState.actions$.pipe(
            ofType(BASIC_SAVE_AND_DOWNLOAD),
            zip(this.ConfigureState.actions$.pipe(ofType(BASIC_SAVE_OK))),
            pluck('1'),
            tap((a) => this.configurationDownload.downloadClusterConfiguration(a.changedItems.cluster)),
            ignoreElements()
        );

        this.advancedDownloadAfterSaveEffect$ = merge(
            this.ConfigureState.actions$.pipe(ofType(ADVANCED_SAVE_CLUSTER)),
            this.ConfigureState.actions$.pipe(ofType(ADVANCED_SAVE_CACHE)),
            this.ConfigureState.actions$.pipe(ofType(ADVANCED_SAVE_IGFS)),
            this.ConfigureState.actions$.pipe(ofType(ADVANCED_SAVE_MODEL)),
        ).pipe(
            filter((a) => a.download),
            zip(this.ConfigureState.actions$.pipe(ofType('ADVANCED_SAVE_COMPLETE_CONFIGURATION_OK'))),
            pluck('1'),
            tap((a) => this.configurationDownload.downloadClusterConfiguration(a.changedItems.cluster)),
            ignoreElements()
        );

        this.advancedSaveRedirectEffect$ = this.ConfigureState.actions$.pipe(
            ofType('ADVANCED_SAVE_COMPLETE_CONFIGURATION_OK'),
            withLatestFrom(this.ConfigureState.actions$.pipe(ofType(ADVANCED_SAVE_COMPLETE_CONFIGURATION))),
            pluck('1', 'changedItems'),
            map((req) => {
                const firstChangedItem = Object.keys(req).filter((k) => k !== 'cluster')
                    .map((k) => Array.isArray(req[k]) ? [k, req[k][0]] : [k, req[k]])
                    .filter((v) => v[1])
                    .pop();
                return firstChangedItem ? [...firstChangedItem, req.cluster] : ['cluster', req.cluster, req.cluster];
            }),
            tap(([type, value, cluster]) => {
                const go = (state, params = {}) => this.$state.go(
                    state, {...params, clusterID: cluster._id}, {location: 'replace', custom: {justIDUpdate: true}}
                );

                switch (type) {
                    case 'models': {
                        const state = 'base.configuration.edit.advanced.models.model';
                        this.IgniteMessages.showInfo(`Model "${value.valueType}" saved`);

                        if (this.$state.is(state) && this.$state.params.modelID !== value._id)
                            return go(state, {modelID: value._id});

                        break;
                    }

                    case 'caches': {
                        const state = 'base.configuration.edit.advanced.caches.cache';
                        this.IgniteMessages.showInfo(`Cache "${value.name}" saved`);

                        if (this.$state.is(state) && this.$state.params.cacheID !== value._id)
                            return go(state, {cacheID: value._id});

                        break;
                    }

                    case 'igfss': {
                        const state = 'base.configuration.edit.advanced.igfs.igfs';
                        this.IgniteMessages.showInfo(`IGFS "${value.name}" saved`);

                        if (this.$state.is(state) && this.$state.params.igfsID !== value._id)
                            return go(state, {igfsID: value._id});

                        break;
                    }

                    case 'cluster': {
                        const state = 'base.configuration.edit.advanced.cluster';
                        this.IgniteMessages.showInfo(`Cluster "${value.name}" saved`);

                        if (this.$state.is(state) && this.$state.params.clusterID !== value._id)
                            return go(state);

                        break;
                    }

                    default: break;
                }
            }),
            ignoreElements()
        );

        this.removeClusterItemsEffect$ = this.ConfigureState.actions$.pipe(
            ofType(REMOVE_CLUSTER_ITEMS),
            exhaustMap((a) => {
                return a.confirm
                    // TODO: list items to remove in confirmation
                    ? from(this.Confirm.confirm('Are you sure you want to remove these items?')).pipe(
                        mapTo(a),
                        catchError(() => empty())
                    )
                    : of(a);
            }),
            map((a) => removeClusterItemsConfirmed(a.clusterID, a.itemType, a.itemIDs))
        );

        this.persistRemovedClusterItemsEffect$ = this.ConfigureState.actions$.pipe(
            ofType(REMOVE_CLUSTER_ITEMS_CONFIRMED),
            withLatestFrom(this.ConfigureState.actions$.pipe(ofType(REMOVE_CLUSTER_ITEMS))),
            filter(([a, b]) => {
                return a.itemType === b.itemType
                    && b.save
                    && JSON.stringify(a.itemIDs) === JSON.stringify(b.itemIDs);
            }),
            pluck('0'),
            withLatestFrom(this.ConfigureState.state$.pipe(pluck('edit'))),
            map(([action, edit]) => advancedSaveCompleteConfiguration(edit))
        );

        this.confirmClustersRemovalEffect$ = this.ConfigureState.actions$.pipe(
            ofType(CONFIRM_CLUSTERS_REMOVAL),
            pluck('clusterIDs'),
            switchMap((ids) => this.ConfigureState.state$.pipe(
                this.ConfigSelectors.selectClusterNames(ids),
                take(1)
            )),
            exhaustMap((names) => {
                return from(this.Confirm.confirm(`
                    <p>Are you sure you want to remove these clusters?</p>
                    <ul>${names.map((name) => `<li>${name}</li>`).join('')}</ul>
                `)).pipe(
                    map(confirmClustersRemovalOK),
                    catchError(() => empty())
                );
            })
        );

        this.persistRemovedClustersLocallyEffect$ = this.ConfigureState.actions$.pipe(
            ofType(CONFIRM_CLUSTERS_REMOVAL_OK),
            withLatestFrom(this.ConfigureState.actions$.pipe(ofType(CONFIRM_CLUSTERS_REMOVAL))),
            switchMap(([, {clusterIDs}]) => of(
                {type: shortClustersActionTypes.REMOVE, ids: clusterIDs},
                {type: clustersActionTypes.REMOVE, ids: clusterIDs}
            ))
        );

        this.persistRemovedClustersRemotelyEffect$ = this.ConfigureState.actions$.pipe(
            ofType(CONFIRM_CLUSTERS_REMOVAL_OK),
            withLatestFrom(
                this.ConfigureState.actions$.pipe(ofType(CONFIRM_CLUSTERS_REMOVAL)),
                this.ConfigureState.actions$.pipe(ofType(shortClustersActionTypes.REMOVE)),
                this.ConfigureState.actions$.pipe(ofType(clustersActionTypes.REMOVE))
            ),
            switchMap(([, {clusterIDs}, ...backup]) => this.Clusters.removeCluster$(clusterIDs).pipe(
                mapTo({
                    type: 'REMOVE_CLUSTERS_OK'
                }),
                catchError((e) => of(
                    {
                        type: 'REMOVE_CLUSTERS_ERR',
                        error: {
                            message: `Failed to remove clusters: ${e.data}`
                        }
                    },
                    {
                        type: 'UNDO_ACTIONS',
                        actions: backup
                    }
                ))
            ))
        );

        this.notifyRemoteClustersRemoveSuccessEffect$ = this.ConfigureState.actions$.pipe(
            ofType('REMOVE_CLUSTERS_OK'),
            withLatestFrom(this.ConfigureState.actions$.pipe(ofType(CONFIRM_CLUSTERS_REMOVAL))),
            tap(([, {clusterIDs}]) => this.IgniteMessages.showInfo(`Cluster(s) removed: ${clusterIDs.length}`)),
            ignoreElements()
        );

        const _applyChangedIDs = (edit, {cache, igfs, model, cluster} = {}) => ({
            cluster: {
                ...edit.changes.cluster,
                ...(cluster ? cluster : {}),
                caches: cache ? uniq([...edit.changes.caches.ids, cache._id]) : edit.changes.caches.ids,
                igfss: igfs ? uniq([...edit.changes.igfss.ids, igfs._id]) : edit.changes.igfss.ids,
                models: model ? uniq([...edit.changes.models.ids, model._id]) : edit.changes.models.ids
            },
            caches: cache ? uniq([...edit.changes.caches.changedItems, cache]) : edit.changes.caches.changedItems,
            igfss: igfs ? uniq([...edit.changes.igfss.changedItems, igfs]) : edit.changes.igfss.changedItems,
            models: model ? uniq([...edit.changes.models.changedItems, model]) : edit.changes.models.changedItems
        });

        this.advancedSaveCacheEffect$ = merge(
            this.ConfigureState.actions$.pipe(ofType(ADVANCED_SAVE_CLUSTER)),
            this.ConfigureState.actions$.pipe(ofType(ADVANCED_SAVE_CACHE)),
            this.ConfigureState.actions$.pipe(ofType(ADVANCED_SAVE_IGFS)),
            this.ConfigureState.actions$.pipe(ofType(ADVANCED_SAVE_MODEL)),
        ).pipe(
            withLatestFrom(this.ConfigureState.state$.pipe(pluck('edit'))),
            map(([action, edit]) => ({
                type: ADVANCED_SAVE_COMPLETE_CONFIGURATION,
                changedItems: _applyChangedIDs(edit, action)
            }))
        );

        this.basicSaveEffect$ = merge(
            this.ConfigureState.actions$.pipe(ofType(BASIC_SAVE)),
            this.ConfigureState.actions$.pipe(ofType(BASIC_SAVE_AND_DOWNLOAD))
        ).pipe(
            withLatestFrom(this.ConfigureState.state$.pipe(pluck('edit'))),
            switchMap(([action, edit]) => {
                const changedItems = _applyChangedIDs(edit, {cluster: action.cluster});
                const actions = [{
                    type: cachesActionTypes.UPSERT,
                    items: changedItems.caches
                },
                {
                    type: shortCachesActionTypes.UPSERT,
                    items: changedItems.caches
                },
                {
                    type: clustersActionTypes.UPSERT,
                    items: [changedItems.cluster]
                },
                {
                    type: shortClustersActionTypes.UPSERT,
                    items: [this.Clusters.toShortCluster(changedItems.cluster)]
                }
                ].filter((a) => a.items.length);

                return merge(
                    of(...actions),
                    from(this.Clusters.saveBasic(changedItems)).pipe(
                        switchMap((res) => of(
                            {type: 'EDIT_CLUSTER', cluster: changedItems.cluster},
                            basicSaveOK(changedItems)
                        )),
                        catchError((res) => of(
                            basicSaveErr(changedItems, res),
                            {type: 'UNDO_ACTIONS', actions}
                        ))
                    )
                );
            })
        );

        this.basicSaveOKMessagesEffect$ = this.ConfigureState.actions$.pipe(
            ofType(BASIC_SAVE_OK),
            tap((action) => this.IgniteMessages.showInfo(`Cluster "${action.changedItems.cluster.name}" saved.`)),
            ignoreElements()
        );
    }

    /**
     * @name etp
     * @function
     * @param {object} action
     * @returns {Promise}
     */
    /**
     * @name etp^2
     * @function
     * @param {string} type
     * @param {object} [params]
     * @returns {Promise}
     */
    etp = (...args) => {
        const action = typeof args[0] === 'object' ? args[0] : {type: args[0], ...args[1]};
        const ok = `${action.type}_OK`;
        const err = `${action.type}_ERR`;

        setTimeout(() => this.ConfigureState.dispatchAction(action));

        return this.ConfigureState.actions$.pipe(
            filter((a) => a.type === ok || a.type === err),
            take(1),
            map((a) => {
                if (a.type === err)
                    throw a;
                else
                    return a;
            })
        ).toPromise();
    };

    connect() {
        return merge(
            ...Object.keys(this).filter((k) => k.endsWith('Effect$')).map((k) => this[k])
        ).pipe(tap((a) => this.ConfigureState.dispatchAction(a))).subscribe();
    }
}