/**
 * 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 blueprintUtils = require('utils/blueprint');
var numberUtils = require('utils/number_utils');
var validationUtils = require('utils/validator');

/**
 * Mixin for assign master-to-host step in wizards
 * Implements basic logic of assign masters page
 * Should be used with controller linked with App.AssignMasterComponentsView
 * @type {Ember.Mixin}
 */
App.AssignMasterComponents = Em.Mixin.create({

  /**
   * Array of master component names to show on the page
   * By default is empty, this means that masters of all selected services should be shown
   * @type {Array}
   */
  mastersToShow: [],

  /**
   * Array of master component names to show on the service config assign master page
   * @type {Array}
   */
  mastersToCreate: [],

  /**
   * Array of master component names to add for install
   * @type {Array}
   */
  mastersToAdd: [],

  /**
   * Array of master component names, that are already installed, but should have ability to change host
   * @type {Array}
   */
  mastersToMove: [],

  /**
   * Array of master component names, that should be addable
   * Are used in HA wizards to add components, that are not addable for other wizards
   * @type {Array}
   */
  mastersAddableInHA: [],

  /**
   * Array of master component names to show 'Current' prefix in label before component name
   * Prefix will be shown only for installed instances
   * @type {Array}
   */
  showCurrentPrefix: [],

  /**
   * Array of master component names to show 'Additional' prefix in label before component name
   * Prefix will be shown only for not installed instances
   * @type {Array}
   */
  showAdditionalPrefix: [],

  /**
   * Array of objects with label and host keys to show specific hosts on the page
   * @type {Array}
   * format:
   * [
   *   {
   *     label: 'Current',
   *     host: 'c6401.ambari.apache.org'
   *   },
   *   {
   *     label: 'Additional',
   *     host: function () {
   *       return 'c6402.ambari.apache.org';
   *     }.property()
   *   }
   * ]
   */
  additionalHostsList: [],

  /**
   * Define whether show already installed masters first
   * @type {Boolean}
   */
  showInstalledMastersFirst: false,

  /**
   * Map of component name to list of hostnames for that component
   * format:
   * {
   *   NAMENODE: [
   *     'c6401.ambari.apache.org'
   *   ],
   *   DATANODE: [
   *     'c6402.ambari.apache.org',
   *     'c6403.ambari.apache.org',
   *   ]
   * }
   * @type {Object}
   */
  recommendedHostsForComponents: {},

  recommendations: null,

  markSavedComponentsAsInstalled: false,

  /**
   * @type {boolean}
   * @default false
   */
  validationInProgress: false,

  /**
   * run validation call which was skipped
   * validation should be always ran after last change
   * @type {boolean}
   * @default false
   */
  runQueuedValidation: false,

  /**
   * Array of <code>servicesMasters</code> objects, that will be shown on the page
   * Are filtered using <code>mastersToShow</code>
   * @type {Array}
   */
  servicesMastersToShow: function () {
    var mastersToShow = this.get('mastersToShow');
    var servicesMasters = this.get('servicesMasters');
    var result = [];
    if (!mastersToShow.length) {
      result = servicesMasters;
    } else {
      mastersToShow.forEach(function (master) {
        result = result.concat(servicesMasters.filterProperty('component_name', master));
      });
    }

    if (this.get('showInstalledMastersFirst')) {
      result = this.sortMasterComponents(result);
    }

    return result;
  }.property('servicesMasters.length', 'mastersToShow.length', 'showInstalledMastersFirst'),

  /**
   * Sort masters, installed masters will be first.
   * @param masters
   * @returns {Array}
   */
  sortMasterComponents: function (masters) {
    return [].concat(masters.filterProperty('isInstalled'), masters.filterProperty('isInstalled', false));
  },

  /**
   * Check if <code>installerWizard</code> used
   * @type {bool}
   */
  isInstallerWizard: Em.computed.equal('content.controllerName', 'installerController'),

  /**
   * Master components which could be assigned to multiple hosts
   * @type {string[]}
   */
  multipleComponents: Em.computed.alias('App.components.multipleMasters'),

  /**
   * Master components which could be assigned to multiple hosts
   * @type {string[]}
   */
  addableComponents: function () {
    return App.get('components.addableMasterInstallerWizard').concat(this.get('mastersAddableInHA')).uniq();
  }.property('App.components.addableMasterInstallerWizard', 'mastersAddableInHA'),

  /**
   * Define state for submit button
   * @type {bool}
   */
  submitDisabled: false,

  /**
   * Is Submit-click processing now
   * @type {bool}
   */
  submitButtonClicked: false,

  /**
   * Either use or not use server validation in this controller
   * @type {bool}
   */
  useServerValidation: true,

  /**
   * Trigger for executing host names check for components
   * Should de "triggered" when host changed for some component and when new multiple component is added/removed
   * @type {bool}
   */
  hostNameCheckTrigger: false,

  /**
   * List of hosts
   * @type {Array}
   */
  hosts: [],

  /**
   * Name of multiple component which host name was changed last
   * @type {Object|null}
   */
  componentToRebalance: null,

  /**
   * Name of component which host was changed last
   * @type {string}
   */
  lastChangedComponent: null,

  /**
   * Flag for rebalance multiple components
   * @type {number}
   */
  rebalanceComponentHostsCounter: 0,

  /**
   * @type {Ember.Enumerable}
   */
  servicesMasters: [],

  /**
   * @type {Ember.Enumerable}
   */
  selectedServicesMasters: [],

  /**
   * Is hosts data loaded
   * @type {bool}
   */
  isHostsLoaded: false,

  /**
   * Are recommendations loaded
   * @type {bool}
   */
  isRecommendationsLoaded: false,

  /**
   * Is data for current step loaded
   * @type {bool}
   */
  isLoaded: Em.computed.and('isHostsLoaded', 'isRecommendationsLoaded'),

  /**
   * Validation error messages which don't related with any master
   */
  generalErrorMessages: [],

  /**
   * Validation warning messages which don't related with any master
   */
  generalWarningMessages: [],

  /**
   * Is masters-hosts layout initial one
   * @type {bool}
   */
  isInitialLayout: true,

  /**
   * Is back from the next step
   * @type {bool}
   */
  backFromNextStep: false,

  /**
   * true if any error exists
   */
  anyError: function() {
    return this.get('servicesMasters').some(function(m) { return m.get('errorMessage'); }) || this.get('generalErrorMessages').some(function(m) { return m; });
  }.property('servicesMasters.@each.errorMessage', 'generalErrorMessages'),

  /**
   * true if any warning exists
   */
  anyWarning: function() {
    return this.get('servicesMasters').some(function(m) { return m.get('warnMessage'); }) || this.get('generalWarningMessages').some(function(m) { return m; });
  }.property('servicesMasters.@each.warnMessage', 'generalWarningMessages'),

  /**
   * Clear loaded recommendations
   */
  clearRecommendations: function() {
    if (this.get('content.recommendations')) {
      this.set('content.recommendations', null);
    }
    if (this.get('recommendations')) {
      this.set('recommendations', null);
    }
  },

  /**
   * List of host with assigned masters
   * Format:
   * <code>
   *   [
   *     {
   *       host_name: '',
   *       hostInfo: {},
   *       masterServices: [],
   *       masterServicesToDisplay: [] // used only in template
   *    },
   *    ....
   *   ]
   * </code>
   * @type {Ember.Enumerable}
   */
  masterHostMapping: function () {
    var mapping = [], mappingObject, mappedHosts, hostObj;
    //get the unique assigned hosts and find the master services assigned to them
    mappedHosts = this.get("selectedServicesMasters").mapProperty("selectedHost").uniq();
    mappedHosts.forEach(function (item) {
      hostObj = this.get("hosts").findProperty("host_name", item);
      // User may input invalid host name (this is handled in hostname checker). Here we just skip it
      if (!hostObj) return;
      var masterServices = this.get("selectedServicesMasters").filterProperty("selectedHost", item),
          masterServicesToDisplay = [];
      masterServices.mapProperty('display_name').uniq().forEach(function (n) {
        masterServicesToDisplay.pushObject(masterServices.findProperty('display_name', n));
      });
      mappingObject = Em.Object.create({
        host_name: item,
        hostInfo: hostObj.host_info,
        masterServices: masterServices,
        masterServicesToDisplay: masterServicesToDisplay
      });

      mapping.pushObject(mappingObject);
    }, this);

    return mapping.sortProperty('host_name');
  }.property('selectedServicesMasters.@each.selectedHost', 'selectedServicesMasters.@each.isHostNameValid', 'isLoaded'),

  /**
   * Count of hosts without masters
   * @type {number}
   */
  remainingHosts: function () {
    if (this.get('content.controllerName') === 'installerController') {
      return 0;
    } else {
      return (this.get("hosts.length") - this.get("masterHostMapping.length"));
    }
  }.property('masterHostMapping.length', 'selectedServicesMasters.@each.selectedHost'),

  /**
   * Update submit button status
   * @method updateIsSubmitDisabled
   */
  updateIsSubmitDisabled: function () {

    if (this.thereIsNoMasters()) {
      return false;
    }

    var isSubmitDisabled = this.get('servicesMasters').someProperty('isHostNameValid', false);

    if (this.get('useServerValidation')) {
      this.set('submitDisabled', true);

      if (this.get('servicesMasters').length === 0) {
        return;
      }

      if (!isSubmitDisabled) {
        if (!this.get('isInitialLayout')) {
          this.clearRecommendations(); // reset previous recommendations
        } else {
          this.set('isInitialLayout', false);
        }
        this.recommendAndValidate();
      }
    } else {
      isSubmitDisabled = isSubmitDisabled || !this.customClientSideValidation();
      this.set('submitDisabled', isSubmitDisabled);
      return isSubmitDisabled;
    }
  }.observes('servicesMasters.@each.selectedHost'),

  /**
   * Function to validate master-to-host assignments
   * Should be defined in controller
   * @returns {boolean}
   */
  customClientSideValidation: function () {
    return true;
  },

  /**
   * Send AJAX request to validate current host layout
   * @param blueprint - blueprint for validation (can be with/withour slave/client components)
   */
  validate: function(blueprint, callback) {
    var self = this;

    var selectedServices = App.StackService.find().filterProperty('isSelected').mapProperty('serviceName');
    var installedServices = App.StackService.find().filterProperty('isInstalled').mapProperty('serviceName');
    var services = installedServices.concat(selectedServices).uniq();

    var hostNames = self.get('hosts').mapProperty('host_name');

    App.ajax.send({
      name: 'config.validations',
      sender: self,
      data: {
        stackVersionUrl: App.get('stackVersionURL'),
        hosts: hostNames,
        services: services,
        validate: 'host_groups',
        recommendations: blueprint
      },
      success: 'updateValidationsSuccessCallback',
      error: 'updateValidationsErrorCallback'
    }).then(function() {
          if (callback) {
            callback();
          }
        }
    );
  },

  /**
   * Success-callback for validations request
   * @param {object} data
   * @method updateValidationsSuccessCallback
   */
  updateValidationsSuccessCallback: function (data) {
    var self = this;

    var generalErrorMessages = [];
    var generalWarningMessages = [];
    this.get('servicesMasters').setEach('warnMessage', null);
    this.get('servicesMasters').setEach('errorMessage', null);
    var anyErrors = false;

    var validationData = validationUtils.filterNotInstalledComponents(data);
    validationData.filterProperty('type', 'host-component').forEach(function(item) {
      var master = self.get('servicesMasters').find(function(m) {
        return m.component_name === item['component-name'] && m.selectedHost === item.host;
      });
      if (master) {
        if (item.level === 'ERROR') {
          anyErrors = true;
          master.set('errorMessage', item.message);
        } else if (item.level === 'WARN') {
          master.set('warnMessage', item.message);
        }
      }
    });

    this.set('generalErrorMessages', generalErrorMessages);
    this.set('generalWarningMessages', generalWarningMessages);

    // use this.set('submitDisabled', anyErrors); is validation results should block next button
    // It's because showValidationIssuesAcceptBox allow use accept validation issues and continue
    this.set('submitDisabled', false); //this.set('submitDisabled', anyErrors);
  },

  /**
   * Error-callback for validations request
   * @param {object} jqXHR
   * @param {object} ajaxOptions
   * @param {string} error
   * @param {object} opt
   * @method updateValidationsErrorCallback
   */
  updateValidationsErrorCallback: function (jqXHR, ajaxOptions, error, opt) {
  },

  /**
   * Composes selected values of comboboxes into master blueprint + merge it with currently installed slave blueprint
   */
  getCurrentBlueprint: function() {
    var self = this;

    var res = {
      blueprint: { host_groups: [] },
      blueprint_cluster_binding: { host_groups: [] }
    };

    var mapping = self.get('masterHostMapping');

    mapping.forEach(function(item, i) {
      var group_name = 'host-group-' + (i+1);

      var host_group = {
        name: group_name,
        components: item.masterServices.map(function(master) {
          return { name: master.component_name };
        })
      };

      var binding = {
        name: group_name,
        hosts: [ { fqdn: item.host_name } ]
      };

      res.blueprint.host_groups.push(host_group);
      res.blueprint_cluster_binding.host_groups.push(binding);
    });

    return blueprintUtils.mergeBlueprints(res, self.getCurrentSlaveBlueprint());
  },

  /**
   * Clear controller data (hosts, masters etc)
   * @method clearStep
   */
  clearStep: function () {
    this.setProperties({
      hosts: [],
      isHostsLoaded: false,
      isRecommendationsLoaded: false,
      backFromNextStep: false,
      selectedServicesMasters: [],
      servicesMasters: []
    });
    App.StackServiceComponent.find().forEach(function (stackComponent) {
      stackComponent.set('serviceComponentId', 1);
    }, this);

  },

  clearStepOnExit: function () {
    this.clearStep();
  },

  /**
   * Load controller data (hosts, host components etc)
   * @method loadStep
   */
  loadStep: function () {
    var self = this;
    this.clearStep();
    if (this._additionalClearSteps) {
      this._additionalClearSteps();
    }
    this.renderHostInfo().done(function () {
      //when returning from step Assign Slaves and Clients, recommendations are already available
      //set the flag so that recommendations AJAX call is not made unnecessarily
      if (self.get('recommendations')) {
        self.set('backFromNextStep', true);
      }
      self.loadComponentsRecommendationsFromServer(self.loadStepCallback);
    });
  },

  /**
   * Callback after load controller data (hosts, host components etc)
   * @method loadStepCallback
   */
  loadStepCallback: function(components, self) {
    self.renderComponents(components);

    self.get('addableComponents').forEach(function (componentName) {
      self.updateComponent(componentName);
    }, self);
    self.set('isRecommendationsLoaded', true);
    if (self.thereIsNoMasters() && !self.get('mastersToCreate').length) {
      App.router.send('next');
    }
  },

  /**
   * Returns true if there is no new master components which need assigment to host
   */
  thereIsNoMasters: function() {
    return !this.get("selectedServicesMasters").filterProperty('isInstalled', false).length;
  },

  /**
   * Used to set showAddControl flag for installer wizard
   * @method updateComponent
   */
  updateComponent: function (componentName) {
    var component = this.last(componentName);
    if (!component) {
      return;
    }

    var showControl = !App.StackServiceComponent.find().findProperty('componentName', componentName).get('stackService').get('isInstalled')
        || this.get('mastersAddableInHA').contains(componentName);

    if (showControl) {
      var mastersLength = this.get("selectedServicesMasters").filterProperty("component_name", componentName).length;
      if (mastersLength < this.getMaxNumberOfMasters(componentName)) {
        component.set('showAddControl', true);
      } else {
        component.set('showRemoveControl', mastersLength != 1);
      }
    }
  },

  /**
   * Count max number of instances for masters <code>componentName</code>, according to their cardinality and number of hosts
   * @param componentName
   * @returns {Number}
   */
  getMaxNumberOfMasters: function (componentName) {
    var maxByCardinality = App.StackServiceComponent.find().findProperty('componentName', componentName).get('maxToInstall');
    var hostsNumber = this.get("hosts.length");
    return Math.min(maxByCardinality, hostsNumber);
  },

  /**
   * Load active host list to <code>hosts</code> variable
   * @method renderHostInfo
   */
  renderHostInfo: function () {
    var self = this;
    var isInstaller = (this.get('wizardController.name') === 'installerController' || this.get('content.controllerName') === 'installerController');
    return App.ajax.send({
      name: isInstaller ? 'hosts.info.install' : 'hosts.high_availability.wizard',
      sender: this,
      data: {
        hostNames: isInstaller ? this.getHosts().join() : null
      }
    }).success(function(data) {
      self.loadWizardHostsSuccessCallback(data)
    });
  },

  loadWizardHostsSuccessCallback: function (data) {
    var hostInfo = this.get('content.hosts'),
      result = [];
    data.items.forEach(function (host) {
      var hostName = host.Hosts.host_name,
        _host = hostInfo[hostName],
        cpu = host.Hosts.cpu_count,
        memory = host.Hosts.total_mem.toFixed(2);
      if (_host.bootStatus === 'REGISTERED') {
        result.push(Em.Object.create({
          host_name: hostName,
          cpu: cpu,
          memory: memory,
          disk_info: host.Hosts.disk_info,
          maintenance_state: host.Hosts.maintenance_state,
          isInstalled: _host.isInstalled,
          host_info: Em.I18n.t('installer.step5.hostInfo').fmt(hostName, numberUtils.bytesToSize(memory, 1, 'parseFloat', 1024), cpu)
        }));
      }
    }, this);
    this.set('hosts', result);
    this.sortHosts(this.get('hosts'));
    this.set('isHostsLoaded', true);
  },

  /**
   * Sort list of host-objects by properties (memory - desc, cpu - desc, hostname - asc)
   * @param {object[]} hosts
   */
  sortHosts: function (hosts) {
    hosts.sort(function (a, b) {
      if (a.get('memory') == b.get('memory')) {
        if (a.get('cpu') == b.get('cpu')) {
          return a.get('host_name').localeCompare(b.get('host_name')); // hostname asc
        }
        return b.get('cpu') - a.get('cpu'); // cores desc
      }
      return b.get('memory') - a.get('memory'); // ram desc
    });
  },

  /**
   * Get recommendations info from API
   * @param {function}callback
   * @param {boolean} includeMasters
   * @method loadComponentsRecommendationsFromServer
   */
  loadComponentsRecommendationsFromServer: function(callback, includeMasters) {
    var self = this;

    //when returning from step Assign Slaves and Clients, backFromNextStep will be true
    if (this.get('recommendations') && this.get('backFromNextStep')) {
      // Don't do AJAX call if recommendations has been already received
      // But if user returns to previous step (selecting services), stored recommendations will be cleared in routers' next handler and AJAX call will be made again
      callback(self.createComponentInstallationObjects(), self);
    }
    else {
      var selectedServices = App.StackService.find().filterProperty('isSelected').mapProperty('serviceName');
      var installedServices = App.StackService.find().filterProperty('isInstalled').mapProperty('serviceName');
      var services = installedServices.concat(selectedServices).uniq();

      var hostNames = self.getHosts();

      var data = {
        stackVersionUrl: App.get('stackVersionURL'),
        hosts: hostNames,
        services: services,
        recommend: 'host_groups'
      };

      if (includeMasters) {
        // Made partial recommendation request for reflect in blueprint host-layout changes which were made by user in UI
        data.recommendations = self.getCurrentBlueprint();
      }
      else
        if (!self.get('isInstallerWizard')) {
          data.recommendations = self.getCurrentMasterSlaveBlueprint();
        }

      return App.ajax.send({
        name: 'wizard.loadrecommendations',
        sender: self,
        data: data,
        success: 'loadRecommendationsSuccessCallback',
        error: 'loadRecommendationsErrorCallback'
      }).then(function () {
          callback(self.createComponentInstallationObjects(), self);
        });
    }
  },

  /**
   * Create components for displaying component-host comboboxes in UI assign dialog
   * expects content.recommendations will be filled with recommendations API call result
   * @return {Object[]}
   */
  createComponentInstallationObjects: function() {
    var stackMasterComponentsMap = {},
        masterHosts = this.get('content.masterComponentHosts') || this.get('masterComponentHosts'), //saved to local storage info
        servicesToAdd = (this.get('content.services')|| []).filterProperty('isSelected').filterProperty('isInstalled', false).mapProperty('serviceName'),
        recommendations = this.get('recommendations'),
        resultComponents = [],
        multipleComponentHasBeenAdded = {},
        hostGroupsMap = {};

    App.StackServiceComponent.find().forEach(function(component) {
      var isMasterCreateOnConfig = this.get('mastersToCreate').contains(component.get('componentName'));
      if (this.get('isInstallerWizard') && (component.get('isShownOnInstallerAssignMasterPage') || isMasterCreateOnConfig) ) {
        stackMasterComponentsMap[component.get('componentName')] = component;
      } else if (component.get('isShownOnAddServiceAssignMasterPage') || this.get('mastersToShow').contains(component.get('componentName')) || isMasterCreateOnConfig) {
        stackMasterComponentsMap[component.get('componentName')] = component;
      }
    }, this);

    recommendations.blueprint_cluster_binding.host_groups.forEach(function(group) {
      hostGroupsMap[group.name] = group;
    });

    recommendations.blueprint.host_groups.forEach(function(host_group) {
      var hosts = hostGroupsMap[host_group.name] ? hostGroupsMap[host_group.name].hosts : [];

      hosts.forEach(function(host) {
        host_group.components.forEach(function(component) {
          var willBeDisplayed = true;
          var stackMasterComponent = stackMasterComponentsMap[component.name];
          if (stackMasterComponent) {
            var isMasterCreateOnConfig = this.get('mastersToCreate').contains(component.name);
            // If service is already installed and not being added as a new service then render on UI only those master components
            // that have already installed hostComponents.
            // NOTE: On upgrade there might be a prior installed service with non-installed newly introduced serviceComponent
            if (!servicesToAdd.contains(stackMasterComponent.get('serviceName')) && !isMasterCreateOnConfig) {
              willBeDisplayed = masterHosts.someProperty('component', component.name);
            }

            if (willBeDisplayed) {
              var savedComponents = masterHosts.filterProperty('component', component.name);

              if (this.get('multipleComponents').contains(component.name) && savedComponents.length > 0) {
                if (!multipleComponentHasBeenAdded[component.name]) {
                  multipleComponentHasBeenAdded[component.name] = true;

                  savedComponents.forEach(function(saved) {
                    resultComponents.push(this.createComponentInstallationObject(stackMasterComponent, host.fqdn.toLowerCase(), saved));
                  }, this);
                }
              } else {
                var savedComponent = masterHosts.findProperty('component', component.name);
                resultComponents.push(this.createComponentInstallationObject(stackMasterComponent, host.fqdn.toLowerCase(), savedComponent));
              }
            }
          }
        }, this);
      }, this);
    }, this);
    return resultComponents;
  },

  /**
   * Create component for displaying component-host comboboxes in UI assign dialog
   * @param fullComponent - full component description
   * @param hostName - host fqdn where component will be installed
   * @param savedComponent - the same object which function returns but created before
   * @return {Object}
   */
  createComponentInstallationObject: function(fullComponent, hostName, savedComponent) {
    var componentName = fullComponent.get('componentName');

    var componentObj = {};
    componentObj.component_name = componentName;
    componentObj.display_name = App.format.role(fullComponent.get('componentName'), false);
    componentObj.serviceId = fullComponent.get('serviceName');
    componentObj.isServiceCoHost = App.StackServiceComponent.find().findProperty('componentName', componentName).get('isCoHostedComponent') && !this.get('mastersToMove').contains(componentName);
    componentObj.selectedHost = savedComponent ? savedComponent.hostName : hostName;
    componentObj.isInstalled = savedComponent ? savedComponent.isInstalled || (this.get('markSavedComponentsAsInstalled') && !this.get('mastersToCreate').contains(fullComponent.get('componentName'))) : false;
    return componentObj;
  },

  /**
   * Success-callback for recommendations request
   * @param {object} data
   * @method loadRecommendationsSuccessCallback
   */
  loadRecommendationsSuccessCallback: function (data) {
    var recommendations = data.resources[0].recommendations;
    this.set('recommendations', recommendations);
    if (this.get('content.controllerName')) {
      this.set('content.recommendations', recommendations);
    }

    var recommendedHostsForComponent = {};
    var hostsForHostGroup = {};

    recommendations.blueprint_cluster_binding.host_groups.forEach(function(hostGroup) {
      hostsForHostGroup[hostGroup.name] = hostGroup.hosts.mapProperty('fqdn');
    });

    recommendations.blueprint.host_groups.forEach(function (hostGroup) {
      var components = hostGroup.components.mapProperty('name');
      components.forEach(function (componentName) {
        var hostList = recommendedHostsForComponent[componentName] || [];
        var hostNames = hostsForHostGroup[hostGroup.name] || [];
        hostList.pushObjects(hostNames);
        recommendedHostsForComponent[componentName] = hostList;
      });
    });

    this.set('recommendedHostsForComponents', recommendedHostsForComponent);
    if (this.get('content.controllerName')) {
      this.set('content.recommendedHostsForComponents', recommendedHostsForComponent);
    }
  },

  /**
   * Error-callback for recommendations request
   * @param {object} jqXHR
   * @param {object} ajaxOptions
   * @param {string} error
   * @param {object} opt
   * @method loadRecommendationsErrorCallback
   */
  loadRecommendationsErrorCallback: function (jqXHR, ajaxOptions, error, opt) {
    App.ajax.defaultErrorHandler(jqXHR, opt.url, opt.type, jqXHR.status);
  },

  /**
   * Put master components to <code>selectedServicesMasters</code>, which will be automatically rendered in template
   * @param {Ember.Enumerable} masterComponents
   * @method renderComponents
   */
  renderComponents: function (masterComponents) {
    var installedServices = App.StackService.find().filterProperty('isSelected').filterProperty('isInstalled', false).mapProperty('serviceName'); //list of shown services
    var result = [];
    var serviceComponentId, previousComponentName;

    this.addNewMasters(masterComponents);

    masterComponents.forEach(function (item) {
      var masterComponent = App.StackServiceComponent.find().findProperty('componentName', item.component_name);
      var componentObj = Em.Object.create(item);
      var showRemoveControl;
      if (masterComponent.get('isMasterWithMultipleInstances')) {
        showRemoveControl = installedServices.contains(masterComponent.get('stackService.serviceName')) &&
            (masterComponents.filterProperty('component_name', item.component_name).length > 1);
        previousComponentName = item.component_name;
        componentObj.set('serviceComponentId', result.filterProperty('component_name', item.component_name).length + 1);
        componentObj.set("showRemoveControl", showRemoveControl);
      }
      componentObj.set('isHostNameValid', true);
      componentObj.set('showCurrentPrefix', this.get('showCurrentPrefix').contains(item.component_name) && item.isInstalled);
      componentObj.set('showAdditionalPrefix', this.get('showAdditionalPrefix').contains(item.component_name) && !item.isInstalled);
      if (this.get('mastersToMove').contains(item.component_name)) {
        componentObj.set('isInstalled', false);
      }

      result.push(componentObj);
    }, this);
    result = this.sortComponentsByServiceName(result);
    this.set("selectedServicesMasters", result);
    this.set('servicesMasters', result);
  },

  /**
   * Add new master components from <code>mastersToAdd</code> list
   * @param masterComponents
   * @returns {masterComponents[]}
   */
  addNewMasters: function (masterComponents) {
    this.get('mastersToAdd').forEach(function (masterName, index, mastersToAdd) {
      var toBeAddedNumber = mastersToAdd.filter(function (name) {
          return name === masterName;
        }).length,
        alreadyAddedNumber = masterComponents.filterProperty('component_name', masterName).rejectProperty('isInstalled').length;
      if (toBeAddedNumber > alreadyAddedNumber) {
        var hostName = this.getHostForMaster(masterName, masterComponents),
          serviceName = this.getServiceByMaster(masterName);
        masterComponents.push(this.createComponentInstallationObject(
          Em.Object.create({
            componentName: masterName,
            serviceName: serviceName
          }),
          hostName
        ));
      }
    }, this);
    return masterComponents;
  },

  /**
   * Find available host for master and return it
   * If there is no available hosts returns false
   * @param master
   * @param allMasters
   * @returns {*}
   */
  getHostForMaster: function (master, allMasters) {
    var masterHostList = [];

    allMasters.forEach(function (component) {
      if (component.component_name === master) {
        masterHostList.push(component.selectedHost);
      }
    });

    var recommendedHostsForMaster = this.get('recommendedHostsForComponents')[master] || [];
    for (var k = 0; k < recommendedHostsForMaster.length; k++) {
      if(!masterHostList.contains(recommendedHostsForMaster[k])) {
        return recommendedHostsForMaster[k];
      }
    }

    var usedHosts = allMasters.filterProperty('component_name', master).mapProperty('selectedHost');
    var allHosts = this.get('hosts');
    for (var i = 0; i < allHosts.length; i++) {
      if (!usedHosts.contains(allHosts[i].get('host_name'))) {
        return allHosts[i].get('host_name');
      }
    }

    return false;
  },

  /**
   * Find serviceName for master by it's componentName
   * @param master
   * @returns {*}
   */
  getServiceByMaster: function (master) {
    return App.StackServiceComponent.find().findProperty('componentName', master).get('serviceName');
  },

  /**
   * Sort components by their service (using <code>App.StackService.displayOrder</code>)
   * Services not in App.StackService.displayOrder are moved to the end of the list
   *
   * @param components
   * @returns {*}
   */
  sortComponentsByServiceName: function(components) {
    var displayOrder = App.StackService.displayOrder;
    var componentsOrderForService = App.StackService.componentsOrderForService;
    var indexForUnordered = Math.max(displayOrder.length, components.length);
    return components.sort(function (a, b) {
      if(a.serviceId === b.serviceId && a.serviceId in componentsOrderForService)
        return componentsOrderForService[a.serviceId].indexOf(a.component_name) - componentsOrderForService[b.serviceId].indexOf(b.component_name);
      var aValue = displayOrder.indexOf(a.serviceId) != -1 ? displayOrder.indexOf(a.serviceId) : indexForUnordered;
      var bValue = displayOrder.indexOf(b.serviceId) != -1 ? displayOrder.indexOf(b.serviceId) : indexForUnordered;
      return aValue - bValue;
    });
  },
  /**
   * Update dependent co-hosted components according to the change in the component host
   * @method updateCoHosts
   */
  updateCoHosts: function () {
    var components = App.StackServiceComponent.find().filterProperty('isOtherComponentCoHosted');
    var selectedServicesMasters = this.get('selectedServicesMasters');
    components.forEach(function (component) {
      var componentName = component.get('componentName');
      var hostComponent = selectedServicesMasters.findProperty('component_name', componentName);
      var dependentCoHosts = component.get('coHostedComponents');
      dependentCoHosts.forEach(function (coHostedComponent) {
        var dependentHostComponent = selectedServicesMasters.findProperty('component_name', coHostedComponent);
        if (!this.get('mastersToMove').contains(coHostedComponent) && hostComponent && dependentHostComponent) dependentHostComponent.set('selectedHost', hostComponent.get('selectedHost'));
      }, this);
    }, this);
  }.observes('selectedServicesMasters.@each.selectedHost'),


  /**
   * On change callback for inputs
   * @param {string} componentName
   * @param {string} selectedHost
   * @param {number} serviceComponentId
   * @method assignHostToMaster
   */
  assignHostToMaster: function (componentName, selectedHost, serviceComponentId) {
    var flag = this.isHostNameValid(componentName, selectedHost);
    var component;
    this.updateIsHostNameValidFlag(componentName, serviceComponentId, flag);
    if (serviceComponentId) {
      component = this.get('selectedServicesMasters').filterProperty('component_name', componentName).findProperty("serviceComponentId", serviceComponentId);
      if (component) component.set("selectedHost", selectedHost);
    }
    else {
      this.get('selectedServicesMasters').findProperty("component_name", componentName).set("selectedHost", selectedHost);
    }
  },

  /**
   * Determines if hostName is valid for component:
   * <ul>
   *  <li>host name shouldn't be empty</li>
   *  <li>host should exist</li>
   *  <li>if host installed maintenance state should be 'OFF'</li>
   *  <li>host should have only one component with <code>componentName</code></li>
   * </ul>
   * @param {string} componentName
   * @param {string} selectedHost
   * @returns {boolean} true - valid, false - invalid
   * @method isHostNameValid
   */
  isHostNameValid: function (componentName, selectedHost) {
    return (selectedHost.trim() !== '') &&
      (this.get('hosts').filter(function(host) {
        return host.host_name === selectedHost && (!host.isInstalled || host.maintenance_state === 'OFF');
      }).length > 0) &&
      (this.get('selectedServicesMasters').
        filterProperty('component_name', componentName).
        mapProperty('selectedHost').
        filter(function (h) {
          return h === selectedHost;
        }).length <= 1);
  },

  /**
   * Update <code>isHostNameValid</code> property with <code>flag</code> value
   * for component with name <code>componentName</code> and
   * <code>serviceComponentId</code>-property equal to <code>serviceComponentId</code>-parameter value
   * @param {string} componentName
   * @param {number} serviceComponentId
   * @param {bool} flag
   * @method updateIsHostNameValidFlag
   */
  updateIsHostNameValidFlag: function (componentName, serviceComponentId, flag) {
    var component;
    if (componentName) {
      if (serviceComponentId) {
        component = this.get('selectedServicesMasters').filterProperty('component_name', componentName).findProperty("serviceComponentId", serviceComponentId);
      } else {
        component = this.get('selectedServicesMasters').findProperty("component_name", componentName);
      }
      if (component) {
        component.set("isHostNameValid", flag);
        component.set("errorMessage", flag ? null : Em.I18n.t('installer.step5.error.host.invalid'));
      }
    }
  },

  /**
   * Returns last component of selected type
   * @param {string} componentName
   * @return {Em.Object|null}
   * @method last
   */
  last: function (componentName) {
    return this.get("selectedServicesMasters").filterProperty("component_name", componentName).get("lastObject");
  },

  /**
   * Add new component to ZooKeeper Server and Hbase master
   * @param {string} componentName
   * @return {bool} true - added, false - not added
   * @method addComponent
   */
  addComponent: function (componentName) {
    /*
     * Logic: If ZooKeeper or Hbase service is selected then there can be
     * minimum 1 ZooKeeper or Hbase master in total, and
     * maximum 1 ZooKeeper or Hbase on every host
     */

    var maxNumMasters = this.getMaxNumberOfMasters(componentName),
        currentMasters = this.get("selectedServicesMasters").filterProperty("component_name", componentName).sortProperty('serviceComponentId'),
        newMaster = null,
        masterHosts = null,
        suggestedHost = null,
        i = 0,
        lastMaster = null;

    if (!currentMasters.length) {
      return false;
    }

    if (currentMasters.get("length") < maxNumMasters) {

      currentMasters.set("lastObject.showAddControl", false);
      currentMasters.set("lastObject.showRemoveControl", true);

      //create a new master component host based on an existing one
      newMaster = Em.Object.create({});
      lastMaster = currentMasters.get("lastObject");
      newMaster.set("display_name", lastMaster.get("display_name"));
      newMaster.set("component_name", lastMaster.get("component_name"));
      newMaster.set("selectedHost", lastMaster.get("selectedHost"));
      newMaster.set("serviceId", lastMaster.get("serviceId"));
      newMaster.set("isInstalled", false);
      newMaster.set('showAdditionalPrefix', this.get('showAdditionalPrefix').contains(lastMaster.get("component_name")));

      if (currentMasters.get("length") === (maxNumMasters - 1)) {
        newMaster.set("showAddControl", false);
      } else {
        newMaster.set("showAddControl", true);
      }
      newMaster.set("showRemoveControl", true);

      //get recommended host for the new Zookeeper server
      masterHosts = currentMasters.mapProperty("selectedHost").uniq();

      for (i = 0; i < this.get("hosts.length"); i++) {
        if (!(masterHosts.contains(this.get("hosts")[i].get("host_name")))) {
          suggestedHost = this.get("hosts")[i].get("host_name");
          break;
        }
      }

      newMaster.set("selectedHost", suggestedHost);
      newMaster.set("serviceComponentId", (currentMasters.get("lastObject.serviceComponentId") + 1));

      this.get("selectedServicesMasters").insertAt(this.get("selectedServicesMasters").indexOf(lastMaster) + 1, newMaster);

      this.setProperties({
        componentToRebalance: componentName,
        lastChangedComponent: componentName
      });
      this.incrementProperty('rebalanceComponentHostsCounter');
      this.toggleProperty('hostNameCheckTrigger');
      return true;
    }
    return false;//if no more zookeepers can be added
  },

  /**
   * Remove component from ZooKeeper server or Hbase Master
   * @param {string} componentName
   * @param {number} serviceComponentId
   * @return {bool} true - removed, false - no
   * @method removeComponent
   */
  removeComponent: function (componentName, serviceComponentId) {
    var currentMasters = this.get("selectedServicesMasters").filterProperty("component_name", componentName);

    //work only if the multiple master service is selected in previous step
    if (currentMasters.length <= 1) {
      return false;
    }

    this.get("selectedServicesMasters").removeAt(this.get("selectedServicesMasters").indexOf(currentMasters.findProperty("serviceComponentId", serviceComponentId)));

    currentMasters = this.get("selectedServicesMasters").filterProperty("component_name", componentName);
    if (currentMasters.get("length") < this.getMaxNumberOfMasters(componentName)) {
      currentMasters.set("lastObject.showAddControl", true);
    }

    if (currentMasters.filterProperty('isInstalled', false).get("length") === 1) {
      currentMasters.set("lastObject.showRemoveControl", false);
    }

    this.setProperties({
      componentToRebalance: componentName,
      lastChangedComponent: componentName
    });
    this.incrementProperty('rebalanceComponentHostsCounter');
    this.toggleProperty('hostNameCheckTrigger');
    return true;
  },

  recommendAndValidate: function(callback) {
    var self = this;

    if (this.get('validationInProgress')) {
      this.set('runQueuedValidation', true);
      return;
    }

    this.set('validationInProgress', true);

    // load recommendations with partial request
    self.loadComponentsRecommendationsFromServer(function() {
      // For validation use latest received recommendations because it contains current master layout and recommended slave/client layout
      self.validate(self.get('recommendations'), function() {
        if (callback) {
          callback();
        }
        self.set('validationInProgress', false);
        if (self.get('runQueuedValidation')) {
          self.set('runQueuedValidation', false);
          self.recommendAndValidate(callback);
        }
      });
    }, true);
  },

  _goNextStepIfValid: function () {
    if (!this.get('submitDisabled')) {
      App.router.send('next');
    }else{
      App.set('router.nextBtnClickInProgress', false);
    }
  },

  nextButtonDisabled: Em.computed.or('App.router.btnClickInProgress', 'submitDisabled', 'validationInProgress', '!isLoaded'),

  /**
   * Submit button click handler
   * Disable 'Next' button while it is already under process. (using Router's property 'nextBtnClickInProgress')
   * @method submit
   */
  submit: function () {
    var self = this;
    if (this.get('submitDisabled')) {
      return;
    }
    if (!this.get('submitButtonClicked') && !App.get('router.nextBtnClickInProgress')) {
      this.set('submitButtonClicked', true);
      App.router.set('nextBtnClickInProgress', true);

      if (this.get('useServerValidation')) {
        self.recommendAndValidate(function () {
          self.showValidationIssuesAcceptBox(self._goNextStepIfValid.bind(self));
        });
      }
      else {
        this.updateIsSubmitDisabled();
        this._goNextStepIfValid();
        this.set('submitButtonClicked', false);
      }
    }
  },

  /**
   * In case of any validation issues shows accept dialog box for user which allow cancel and fix issues or continue anyway
   * @method showValidationIssuesAcceptBox
   */
  showValidationIssuesAcceptBox: function(callback) {
    var self = this;

    // If there are no warnings and no errors, return
    if (!self.get('anyWarning') && !self.get('anyError')) {
      callback();
      self.set('submitButtonClicked', false);
      return;
    }

    App.ModalPopup.show({
      primary: Em.I18n.t('common.continueAnyway'),
      header: Em.I18n.t('installer.step5.validationIssuesAttention.header'),
      body: Em.I18n.t('installer.step5.validationIssuesAttention'),
      onPrimary: function () {
        this._super();
        callback();
        self.set('submitButtonClicked', false);
      },
      onSecondary: function () {
        this._super();
        App.router.set('nextBtnClickInProgress', false);
        self.set('submitButtonClicked', false);
      },
      onClose: function () {
        this._super();
        self.set('submitButtonClicked', false);
      }
    });
  },

  getHosts: function () {
    return Em.keys(this.get('content.hosts'));
  }
});