/**
 * 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.
 */

var App = require('app');
var stringUtils = require('utils/string_utils');
var fileUtils = require('utils/file_utils');
require('./wizardStep_controller');

App.WizardStep8Controller = App.WizardStepController.extend(App.AddSecurityConfigs, App.wizardDeployProgressControllerMixin, App.ConfigOverridable, App.ConfigsSaverMixin, {

  name: 'wizardStep8Controller',

  stepName: 'step8',

  /**
   * @type {boolean}
   */
  isAddService: Em.computed.equal('content.controllerName', 'addServiceController'),

  /**
   * @type {boolean}
   */
  isAddHost: Em.computed.equal('content.controllerName', 'addHostController'),

  /**
   * @type {boolean}
   */
  isInstaller: Em.computed.equal('content.controllerName', 'installerController'),

  /**
   * List of raw data about cluster that should be displayed
   * @type {Array}
   */
  rawContent: [
    {
      config_name: 'Admin',
      display_name: 'Admin Name',
      config_value: ''
    },
    {
      config_name: 'cluster',
      display_name: 'Cluster Name',
      config_value: ''
    },
    {
      config_name: 'hosts',
      display_name: 'Total Hosts',
      config_value: ''
    },
    {
      config_name: 'Repo',
      display_name: 'Local Repository',
      config_value: ''
    }
  ],

  /**
   * List of data about cluster (based on formatted <code>rawContent</code>)
   * @type {Object[]}
   */
  clusterInfo: [],

  /**
   * List of services with components assigned to hosts
   * @type {Object[]}
   */
  services: [],

  /**
   * @type {Object[]}
   */
  configs: [],

  /**
   * True if Kerberos is installed on the cluster and the kdc_type on the server is set to "none"
   * @type {Boolean}
   */
  isManualKerberos: Em.computed.equal('App.router.mainAdminKerberosController.kdc_type', 'none'),

  showDownloadCsv: function () {
    return !!App.get('router.mainAdminKerberosController.kdc_type')
  }.property('App.router.mainAdminKerberosController.kdc_type'),


  /**
   * Should Submit button be disabled
   * @type {bool}
   */
  isSubmitDisabled: false,

  /**
   * Should Back button be disabled
   * @type {bool}
   */
  isBackBtnDisabled: false,

  /**
   * Is error appears while <code>ajaxQueue</code> executes
   * @type {bool}
   */
  hasErrorOccurred: false,

  /**
   * Are services installed
   * Used to hide Deploy Progress Bar
   * @type {bool}
   */
  servicesInstalled: false,

  /**
   * List of service config tags
   * @type {Object[]}
   */
  serviceConfigTags: [],

  /**
   * Selected config group
   * @type {Object}
   */
  selectedConfigGroup: null,

  /**
   * List of config groups
   * @type {Object[]}
   */
  configGroups: [],

  selectedServices: function () {
    const services = App.StackService.find().map(service => service);
    return services;
  }.property(),

  selectedMpacks: function() {
    return this.get('content.selectedMpacks') || this.get('wizardController').getDBProperty('selectedMpacks');
  }.property(),

  downloadConfig: function() {
    return this.get('content.downloadConfig') || this.get('wizardController').getDBProperty('downloadConfig');
  }.property(),

  getSelectedStack: function() {
    const selectedStack = this.get('content.selectedStack');
    const stack = this.get('wizardController').getStack(selectedStack.name, selectedStack.version);
    return stack;    
  },

  installedServices: function() {
    const services = App.StackService.find().filter(service => service.get('isInstalled') === true);
    return services;
  }.property(),

  /**
   * Current cluster name
   * @type {string}
   */
  clusterName: Em.computed.alias('content.cluster.name'),

  /**
   * List of existing cluster names
   * @type {string[]}
   */
  clusterNames: [],

  /**
   * Number of completed cluster delete requests
   * @type {number}
   */
  clusterDeleteRequestsCompleted: 0,

  /**
   * Number of existing repo_versions
   * @type {number}
   */
  existingRepositoryVersions: 0,

  /**
   * Indicates if all cluster delete requests are completed
   * @type {boolean}
   */
  isAllClusterDeleteRequestsCompleted: Em.computed.equalProperties('clusterDeleteRequestsCompleted', 'clusterNames.length'),

  /**
   * Error popup body views for clusters that couldn't be deleted
   * @type {App.AjaxDefaultErrorPopupBodyView[]}
   */
  clusterDeleteErrorViews: [],

  /**
   * Clear current step data
   * @method clearStep
   */
  clearStep: function () {
    this.get('services').clear();
    this.get('configs').clear();
    this.get('clusterInfo').clear();
    this.get('serviceConfigTags').clear();
    this.set('servicesInstalled', false);
    this.set('ajaxQueueLength', 0);
    this.set('ajaxRequestsQueue', App.ajaxQueue.create());
    this.set('ajaxRequestsQueue.finishedCallback', this.ajaxQueueFinished);
    this.get('clusterDeleteErrorViews').clear();
    this.set('clusterDeleteRequestsCompleted', 0);
  },

  /**
   * Load current step data
   * @method loadStep
   */
  loadStep: function () {
    this.clearStep();
    if (this.get('content.serviceConfigProperties')) {
      this.formatProperties();
      this.loadConfigs();
    }
    this.loadClusterInfo();
    this.loadServices();
    this.set('isSubmitDisabled', false);
    this.set('isBackBtnDisabled', false);
  },

  /**
   * replace whitespace character with coma between directories
   * @method formatProperties
   */
  formatProperties: function () {
    this.get('content.serviceConfigProperties').forEach(function (_configProperty) {
      _configProperty.value = typeof _configProperty.value === "boolean"
        ? _configProperty.value.toString() : App.config.trimProperty(_configProperty, false);
    });
  },

  /**
   * Load all site properties
   * @method loadConfigs
   */
  loadConfigs: function () {
    this.set('configs', this.get('content.serviceConfigProperties').filter(function (config) {
      return !config.group;
    }));
  },

  /**
   * Format <code>content.hosts</code> from Object to Array
   * @returns {Array}
   * @method getRegisteredHosts
   */
  getRegisteredHosts: function () {
    var allHosts = this.get('content.hosts');
    var hosts = [];
    for (var hostName in allHosts) {
      if (allHosts.hasOwnProperty(hostName)) {
        if (allHosts[hostName].bootStatus === 'REGISTERED') {
          allHosts[hostName].hostName = allHosts[hostName].name;
          hosts.pushObject(allHosts[hostName]);
        }
      }
    }
    return hosts;
  },

  /**
   * Load all info about cluster to <code>clusterInfo</code> variable
   * @method loadClusterInfo
   */
  loadClusterInfo: function () {

    //Admin name
    var admin = this.rawContent.findProperty('config_name', 'Admin');
    admin.config_value = App.db.getLoginName();
    if (admin.config_value) {
      this.get('clusterInfo').pushObject(Ember.Object.create(admin));
    }

    // cluster name
    var cluster = this.rawContent.findProperty('config_name', 'cluster');
    cluster.config_value = this.get('content.cluster.name');
    this.get('clusterInfo').pushObject(Ember.Object.create(cluster));

    //hosts
    var newHostsCount = 0;
    var totalHostsCount = 0;
    var hosts = this.get('content.hosts');
    for (var hostName in hosts) {
      newHostsCount += ~~!hosts[hostName].isInstalled;
      totalHostsCount++;
    }

    var totalHostsObj = this.rawContent.findProperty('config_name', 'hosts');
    totalHostsObj.config_value = totalHostsCount + ' (' + newHostsCount + ' new)';
    this.get('clusterInfo').pushObject(Em.Object.create(totalHostsObj));

    //repo
    if (this.get('isAddService') || this.get('isAddHost')) {
      // For some stacks there is no info regarding stack versions to upgrade, e.g. HDP-2.1
      if (App.StackVersion.find().get('content.length')) {
        this.loadRepoInfo();
      } else {
        this.loadDefaultRepoInfo();
      }
    } else {
      // from install wizard
      var downloadConfig = this.get('downloadConfig');
      var selectedStack = this.getSelectedStack();
      var allRepos = [];
      if (selectedStack && selectedStack.get('operatingSystems')) {
        selectedStack.get('operatingSystems').forEach(function (os) {
          if (os.get('isSelected')) {
            os.get('repositories').forEach(function(repo) {
              if (repo.get('showRepo')) {
                allRepos.push(Em.Object.create({
                  base_url: repo.get('baseUrl'),
                  os_type: repo.get('osType'),
                  repo_id: repo.get('repoId')
                }));
              }
            }, this);
          }
        }, this);
      }
      allRepos.set('display_name', Em.I18n.t("installer.step8.repoInfo.displayName"));
      this.get('clusterInfo').set('useRedhatSatellite', downloadConfig.useRedhatSatellite);
      this.get('clusterInfo').set('repoInfo', allRepos);
    }
  },

  /**
   * Load repo info for add Service/Host wizard review page
   * @return {$.ajax|null}
   * @method loadRepoInfo
   */
  loadRepoInfo: function () {
    var stackName = App.get('currentStackName');
    var currentStackVersionNumber = App.get('currentStackVersionNumber');
    var currentStackVersion = App.StackVersion.find().filterProperty('stack', stackName).findProperty('version', currentStackVersionNumber);
    var currentRepoVersion = currentStackVersion.get('repositoryVersion.repositoryVersion');

    return App.ajax.send({
      name: 'cluster.load_repo_version',
      sender: this,
      data: {
        stackName: stackName,
        repositoryVersion: currentRepoVersion
      },
      success: 'loadRepoInfoSuccessCallback',
      error: 'loadRepoInfoErrorCallback'
    });
  },

  /**
   * Save all repo base URL of all OS type to <code>repoInfo<code>
   * @param {object} data
   * @method loadRepoInfoSuccessCallback
   */
  loadRepoInfoSuccessCallback: function (data) {
    Em.assert('Current repo-version may be only one', data.items.length === 1);
    if (data.items.length) {
      var allRepos = this.generateRepoInfo(Em.getWithDefault(data, 'items.0.repository_versions.0.operating_systems', []));
      allRepos.set('display_name', Em.I18n.t("installer.step8.repoInfo.displayName"));
      this.get('clusterInfo').set('repoInfo', allRepos);
      //if the property is missing, set as false
      this.get('clusterInfo').set('useRedhatSatellite', data.items[0].repository_versions[0].operating_systems[0].OperatingSystems.ambari_managed_repositories === false);
    } else {
      this.loadDefaultRepoInfo();
    }
  },

  /**
   * Generate list regarding info about OS versions and repositories.
   *
   * @param {Object{}} oses - OS array
   * @returns {Em.Object[]}
   */
  generateRepoInfo: function(oses) {
    return oses.map(function(os) {
      return os.repositories.map(function (repository) {
        return Em.Object.create({
          base_url: repository.Repositories.base_url,
          os_type: repository.Repositories.os_type,
          repo_id: repository.Repositories.repo_id
        });
      });
    }).reduce(function(p, c) { return p.concat(c); });
  },

  /**
   * Load repo info from stack. Used if installed stack doesn't have upgrade info.
   *
   * @returns {$.Deferred}
   * @method loadDefaultRepoInfo
   */
  loadDefaultRepoInfo: function() {
    var nameVersionCombo = App.get('currentStackVersion').split('-');

    return App.ajax.send({
      name: 'cluster.load_repositories',
      sender: this,
      data: {
        stackName: nameVersionCombo[0],
        stackVersion: nameVersionCombo[1]
      },
      success: 'loadDefaultRepoInfoSuccessCallback',
      error: 'loadRepoInfoErrorCallback'
    });
  },

  /**
   * @param {Object} data - JSON data from server
   * @method loadDefaultRepoInfoSuccessCallback
   */
  loadDefaultRepoInfoSuccessCallback: function (data) {
    var allRepos = this.generateRepoInfo(Em.getWithDefault(data, 'items', []));
    allRepos.set('display_name', Em.I18n.t("installer.step8.repoInfo.displayName"));
    this.get('clusterInfo').set('repoInfo', allRepos);
    //if the property is missing, set as false
    this.get('clusterInfo').set('useRedhatSatellite', data.items[0].OperatingSystems.ambari_managed_repositories === false);
  },

  /**
   * @method loadRepoInfoErrorCallback
   */
  loadRepoInfoErrorCallback: function () {
    var allRepos = [];
    allRepos.set('display_name', Em.I18n.t("installer.step8.repoInfo.displayName"));
    this.get('clusterInfo').set('repoInfo', allRepos);
  },

  /**
   * Load all info about services to <code>services</code> variable
   * @method loadServices
   */
  loadServices: function () {
    this.get('selectedServices').filterProperty('isHiddenOnSelectServicePage', false).forEach(function (service) {
      var serviceObj = Em.Object.create({
        service_name: service.get('serviceName'),
        display_name: service.get('displayNameOnSelectServicePage'),
        service_components: Em.A([])
      });
      service.get('serviceComponents').forEach(function (component) {
        // show clients for services that have only clients components
        if ((component.get('isClient') || component.get('isRequiredOnAllHosts')) && !service.get('isClientOnlyService')) return;
        // no HA component
        if (component.get('isHAComponentOnly')) return;
        // skip if component is not allowed on single node cluster
        if (Object.keys(this.get('content.hosts')).length === 1 && component.get('isNotAllowedOnSingleNodeCluster')) return;
        var displayName;
        if (component.get('isClient')) {
          displayName = Em.I18n.t('common.clients')
        } else {
          // remove service name from component display name
          displayName = App.format.role(component.get('componentName'), false).replace(new RegExp('^' + service.get('serviceName') + '\\s', 'i'), '');
        }

        var componentName = component.get('componentName');
        var masterComponents = this.get('content.masterComponentHosts');
        var isMasterComponentSelected = masterComponents.someProperty('component', componentName);
        var isMaster = component.get('isMaster');

        if (!isMaster || isMasterComponentSelected) {
          serviceObj.get('service_components').pushObject(Em.Object.create({
            component_name: component.get('isClient') ? Em.I18n.t('common.client').toUpperCase() : component.get('componentName'),
            display_name: displayName,
            component_value: this.assignComponentHosts(component)
          }));
        }
      }, this);
      if (service.get('customReviewHandler')) {
        for (var displayName in service.get('customReviewHandler')) {
          serviceObj.get('service_components').pushObject(Em.Object.create({
            display_name: displayName,
            component_value: this.assignComponentHosts(Em.Object.create({
              customHandler: service.get('customReviewHandler.' + displayName)
            }))
          }));
        }
      }
      this.get('services').pushObject(serviceObj);
    }, this);
  },

  /**
   * Set <code>component_value</code> property to <code>component</code>
   * @param {Em.Object} component
   * @return {String}
   * @method assignComponentHosts
   */
  assignComponentHosts: function (component) {
    var componentValue;
    if (component.get('customHandler')) {
      componentValue = this[component.get('customHandler')].call(this, component);
    }
    else {
      if (component.get('isMaster')) {
        componentValue = this.getMasterComponentValue(component.get('componentName'));
      }
      else {
        var componentName = component.get('isClient') ? Em.I18n.t('common.client').toUpperCase() : component.get('componentName');
        var hostsLength = this.get('content.slaveComponentHosts')
          .findProperty('componentName', componentName).hosts.length;
        componentValue = hostsLength + Em.I18n.t('installer.step8.host' + (hostsLength > 1 ? 's' : ''));
      }
    }
    return componentValue;
  },

  getMasterComponentValue: function (componentName) {
    var masterComponents = this.get('content.masterComponentHosts');
    var hostsCount = masterComponents.filterProperty('component', componentName).length;
    return stringUtils.pluralize(hostsCount,
      masterComponents.findProperty('component', componentName).hostName,
        hostsCount + ' ' + Em.I18n.t('installer.step8.hosts'));
  },

  loadHiveDbValue: function() {
    return this.loadDbValue('HIVE');
  },

  loadOozieDbValue: function() {
    return this.loadDbValue('OOZIE');
  },

  /**
   * Set displayed Hive DB value based on DB type
   * @method loadHiveDbValue
   */
  loadDbValue: function (serviceName) {
    var serviceConfigProperties = this.get('content.serviceConfigProperties');
    var dbFull = serviceConfigProperties.findProperty('name', serviceName.toLowerCase() + '_database');
      //db = serviceConfigProperties.findProperty('name', serviceName.toLowerCase() + '_ambari_database');
    //since db.value contains the intial default value of <service>_admin_database (MySQL) and not the actual db type selected,
    //ignore the value when displaying the database name on the summary page
    return dbFull ? dbFull.value : '';
  },

  /**
   * Set displayed HBase master value
   * @param {Object} hbaseMaster
   * @method loadHbaseMasterValue
   */
  loadHbaseMasterValue: function (hbaseMaster) {
    var hbaseHostName = this.get('content.masterComponentHosts').filterProperty('component', hbaseMaster.component_name);
    if (hbaseHostName.length === 1) {
      hbaseMaster.set('component_value', hbaseHostName[0].hostName);
    } else {
      hbaseMaster.set('component_value', hbaseHostName[0].hostName + " " + Em.I18n.t('installer.step8.other').format(hbaseHostName.length - 1));
    }
  },

  /**
   * Set displayed ZooKeeper Server value
   * @param {Object} serverComponent
   * @method loadZkServerValue
   */
  loadZkServerValue: function (serverComponent) {
    var zkHostNames = this.get('content.masterComponentHosts').filterProperty('component', serverComponent.component_name).length;
    var hostSuffix;
    if (zkHostNames === 1) {
      hostSuffix = Em.I18n.t('installer.step8.host');
    } else {
      hostSuffix = Em.I18n.t('installer.step8.hosts');
    }
    serverComponent.set('component_value', zkHostNames + hostSuffix);
  },

  /**
   * Onclick handler for <code>next</code> button
   * @method submit
   * @return {void}
   */
  submit: function () {
    var wizardController;
    if (!this.get('isSubmitDisabled')) {
      wizardController = App.router.get(this.get('content.controllerName'));
      wizardController.setLowerStepsDisable(wizardController.get('currentStep'));
      this.set('isSubmitDisabled', true);
      this.set('isBackBtnDisabled', true);
      this.showRestartWarnings()
        .then(this.checkKDCSession.bind(this));
    }
  },

  /**
   * Warn user about services that will be restarted during installation.
   *
   * @returns {$.Deferred}
   */
  showRestartWarnings: function() {
    var self = this;
    var dfd = $.Deferred();
    var wizardController = App.router.get(this.get('content.controllerName'));
    var selectedServiceNames = this.get('selectedServices').mapProperty('serviceName');
    var installedServiceNames = this.get('installedServices').mapProperty('serviceName');

    if (this.get('isAddService') && selectedServiceNames.contains('OOZIE')) {
      var affectedServices = ['HDFS', 'YARN'].filter(function(serviceName) {
        return installedServiceNames.contains(serviceName);
      });
      if (affectedServices.length) {
        var serviceNames = affectedServices.length > 1 ?
            '<b>{0}</b> {1} <b>{2}</b>'.format(affectedServices[0], Em.I18n.t('and'), affectedServices[1]) : '<b>' + affectedServices[0] + '</b> ';
        App.ModalPopup.show({
          encodeBody: false,
          header: Em.I18n.t('common.warning'),
          body: Em.I18n.t('installer.step8.services.restart.required').format(serviceNames, stringUtils.pluralize(affectedServices.length, Em.I18n.t('common.service').toLowerCase())),
          secondary: Em.I18n.t('common.cancel'),
          primary: Em.I18n.t('common.proceedAnyway'),
          onPrimary: function() {
            this.hide();
            dfd.resolve();
          },
          onClose: function() {
            this.hide();
            self.set('isSubmitDisabled', false);
            self.set('isBackBtnDisabled', false);
            wizardController.setStepsEnable();
            dfd.reject();
          },
          onSecondary: function() {
            this.onClose();
          }
        });
      } else {
        dfd.resolve();
      }
    } else {
      dfd.resolve();
    }
    return dfd.promise();
  },

  checkKDCSession: function() {
    var self = this;
    var wizardController = App.router.get(this.get('content.controllerName'));
    if (!this.get('isInstaller')) {
      App.get('router.mainAdminKerberosController').getKDCSessionState(this.submitProceed.bind(this), function () {
        self.set('isSubmitDisabled', false);
        self.set('isBackBtnDisabled', false);
        wizardController.setStepsEnable();
        if (self.get('isAddService')) {
          wizardController.setSkipSlavesStep(wizardController.getDBProperty('selectedServiceNames'), 3);
        }
      });
    } else {
      this.submitProceed();
    }
  },

  /**
   * Prepare <code>ajaxQueue</code> and start to execute it
   * @method submitProceed
   */
  submitProceed: function () {
    var self = this;
    this.set('clusterDeleteRequestsCompleted', 0);
    this.get('clusterDeleteErrorViews').clear();
    if (this.get('isAddHost')) {
      App.router.get('addHostController').setLowerStepsDisable(4);
    }

    // checkpoint the cluster status on the server so that the user can resume from where they left off
    switch (this.get('content.controllerName')) {
      case 'installerController':
        App.clusterStatus.setClusterStatus({
          clusterName: this.get('clusterName'),
          clusterState: 'CLUSTER_DEPLOY_PREP_2',
          wizardControllerName: this.get('content.controllerName'),
          localdb: App.db.data
        });
        break;
      case 'addHostController':
        App.clusterStatus.setClusterStatus({
          clusterName: this.get('clusterName'),
          clusterState: 'ADD_HOSTS_DEPLOY_PREP_2',
          wizardControllerName: this.get('content.controllerName'),
          localdb: App.db.data
        });
        break;
      case 'addServiceController':
        App.clusterStatus.setClusterStatus({
          clusterName: this.get('clusterName'),
          clusterState: 'ADD_SERVICES_DEPLOY_PREP_2',
          wizardControllerName: this.get('content.controllerName'),
          localdb: App.db.data
        });
        break;
      default:
        break;
    }
    // delete any existing clusters to start from a clean slate
    // before creating a new cluster in install wizard
    // TODO: modify for multi-cluster support
    // this.getExistingClusterNames().complete(function () {
    //   var clusterNames = self.get('clusterNames');
    //   if (self.get('isInstaller') && !App.get('testMode') && clusterNames.length) {
    //     self.deleteClusters(clusterNames);
    //   } else {
    //     self.getExistingVersions();
    //   }
    // });

    this.startDeploy();
  },

  /**
   * Get list of existing cluster names
   * @returns {object|null}
   * returns an array of existing cluster names.
   * returns an empty array if there are no existing clusters.
   * @method getExistingClusterNames
   */
  getExistingClusterNames: function () {
    return App.ajax.send({
      name: 'wizard.step8.existing_cluster_names',
      sender: this,
      success: 'getExistingClusterNamesSuccessCallBack',
      error: 'getExistingClusterNamesErrorCallback'
    });
  },

  /**
   * Save received list to <code>clusterNames</code>
   * @param {Object} data
   * @method getExistingClusterNamesSuccessCallBack
   */
  getExistingClusterNamesSuccessCallBack: function (data) {
    var clusterNames = data.items.mapProperty('Clusters.cluster_name');
    this.set('clusterNames', clusterNames);
  },

  /**
   * If error appears, set <code>clusterNames</code> to <code>[]</code>
   * @method getExistingClusterNamesErrorCallback
   */
  getExistingClusterNamesErrorCallback: function () {
    this.set('clusterNames', []);
  },

  /**
   * Delete cluster by name
   * One request for one cluster!
   * @param {string[]} clusterNames
   * @method deleteClusters
   */
  deleteClusters: function (clusterNames) {
    this.get('clusterDeleteErrorViews').clear();
    clusterNames.forEach(function (clusterName, index) {
      App.ajax.send({
        name: 'common.delete.cluster',
        sender: this,
        data: {
          name: clusterName,
          isLast: index === clusterNames.length - 1
        },
        success: 'deleteClusterSuccessCallback',
        error: 'deleteClusterErrorCallback'
      });
    }, this);

  },

  /**
   * Method to execute after successful cluster deletion
   * @method deleteClusterSuccessCallback
   */
  deleteClusterSuccessCallback: function () {
    this.incrementProperty('clusterDeleteRequestsCompleted');
    if (this.get('isAllClusterDeleteRequestsCompleted')) {
      if (this.get('clusterDeleteErrorViews.length')) {
        this.showDeleteClustersErrorPopup();
      } else {
        this.getExistingVersions();
      }
    }
  },

  /**
   * Method to execute after failed cluster deletion
   * @param {object} request
   * @param {string} ajaxOptions
   * @param {string} error
   * @param {object} opt
   * @method deleteClusterErrorCallback
   */
  deleteClusterErrorCallback: function (request, ajaxOptions, error, opt) {
    this.incrementProperty('clusterDeleteRequestsCompleted');
    try {
      var json = $.parseJSON(request.responseText);
      var message = json.message;
    } catch (err) {
    }
    this.get('clusterDeleteErrorViews').pushObject(App.AjaxDefaultErrorPopupBodyView.create({
      url: opt.url,
      type: opt.type,
      status: request.status,
      message: message
    }));
    if (this.get('isAllClusterDeleteRequestsCompleted')) {
      this.showDeleteClustersErrorPopup();
    }
  },

  /**
   * Show error popup if cluster deletion failed
   * @method showDeleteClustersErrorPopup
   */
  showDeleteClustersErrorPopup: function () {
    var self = this;
    this.setProperties({
      isSubmitDisabled: false,
      isBackBtnDisabled: false
    });
    App.ModalPopup.show({
      header: Em.I18n.t('common.error'),
      secondary: false,
      onPrimary: function () {
        this.hide();
      },
      bodyClass: Em.ContainerView.extend({
        childViews: self.get('clusterDeleteErrorViews')
      })
    });
  },

  /**
   * Get existing repo_versions
   * @method getExistingVersions
   */
  getExistingVersions: function () {
    return App.ajax.send({
      name: 'wizard.get_version_definitions',
      sender: this,
      success: 'getExistingVersionsSuccessCallback'
    });
  },

  /**
   * @param {Object} data
   * @method getExistingVersionsSuccessCallback
   */
  getExistingVersionsSuccessCallback: function (data) {
    if (this.get('isInstaller') && !App.get('testMode') && data.items.length) {
      this.set('existingRepositoryVersions', data.items.length);
      this.deleteExistingVersions(data.items);
    } else {
      this.startDeploy();
    }
  },

  /**
   * Delete existing repo_versions
   * @param {Array} versions
   * @method deleteExistingVersions
   */
  deleteExistingVersions: function (versions) {
    versions.forEach(function (version) {
      App.ajax.send({
        name: 'wizard.delete_repository_versions',
        sender: this,
        data: {
          id: version.VersionDefinition.id,
          stackName: version.VersionDefinition.stack_name,
          stackVersion: version.VersionDefinition.stack_version
        },
        success: 'deleteExistingVersionsSuccessCallback'
      });
    }, this);
  },

  /**
   * Method to execute after successful version deletion
   * @method deleteExistingVersionsSuccessCallback
   */
  deleteExistingVersionsSuccessCallback: function () {
    this.decrementProperty('existingRepositoryVersions');
    if (this.get('existingRepositoryVersions') === 0) {
      this.startDeploy();
    }
  },

  /**
   * updates kerberosDescriptorConfigs
   * @method updateKerberosDescriptor
   */
  updateKerberosDescriptor: function(instant) {
    var kerberosDescriptor = this.get('wizardController').getDBProperty('kerberosDescriptorConfigs');
    var descriptorExists = this.get('wizardController').getDBProperty('isClusterDescriptorExists') === true;

    var ajaxOpts = {
      name: descriptorExists ? 'admin.kerberos.cluster.artifact.update' : 'admin.kerberos.cluster.artifact.create',
      data: {
        artifactName: 'kerberos_descriptor',
        data: {
          artifact_data: kerberosDescriptor
        }
      }
    };
    if (instant) {
      ajaxOpts.sender = this;
      App.ajax.send(ajaxOpts);
    } else {
      this.addRequestToAjaxQueue(ajaxOpts);
    }
  },

  /**
   * Start deploy process
   * @method startDeploy
   */
  startDeploy: function () {
    this.createCluster();
    this.createServiceGroups();
    this.createSelectedServices();
    if (!this.get('isAddHost')) {
      if (this.get('isAddService')) {
        // for manually enabled Kerberos descriptor was updated on transition to this step
        if (App.get('isKerberosEnabled') && !this.get('isManualKerberos')) {
          this.updateKerberosDescriptor();
        }
        var fileNamesToUpdate = this.get('wizardController').getDBProperty('fileNamesToUpdate').uniq();
        if (fileNamesToUpdate && fileNamesToUpdate.length) {
          this.applyConfigurationsToCluster(this.generateDesiredConfigsJSON(this.get('configs'), fileNamesToUpdate));
        }
      }
      this.configureCluster();
      this.createServiceConfigurations();
      this.applyConfigurationsToCluster(this.get('serviceConfigTags'));
    }
    this.createComponents();
    this.registerHostsToCluster();
    this.createConfigurationGroups();
    this.createMasterHostComponents();
    this.createSlaveAndClientsHostComponents();
    if (this.get('isAddService')) {
      this.createAdditionalClientComponents();
    }
    this.createAdditionalHostComponents();

    this.set('ajaxQueueLength', this.get('ajaxRequestsQueue.queue.length'));
    this.get('ajaxRequestsQueue').start();
    this.showLoadingIndicator();
  },

  /**
   * *******************************************************************
   * The following create* functions are called upon submitting Step 8.
   * *******************************************************************
   */

  /**
   * Create cluster using selected stack version
   * Queued request
   * @method createCluster
   */
  createCluster: function () {
    if (!this.get('isInstaller')) return;
    const selectedStack = this.getSelectedStack()
    this.addRequestToAjaxQueue({
      name: 'wizard.step8.create_cluster',
      data: {
        data: JSON.stringify({ "Clusters": {"version": selectedStack.get('stackNameVersion')}})
      },
      success: 'createClusterSuccess'
    });
  },

  createClusterSuccess: function (data, xhr, params) {
    App.set('clusterName', params.cluster);
  },

  /**
   * Creates one service group per mpack.
   * Skip if no mpacks were selected.
   * Queued request
   * @method createServiceGroup
   */
  createServiceGroups: function () {
    if (!this.get('isInstaller')) return;
    
    var data = this.createServiceGroupsData();
    if (data) {
      this.addRequestToAjaxQueue({
        name: 'wizard.step8.create_service_group',
        data: {
          data: JSON.stringify(data)
        }
      });
    } 
  },

  /**
   * Format data for <code>createServiceGroups</code> request
   * @returns {Object[]}
   * @method createServiceGroupsData
   */
  createServiceGroupsData: function () {
    const mpacks = this.get('selectedMpacks');
    
    if (mpacks) {
      const serviceGroups = mpacks.map(mpack => ({
          "ServiceGroupInfo": {
            "service_group_name": `${mpack.name}-${mpack.version}`,
          }
        })
      );

      return serviceGroups;
    }

    return null;
  },

  /**
   * Create selected to install services
   * Queued request
   * Skipped if no services where selected!
   * @method createSelectedServices
   */
  createSelectedServices: function () {
    var data = this.createSelectedServicesData();
    if (!data.length) return;
    this.addRequestToAjaxQueue({
      name: 'wizard.step8.create_selected_services',
      data: {
        data: JSON.stringify(data)
      }
    });
  },

  /**
   * Format data for <code>createSelectedServices</code> request
   * @returns {Object[]}
   * @method createSelectedServicesData
   */
  createSelectedServicesData: function () {
    const services = this.get('selectedServices');
    const data = services.map(service => ({
        "ServiceInfo": {
          "service_name": service.get('serviceName'),
          "service_type": service.get('serviceName'),
          //TODO: mpacks - needs to be revisited when we are no longer hard coding service groups to be named 
          //               for mpacks and when the concept of a "selected stack" is no longer a thing
          "service_group_name": `${service.get('stackName')}-${service.get('stackVersion')}`,
          "desired_stack": `${service.get('stackName')}-${service.get('stackVersion')}`,
        }
      })
    );
    return data;
  },

  /**
   * Create components for selected services
   * Queued requests
   * One request for each service!
   * @method createComponents
   */
  createComponents: function () {
    var serviceComponents = App.StackServiceComponent.find();
    this.get('selectedServices').forEach(function (_service) {
      var serviceName = _service.get('serviceName');
      var componentsData = serviceComponents.filterProperty('serviceName', serviceName).map(function (_component) {
        return { "ServiceComponentInfo": { "component_name": _component.get('componentName') } };
      });

      // Service must be specified in terms of a query for creating multiple components at the same time.
      // See AMBARI-1018.
      this.addRequestToCreateComponent(componentsData, serviceName);
    }, this);

    if (this.get('isAddHost')) {
      var allServiceComponents = [];
      var services = App.Service.find().mapProperty('serviceName');
      services.forEach(function(_service){
        var _serviceComponents = App.Service.find(_service).get('serviceComponents');
        allServiceComponents = allServiceComponents.concat(_serviceComponents);
      }, this);
      this.get('content.slaveComponentHosts').forEach(function (component) {
        if (component.componentName !== 'CLIENT' && !allServiceComponents.contains(component.componentName)) {
          this.addRequestToCreateComponent(
              [{"ServiceComponentInfo": {"component_name": component.componentName}}],
              App.StackServiceComponent.find().findProperty('componentName', component.componentName).get('serviceName')
          );
        }
      }, this);
      this.get('content.clients').forEach(function (component) {
        if (!allServiceComponents.contains(component.component_name)) {
          this.addRequestToCreateComponent(
              [{"ServiceComponentInfo": {"component_name": component.component_name}}],
              App.StackServiceComponent.find().findProperty('componentName', component.component_name).get('serviceName')
          );
        }
      }, this);
    }
  },

  /**
   * Add request to ajax queue to create service component
   * @param componentsData
   * @param serviceName
   */
  addRequestToCreateComponent: function (componentsData, serviceName) {
    this.addRequestToAjaxQueue({
      name: 'wizard.step8.create_components',
      data: {
        data: JSON.stringify(componentsData),
        serviceName: serviceName
      }
    });
  },

  /**
   * Error callback for new service component request
   * So, if component doesn't exist we should create it
   * @param {object} request
   * @param {object} ajaxOptions
   * @param {string} error
   * @param {object} opt
   * @param {object} params
   * @method newServiceComponentErrorCallback
   */
  newServiceComponentErrorCallback: function (request, ajaxOptions, error, opt, params) {
    this.addRequestToAjaxQueue({
      name: 'wizard.step8.create_components',
      data: {
        serviceName: params.serviceName,
        data: JSON.stringify({
          "components": [
            {
              "ServiceComponentInfo": {
                "component_name": params.componentName
              }
            }
          ]
        })
      }
    });
  },

  /**
   * Register hosts
   * Queued request
   * @method registerHostsToCluster
   */
  registerHostsToCluster: function () {
    var data = this.createRegisterHostData();
    if (!data.length) return;
    this.addRequestToAjaxQueue({
      name: 'wizard.step8.register_host_to_cluster',
      data: {
        data: JSON.stringify(data)
      }
    });
  },

  /**
   * Format request-data for <code>registerHostsToCluster</code>
   * @returns {Object}
   * @method createRegisterHostData
   */
  createRegisterHostData: function () {
    return this.getRegisteredHosts().filterProperty('isInstalled', false).map(function (host) {
      return {"Hosts": { "host_name": host.hostName}};
    });
  },

  /**
   * Register new master components
   * @uses registerHostsToComponent
   * @method createMasterHostComponents
   */
  createMasterHostComponents: function () {
    var masterOnAllHosts = [];

    this.get('content.services').filterProperty('isSelected').forEach(function (service) {
      service.get('serviceComponents').filterProperty('isRequiredOnAllHosts').forEach(function (component) {
        if (component.get('isMaster')) {
          masterOnAllHosts.push(component.get('componentName'));
        }
      }, this);
    }, this);

    // create master components for only selected services.
    var selectedMasterComponents = this.get('content.masterComponentHosts').filter(function (_component) {
      return this.get('selectedServices').mapProperty('serviceName').contains(_component.serviceId)
    }, this);
    selectedMasterComponents.mapProperty('component').uniq().forEach(function (component) {
      var hostNames = [];
      if (masterOnAllHosts.length > 0) {
        var compOnAllHosts = false;
        for (var i=0; i < masterOnAllHosts.length; i++) {
          if (component === masterOnAllHosts[i]) {
            compOnAllHosts = true;
            break;
          }
        }
        if (!compOnAllHosts) {
          hostNames = selectedMasterComponents.filterProperty('component', component).filterProperty('isInstalled', false).mapProperty('hostName');
          this.registerHostsToComponent(hostNames, component);
        }
      } else {
        hostNames = selectedMasterComponents.filterProperty('component', component).filterProperty('isInstalled', false).mapProperty('hostName');
        this.registerHostsToComponent(hostNames, component);
      }
    }, this);
  },

  getClientsMap: function (flag) {
    var clients = App.StackServiceComponent.find().filterProperty('isClient'),
      clientsMap = {},
      dependedComponents = flag ? App.StackServiceComponent.find().filterProperty(flag) : App.StackServiceComponent.find();
    clients.forEach(function (client) {
      var clientName = client.get('componentName');
      clientsMap[clientName] = Em.A([]);
      dependedComponents.forEach(function (component) {
        if (component.dependsOn(client))
          clientsMap[clientName].push(component.get('componentName'));
      });
      if (!clientsMap[clientName].length) delete clientsMap[clientName];
    });
    return clientsMap;
  },

  /**
   * Register slave components and clients
   * @uses registerHostsToComponent
   * @method createSlaveAndClientsHostComponents
   */
  createSlaveAndClientsHostComponents: function () {
    var masterHosts = this.get('content.masterComponentHosts');
    var slaveHosts = this.get('content.slaveComponentHosts');
    var clients = this.get('content.clients').filterProperty('isInstalled', false);
    var slaveOnAllHosts = [];
    var clientOnAllHosts = [];

    this.get('content.services').filterProperty('isSelected').forEach(function (service) {
      service.get('serviceComponents').filterProperty('isRequiredOnAllHosts').forEach(function (component) {
        if (component.get('isClient')) {
          clientOnAllHosts.push(component.get('componentName'));
        } else if (component.get('isSlave')) {
          slaveOnAllHosts.push(component.get('componentName'));
        }
      }, this);
    }, this);

    /**
     * Determines on which hosts client should be installed (based on availability of master components on hosts)
     * @type {Object}
     * Format:
     * <code>
     *  {
     *    CLIENT1: Em.A([MASTER1, MASTER2, ...]),
     *    CLIENT2: Em.A([MASTER3, MASTER1, ...])
     *    ...
     *  }
     * </code>
     */
    var clientsToMasterMap = this.getClientsMap('isMaster'),
        clientsToSlaveMap = this.getClientsMap('isSlave');

    slaveHosts.forEach(function (_slave) {
      var hostNames = [];
      var compOnAllHosts;
      if (_slave.componentName !== 'CLIENT') {
        if (slaveOnAllHosts.length > 0) {
          compOnAllHosts = false;
          for (var i=0; i < slaveOnAllHosts.length; i++) {
            if (_slave.componentName === slaveOnAllHosts[i]) {
              // component with ALL cardinality should not
              // registerHostsToComponent in createSlaveAndClientsHostComponents
              compOnAllHosts = true;
              break;
            }
          }
          if (!compOnAllHosts) {
            hostNames = _slave.hosts.filterProperty('isInstalled', false).mapProperty('hostName');
            this.registerHostsToComponent(hostNames, _slave.componentName);
          }
        } else {
          hostNames = _slave.hosts.filterProperty('isInstalled', false).mapProperty('hostName');
          this.registerHostsToComponent(hostNames, _slave.componentName);
        }
      }
      else {
        clients.forEach(function (_client) {
          hostNames = _slave.hosts.mapProperty('hostName');
          // The below logic to install clients to existing/New master hosts should not be applied to Add Host wizard.
          // This is with the presumption that Add Host controller does not add any new Master component to the cluster
          if (!this.get('isAddHost')) {
            if (clientsToMasterMap[_client.component_name]) {
              clientsToMasterMap[_client.component_name].forEach(function (componentName) {
                masterHosts.filterProperty('component', componentName).forEach(function (_masterHost) {
                  hostNames.pushObject(_masterHost.hostName);
                });
              });
            }
          }
          if (clientsToSlaveMap[_client.component_name]) {
            clientsToSlaveMap[_client.component_name].forEach(function (componentName) {
              slaveHosts.filterProperty('componentName', componentName).forEach(function (slaveHost) {
                hostNames = hostNames.concat(slaveHost.hosts.mapProperty('hostName')).uniq();
              });
            });
          }
          if (clientOnAllHosts.length > 0) {
            compOnAllHosts = false;
            for (var i=0; i < clientOnAllHosts.length; i++) {
              if (_client.component_name === clientOnAllHosts[i]) {
                // component with ALL cardinality should not
                // registerHostsToComponent in createSlaveAndClientsHostComponents
                compOnAllHosts = true;
                break;
              }
            }
            if (!compOnAllHosts) {
              hostNames = hostNames.uniq();
              this.registerHostsToComponent(hostNames, _client.component_name);
            }
          } else {
            hostNames = hostNames.uniq();
            this.registerHostsToComponent(hostNames, _client.component_name);
          }
        }, this);
      }
    }, this);
  },

  /**
   * This function is specific to addServiceController
   * Newly introduced master components requires some existing client components to be hosted along with them
   */
  createAdditionalClientComponents: function () {
    var masterHosts = this.get('content.masterComponentHosts');
    var clientHosts = [];
    if (this.get('content.slaveComponentHosts').someProperty('componentName', 'CLIENT')) {
      clientHosts = this.get('content.slaveComponentHosts').findProperty('componentName', 'CLIENT').hosts;
    }
    var clients = this.get('content.clients').filterProperty('isInstalled', false);
    var clientsToMasterMap = this.getClientsMap('isMaster');
    var clientsToClientMap = this.getClientsMap('isClient');
    var installedClients = [];

    // Get all the installed Client components
    this.get('content.services').filterProperty('isInstalled').forEach(function (_service) {
      var serviceClients = App.StackServiceComponent.find().filterProperty('serviceName', _service.get('serviceName')).filterProperty('isClient');
      serviceClients.forEach(function (client) {
        installedClients.push(client.get('componentName'));
      }, this);
    }, this);

    // Check if there is a dependency for being co-hosted between existing client and selected new master
    installedClients.forEach(function (_clientName) {
      if (clientsToMasterMap[_clientName] || clientsToClientMap[_clientName]) {
        var hostNames = [];
        if (clientsToMasterMap[_clientName]) {
          clientsToMasterMap[_clientName].forEach(function (componentName) {
            masterHosts.filterProperty('component', componentName).filterProperty('isInstalled', false).forEach(function (_masterHost) {
              hostNames.pushObject(_masterHost.hostName);
            }, this);
          }, this);
        }
        if (clientsToClientMap[_clientName]) {
          clientsToClientMap[_clientName].forEach(function (componentName) {
            clientHosts.forEach(function (_clientHost) {
              var host = this.get('content.hosts')[_clientHost.hostName];
              var isClientSelected = clients.someProperty('component_name', componentName);
              if (host.isInstalled && isClientSelected && !host.hostComponents.someProperty('HostRoles.component_name', componentName)) {
                hostNames.pushObject(_clientHost.hostName);
              }
            }, this);
          }, this);
        }
        hostNames = hostNames.uniq();
        if (hostNames.length > 0) {
          // If a dependency for being co-hosted is derived between existing client and selected new master but that
          // dependency is already satisfied in the cluster then disregard the derived dependency
          this.removeClientsFromList(_clientName, hostNames);
          this.registerHostsToComponent(hostNames, _clientName);
          if(hostNames.length > 0) {
            this.get('content.additionalClients').pushObject({hostNames: hostNames, componentName: _clientName});
          }
        }
      }
    }, this);
  },

  /**
   *
   * @param clientName
   * @param hostList
   */
  removeClientsFromList: function (clientName, hostList) {
    var clientHosts = [];
    var installedHosts = this.get('content.hosts');
    for (var hostName in installedHosts) {
      if (installedHosts[hostName].isInstalled) {
        if (installedHosts[hostName].hostComponents.mapProperty('HostRoles.component_name').contains(clientName)) {
          clientHosts.push(hostName);
        }
      }
    }

    if (clientHosts.length > 0) {
      clientHosts.forEach(function (hostName) {
        if (hostList.contains(hostName)) {
          hostList.splice(hostList.indexOf(hostName), 1);
        }
      }, this);
    }
  },

  /**
   * Register additional components
   * Based on availability of some services
   * @uses registerHostsToComponent
   * @method createAdditionalHostComponents
   */
  createAdditionalHostComponents: function () {
    var masterHosts = this.get('content.masterComponentHosts');

    // add all components with cardinality == ALL of selected services
    var registeredHosts = this.getRegisteredHosts();
    var notInstalledHosts = registeredHosts.filterProperty('isInstalled', false);
    this.get('content.services').filterProperty('isSelected').forEach(function (service) {
      service.get('serviceComponents').filterProperty('isRequiredOnAllHosts').forEach(function (component) {
        if (service.get('isInstalled') && notInstalledHosts.length) {
          this.registerHostsToComponent(notInstalledHosts.mapProperty('hostName'), component.get('componentName'));
        } else if (!service.get('isInstalled') && registeredHosts.length) {
          this.registerHostsToComponent(registeredHosts.mapProperty('hostName'), component.get('componentName'));
        }
      }, this);
    }, this);

    // add MySQL Server if Hive is selected
    var hiveService = this.get('content.services').filterProperty('isSelected', true).filterProperty('isInstalled', false).findProperty('serviceName', 'HIVE');
    if (hiveService) {
      var hiveDb = this.get('content.serviceConfigProperties').findProperty('name', 'hive_database');
      if (hiveDb.value === "New MySQL Database") {
        this.registerHostsToComponent(masterHosts.filterProperty('component', 'HIVE_SERVER').mapProperty('hostName'), 'MYSQL_SERVER');
      } else if (hiveDb.value === "New PostgreSQL Database") {
        this.registerHostsToComponent(masterHosts.filterProperty('component', 'HIVE_SERVER').mapProperty('hostName'), 'POSTGRESQL_SERVER');
      }
    }
  },

  /**
   * Register component to hosts
   * Queued request
   * @param {String[]} hostNames
   * @param {String} componentName
   * @method registerHostsToComponent
   */
  registerHostsToComponent: function (hostNames, componentName) {
    if (!hostNames.length) return;

    let serviceName,
        serviceGroupName;
    var queryStr = '';
    hostNames.forEach(function (hostName) {
      queryStr += 'Hosts/host_name=' + hostName + '|';
    });
    //slice off last symbol '|'
    queryStr = queryStr.slice(0, -1);

    this.get('selectedServices').forEach( function (service) {
      if (service.get('serviceComponents').findProperty('componentName', componentName)) {
        serviceName = service.get('serviceName');
        serviceGroupName = service.get('stackName') + "-" + service.get('stackVersion');
      }
    });

    var data = {
      "RequestInfo": {
        "query": queryStr
      },
      "Body": {
        "host_components": [
          {
            "HostRoles": {
              "component_name": componentName,
              "service_name": serviceName,
              "service_group_name": serviceGroupName
            }
          }
        ]
      }
    };

    this.addRequestToAjaxQueue({
      name: 'wizard.step8.register_host_to_component',
      data: {
        data: JSON.stringify(data)
      }
    });
  },

  /**
   * Configure cluster settings
   */
  configureCluster: function () {
    const clusterSettings = this.get('configs').filterProperty('filename', 'cluster-settings.xml');
    const data = [];
    clusterSettings.forEach(setting => {
      data.push({
        "ClusterSettingInfo": {
          "cluster_setting_name": setting.name,
          "cluster_setting_value": setting.value
        }
      })
    });

    this.addRequestToAjaxQueue({
      name: 'common.cluster.settings',
      data: {
        clusterName: this.get('clusterName'),
        data: data
      }
    });
  },

  /**
   * Create config objects for services
   * @method createServiceConfigurations
   */
  createServiceConfigurations: function () {
    this.get('selectedServices').forEach(function (service) {
      Object.keys(service.get('configTypes')).forEach(function (type) {
        if (!this.get('serviceConfigTags').someProperty('type', type)) {
          var configs = this.get('configs').filterProperty('filename', App.config.getOriginalFileName(type));
          var serviceConfigNote = this.getServiceConfigNote(type, service.get('displayName'));
          this.get('serviceConfigTags').pushObject(this.createDesiredConfig(type, configs, serviceConfigNote));
        }
      }, this);
    }, this);
    this.createNotification();
  },

  /**
   * Get config version message
   *
   * @param type
   * @param serviceDisplayName
   * @returns {*}
   */
  getServiceConfigNote: function(type, serviceDisplayName) {
    return this.get('isAddService') && type === 'core-site' ?
      Em.I18n.t('dashboard.configHistory.table.notes.addService') : Em.I18n.t('dashboard.configHistory.table.notes.default').format(serviceDisplayName);
  },

  /**
   * Send <code>serviceConfigTags</code> to server
   * Queued request
   * One request for each service config tag
   * @param serviceConfigTags
   * @method applyConfigurationsToCluster
   */
  applyConfigurationsToCluster: function (serviceConfigTags) {
    var allServices = this.get('installedServices').concat(this.get('selectedServices'));
    
    allServices.forEach(function (service) {
      var serviceConfigData = [];
     
      Object.keys(service.get('configTypesRendered')).forEach(function (type) {
        var serviceConfigTag = serviceConfigTags.findProperty('type', type);
        if (serviceConfigTag) {
          serviceConfigData.pushObject(serviceConfigTag);
        }
      }, this);
      
      if (serviceConfigData.length) {
        //TODO: Remove this delete call when the API supports service_config_version_note
        serviceConfigData.forEach(scd => {
          delete scd.service_config_version_note;
        })

        this.addRequestToAjaxQueue({
          name: 'common.service.create.configs',
          data: {
            serviceName: service.get('serviceName'),
            serviceGroupName: `${service.get('stackName')}-${service.get('stackVersion')}`,
            data: serviceConfigData
          }
        });    
      }
    }, this);
  },

  /**
   * Create and update config groups
   * @method createConfigurationGroups
   */
  createConfigurationGroups: function () {
    var configGroups = this.get('content.configGroups').filterProperty('is_default', false);
    var groupsToDelete = App.router.get(this.get('content.controllerName')).getDBProperty('groupsToDelete');
    if (groupsToDelete && groupsToDelete.length > 0) {
      this.removeInstalledServicesConfigurationGroups(groupsToDelete);
    }
    configGroups.forEach(function (configGroup) {
      if (configGroup.is_for_update || configGroup.is_temporary) {
        this.saveGroup(configGroup.properties, configGroup, this.getServiceConfigNote('', configGroup.service_id));
      }
    }, this);
    App.ServiceConfigGroup.deleteTemporaryRecords();
  },

  /**
   * add request to create config group to queue
   *
   * @param data
   * @method createConfigGroup
   */
  createConfigGroup: function(data) {
    this.addRequestToAjaxQueue({
      name: 'wizard.step8.apply_configuration_groups',
      sender: this,
      data: {
        data: JSON.stringify(data)
      }
    });
  },

  /**
   * add request to update config group to queue
   *
   * @param data {Object}
   * @method updateConfigGroup
   */
  updateConfigGroup: function (data) {
    this.addRequestToAjaxQueue({
      name: 'config_groups.update_config_group',
      sender: this,
      data: {
        id: data.ConfigGroup.id,
        configGroup: data
      }
    });
  },

  /**
   * Delete selected config groups
   * @param {Object[]} groupsToDelete
   * @method removeInstalledServicesConfigurationGroups
   */
  removeInstalledServicesConfigurationGroups: function (groupsToDelete) {
    var self = this;
    groupsToDelete.forEach(function (item) {
      self.deleteConfigurationGroup(Em.Object.create(item));
    });
  },

  /**
   * Selected and installed services
   * @override
   */
  currentServices: function() {
    return this.get('installedServices').concat(this.get('selectedServices'));
  }.property('installedServices.length', 'selectedServices.length'),

  /**
   * Add handling GLUSTREFS properties
   * @param property
   * @returns {*}
   * @override
   */
  formatValueBeforeSave: function(property) {
    if (this.formatGLUSTERFSProperties(Em.get(property, 'filename'))) {
      switch (property.name) {
        case "fs.default.name":
          return this.get('configs').someProperty('name', 'fs_glusterfs_default_name') ?
            this.get('configs').findProperty('name', 'fs_glusterfs_default_name').value : null;
        case "fs.defaultFS":
          return this.get('configs').someProperty('name', 'glusterfs_defaultFS_name') ?
            this.get('configs').findProperty('name', 'glusterfs_defaultFS_name').value : null;
      }
    }
    return this._super(property);
  },

  /**
   * Defines if some GLUSTERFS properties should be changed
   *
   * @param {String} type
   * @returns {boolean}
   */
  formatGLUSTERFSProperties: function(type) {
    return App.config.getConfigTagFromFileName(type) === 'core-site'
      && this.get('installedServices').concat(this.get('selectedServices')).someProperty('serviceName', 'GLUSTERFS');
  },


  /**
   * Create one Alert Notification (if user select this on step7)
   * Only for Install Wizard and stack
   * @method createNotification
   */
  createNotification: function () {
    if (!this.get('isInstaller')) return;
    var miscConfigs = this.get('configs').filterProperty('serviceName', 'MISC'),
      createNotification = miscConfigs.findProperty('name', 'create_notification').value;
    if (createNotification !== 'yes') return;
      var predefinedNotificationConfigNames = require('data/configs/alert_notification').mapProperty('name'),
      configsForNotification = this.get('configs').filterProperty('filename', 'alert_notification');
    var properties = {},
      names = [
        'ambari.dispatch.recipients',
        'mail.smtp.host',
        'mail.smtp.port',
        'mail.smtp.from',
        'mail.smtp.starttls.enable',
        'mail.smtp.startssl.enable'
      ];
    if (miscConfigs.findProperty('name', 'smtp_use_auth').value == 'true') { // yes, it's not converted to boolean
      names.pushObjects(['ambari.dispatch.credential.username', 'ambari.dispatch.credential.password']);
    }

    names.forEach(function (name) {
      properties[name] = miscConfigs.findProperty('name', name).value;
    });

    properties['ambari.dispatch.recipients'] = properties['ambari.dispatch.recipients'].replace(/\s/g, '').split(',');

    configsForNotification.forEach(function (config) {
      if (predefinedNotificationConfigNames.contains(config.name)) return;
      properties[config.name] = config.value;
    });

    var apiObject = {
      AlertTarget: {
        name: 'Initial Notification',
        description: 'Notification created during cluster installing',
        global: true,
        notification_type: 'EMAIL',
        alert_states: ['OK', 'WARNING', 'CRITICAL', 'UNKNOWN'],
        properties: properties
      }
    };
    this.addRequestToAjaxQueue({
      name: 'alerts.create_alert_notification',
      data: {
        urlParams: 'overwrite_existing=true',
        data: apiObject
      }
    });
  },

  /**
   * Should ajax-queue progress bar be displayed
   * @method showLoadingIndicator
   */
  showLoadingIndicator: function () {
    return App.ModalPopup.show({

      header: '',

      showFooter: false,

      showCloseButton: false,

      bodyClass: Em.View.extend({

        templateName: require('templates/wizard/step8/step8_log_popup'),

        controllerBinding: 'App.router.wizardStep8Controller',

        /**
         * Css-property for progress-bar
         * @type {string}
         */
        barWidth: '',
        progressBarClass: 'progress log_popup',

        /**
         * Popup-message
         * @type {string}
         */
        message: '',

        /**
         * Set progress bar width and popup message when ajax-queue requests are processed
         * @method ajaxQueueChangeObs
         */
        ajaxQueueChangeObs: function () {
          var length = this.get('controller.ajaxQueueLength');
          var left = this.get('controller.ajaxRequestsQueue.queue.length');
          this.set('barWidth', 'width: ' + (length - left) / length * 100 + '%;');
          this.set('message', Em.I18n.t('installer.step8.deployPopup.message').format(length - left, length));
        }.observes('controller.ajaxQueueLength', 'controller.ajaxRequestsQueue.queue.length'),

        /**
         * Hide popup when ajax-queue is finished
         * @method autoHide
         */
        autoHide: function () {
          if (this.get('controller.servicesInstalled')) {
            this.get('parentView').hide();
          }
        }.observes('controller.servicesInstalled'),

        ajaxQueueErrorAppears: function () {
          if (this.get('controller.hasErrorOccurred')) {
            this.get('parentView').onClose();
          }
        }.observes('controller.hasErrorOccurred')

      })

    });
  },

  getComponentsForHost: function(host) {
    if(!host.hostComponents) {
      App.router.get('installerController').get('allHosts');
    }
    var componentNameDetail = [];
    host.hostComponents.mapProperty('componentName').forEach(function (componentName) {
      if(componentName === 'CLIENT') {
        this.get('content.clients').mapProperty('component_name').forEach(function (clientComponent) {
          componentNameDetail.push({ name : clientComponent });
        }, this);
        return;
      }
      componentNameDetail.push({ name : componentName });
    }, this);
    return componentNameDetail;
  },

  getPropertyAttributesForConfigType : function(configs) {
    //Currently only looks for final properties, if any
    var finalProperties = configs.filterProperty('isFinal', 'true');
    var propertyAttributes = {};
    finalProperties.forEach(function (finalProperty) {
      propertyAttributes[finalProperty['name']] = "true";
    });
    var finalPropertyMap = {};
    if (!App.isEmptyObject(finalProperties)) {
      finalPropertyMap = {
        "isFinal": propertyAttributes
      };
    }
    return finalPropertyMap;
  },

  getConfigurationDetailsForConfigType: function(configs) {
    var configDetails = {};
    var self = this;
    configs.forEach(function (propertyObj) {
      configDetails[propertyObj['name']] = propertyObj['value'];
    }, this);
    var configurationsDetails = {
      "properties_attributes": self.getPropertyAttributesForConfigType(configs),
      "properties": configDetails
    };
    return configurationsDetails;
  },

  hostInExistingHostGroup: function (newHost, host_groups) {
    var hostGroupMatched = false;
      host_groups.some(function (existingHostGroup) {
        if(!hostGroupMatched) {
        var fqdnInHostGroup =  existingHostGroup.hosts[0].fqdn;
        var componentsInExistingHostGroup = this.getRegisteredHosts().filterProperty('hostName', fqdnInHostGroup)[0].hostComponents;
        if(componentsInExistingHostGroup.length !== newHost.hostComponents.length) {
          return;
        } else {
          var componentMismatch = false;
          componentsInExistingHostGroup.forEach(function (componentInExistingHostGroup, index) {
          if(!componentMismatch) {
            if(!newHost.hostComponents.mapProperty('componentName').includes(componentInExistingHostGroup.componentName)) {
              componentMismatch = true;
            }
          }
          });
          if(!componentMismatch) {
            hostGroupMatched = true;
            existingHostGroup["cardinality"] = parseInt(existingHostGroup["cardinality"]) + 1;
            existingHostGroup.hosts.push({"fqdn" : newHost.hostName});
            return true;
          }
        }
        }
      }, this);
    return hostGroupMatched;
  },

   hostInChildHostGroup: function (presentHostGroup, configGroupName, hostInConfigGroup) {
    return  presentHostGroup['childHostGroups'].some(function (childHostGroup) {
      //Check if childHostGroup name is same as this configgroupname, if yes, update childHostGroup else, compare with other childhostgroups
      if(childHostGroup.configGroupName === configGroupName) {
        childHostGroup.hosts.push( { "fqdn" : hostInConfigGroup } );
        childHostGroup['cardinality'] = childHostGroup['cardinality'] + 1;
        return true;
      }
      });
  },

  /**
   * Confirmation popup before generate blueprint
   */
  generateBlueprintConfirmation: function () {
    var self = this;
    return App.showConfirmationPopup(function () {
      self.generateBlueprint();
      }, Em.I18n.t('installer.step8.generateBlueprint.popup.msg').format(App.clusterStatus.clusterName)
    );
  },

  generateBlueprint: function () {
    console.log("Prepare blueprint for download...");
    var blueprint = {};
    var self = this;
    //service configurations
    var totalConf = [];
    //Add cluster-env
    var clusterEnv = this.get('configs').filterProperty('filename', 'cluster-settings.xml');
    var configurations = {};
    configurations["cluster-env"] = self.getConfigurationDetailsForConfigType(clusterEnv);
    totalConf.push(configurations);
    //Add configurations for selected services
    this.get('selectedServices').forEach(function (service) {
      Object.keys(service.get('configTypes')).forEach(function (type) {
        if (!this.get('serviceConfigTags').someProperty('type', type)) {
          var configs = this.get('configs').filterProperty('filename', App.config.getOriginalFileName(type));
          var configurations = {};
          configurations[type] = self.getConfigurationDetailsForConfigType(configs);
          totalConf.push(configurations);
        }
      }, this);
    }, this);

    var host_groups = [];
    var cluster_template_host_groups = [];
    var counter = 0;

    this.getRegisteredHosts().filterProperty('isInstalled', false).map(function (host) {
      if(self.hostInExistingHostGroup(host, host_groups)) {
        return;
      }
      //Create new host_group if host is not mapped to existing host_groups
      var hostGroupId = "host_group_" + counter;
      var hostListForGroup = [];
      hostListForGroup.push({ "fqdn": host.hostName });
      var hostGroupDetail = {
        "name": hostGroupId,
        "components": self.getComponentsForHost(host),
        "hosts": hostListForGroup,
        "cardinality" : 1
      };
      hostGroupDetail.toJSON = function () {
        var hostGroupDetailResult = _.omit(this, [ "hosts", "childHostGroups" ]);
        hostGroupDetailResult["cardinality"] = this["cardinality"].toString();
        return hostGroupDetailResult;
      };
      host_groups.push(hostGroupDetail);

      var clusterTemplateHostGroupDetail = {
        "name": hostGroupId,
        "hosts": hostListForGroup
      };

      cluster_template_host_groups.push(clusterTemplateHostGroupDetail);
      counter++;
    }, this);

    this.get('content.configGroups').filterProperty("is_default", false).forEach(function (configGroup) {
      if (configGroup.properties.length == 0) {
        return;
      }
      configGroup.hosts.forEach(function (hostInConfigGroup) {
        return host_groups.some(function (presentHostGroup) {
          return presentHostGroup.hosts.some(function (hostInPresentHostGroup, index) {
            if (hostInConfigGroup !== hostInPresentHostGroup.fqdn) {
              return;
            }
            //Check if childHostGroup already created
            if (presentHostGroup['childHostGroups']) {
             if (self.hostInChildHostGroup(presentHostGroup, configGroup.name, hostInConfigGroup)) {
               // Update to remove parentHostGroup as all the hosts are added to childHostGroup/s
               presentHostGroup.hosts.splice(index, 1);
               presentHostGroup["cardinality"] = presentHostGroup['cardinality'] - 1;
               return true;
             }
            }
            //create configuration object
            var hgConfigurations;
            if(presentHostGroup.hosts.length === 1 && presentHostGroup["configurations"]) {
              hgConfigurations = presentHostGroup["configurations"][0];
            } else if (presentHostGroup["configurations"]) { //Deep copy
                hgConfigurations = jQuery.extend(true, {}, presentHostGroup["configurations"][0]);
            } else {
                hgConfigurations = {};
            }
            configGroup.properties.forEach(function (hgProperties) {
              var type = App.config.getConfigTagFromFileName(hgProperties.filename);
              if (!hgConfigurations[type]) {
                hgConfigurations[type] = { properties: {} };
              }
              hgConfigurations[type]['properties'][hgProperties.name] = hgProperties.value;
            });
            var totalHgConf = [];
            totalHgConf.push(hgConfigurations);
            //If only host in presentHostGroup then merge configuration and return
            if (presentHostGroup.hosts.length === 1) {
              //If host_group already has configuration, assigned from previously processed config_group
              if(!presentHostGroup["configurations"]) {
                presentHostGroup["configurations"] = totalHgConf;
              }
              return true;
            }

            //Create new host_group from this host
            var hostGroupId = "host_group_" + counter;
            counter++;
            var hostListForGroup = [];
            hostListForGroup.push({ "fqdn": hostInPresentHostGroup.fqdn });
            var hostGroupDetail = {
              "name": hostGroupId,
              "components": presentHostGroup.components,
              "cardinality": 1,
              "hosts": hostListForGroup,
              "configurations": totalHgConf,
              "configGroupName": configGroup.name
            };
            hostGroupDetail.toJSON = function () {
              var hostGroupDetailResult = _.omit(this, [ "hosts", "configGroupName", "childHostGroups" ]);
              hostGroupDetailResult["cardinality"] = this["cardinality"].toString();
              return hostGroupDetailResult;
            };
            host_groups.push(hostGroupDetail);
            //Update for clustertemplate file
            var clusterTemplateHostGroupDetail = {
              "name": hostGroupId,
              "hosts": hostListForGroup
            };
            cluster_template_host_groups.push(clusterTemplateHostGroupDetail);
            //Add newly created host_group as child to existing host_group
            if (!presentHostGroup['childHostGroups']) {
              presentHostGroup['childHostGroups'] = [];
            }
            presentHostGroup['childHostGroups'].push(hostGroupDetail);
            presentHostGroup.hosts.splice(index, 1);
            presentHostGroup["cardinality"] = presentHostGroup['cardinality'] - 1;
            //return true to indicate that host has been matched
            return true;
          }, this);
        }, this);
      }, this);
    }, this);

    var selectedStack = this.getSelectedStack();
    blueprint = {
        'configurations': totalConf,
        'host_groups': host_groups.filter(function (item) { return item.cardinality > 0; }),
        'Blueprints': {'blueprint_name' : App.clusterStatus.clusterName, 'stack_name':selectedStack.get('stackName'), 'stack_version':selectedStack.get('stackVersion')}
    };
    fileUtils.downloadTextFile(JSON.stringify(blueprint), 'json', 'blueprint.json')

    var cluster_template = {
      "blueprint": App.clusterStatus.clusterName,
      "config_recommendation_strategy" : "NEVER_APPLY",
      "provision_action" : "INSTALL_AND_START",
      "configurations": [],
      "host_groups": cluster_template_host_groups.filter(function (item) { return item.hosts.length > 0; }),
      "Clusters": {'cluster_name': App.clusterStatus.clusterName}
    };
    fileUtils.downloadTextFile(JSON.stringify(cluster_template), 'json', 'clustertemplate.json')
  },

  downloadCSV: function() {
    App.router.get('kerberosWizardStep5Controller').getCSVData(false);
  }
});