text: 'use strict';
  
  /**
   * @ngdoc function
   * @name openshiftConsole.controller:EditAutoscalerController
   * @description
   * # EditAutoscalerController
   * Controller of the openshiftConsole
   */
  angular.module('openshiftConsole')
    .controller('EditAutoscalerController',
                function ($scope,
                          $filter,
                          $routeParams,
                          $window,
                          APIService,
                          AuthorizationService,
                          BreadcrumbsService,
                          DataService,
                          HPAService,
                          MetricsService,
                          Navigate,
                          NotificationsService,
                          ProjectsService,
                          keyValueEditorUtils) {
      if (!$routeParams.kind || !$routeParams.name) {
        Navigate.toErrorPage("Kind or name parameter missing.");
        return;
      }
  
      var supportedKinds = [
        'Deployment',
        'DeploymentConfig',
        'HorizontalPodAutoscaler',
        'ReplicaSet',
        'ReplicationController'
      ];
  
      if (!_.includes(supportedKinds, $routeParams.kind)) {
        Navigate.toErrorPage("Autoscaling not supported for kind " + $routeParams.kind + ".");
        return;
      }
  
      $scope.kind = $routeParams.kind;
      $scope.name = $routeParams.name;
      if ($routeParams.kind === "HorizontalPodAutoscaler") {
        // Wait for the HPA data to load before enabling the form controls.
        // This is only necessary when editing an existing HPA.
        $scope.disableInputs = true;
      } else {
        $scope.targetKind = $routeParams.kind;
        $scope.targetName = $routeParams.name;
      }
  
      $scope.autoscaling = {
        name: $scope.name
      };
  
      $scope.labels = [];
  
      var getErrorDetails = $filter('getErrorDetails');
  
      var navigateBack = function() {
        $window.history.back();
      };
      $scope.cancel = navigateBack;
  
      var hideErrorNotifications = function() {
        NotificationsService.hideNotification('edit-hpa-error');
      };
      $scope.$on('$destroy', hideErrorNotifications);
  
      var horizontalPodAutoscalerVersion = APIService.getPreferredVersion('horizontalpodautoscalers');
      var limitRangesVersion = APIService.getPreferredVersion('limitranges');
  
  
      ProjectsService
        .get($routeParams.project)
        .then(_.spread(function(project, context) {
          // Update project breadcrumb with display name.
          $scope.project = project;
  
          var verb = $routeParams.kind === 'HorizontalPodAutoscaler' ? 'update' : 'create';
          if (!AuthorizationService.canI({ resource: 'horizontalpodautoscalers', group: 'autoscaling' }, verb, $routeParams.project)) {
            Navigate.toErrorPage('You do not have authority to ' + verb + ' horizontal pod autoscalers in project ' + $routeParams.project + '.', 'access_denied');
            return;
          }
  
          var updateHPA = function(hpa) {
            $scope.disableInputs = true;
  
            hpa = angular.copy(hpa);
            hpa.metadata.labels = keyValueEditorUtils.mapEntries(keyValueEditorUtils.compactEntries($scope.labels));
            hpa.spec.minReplicas = $scope.autoscaling.minReplicas;
            hpa.spec.maxReplicas = $scope.autoscaling.maxReplicas;
            hpa.spec.targetCPUUtilizationPercentage = $scope.autoscaling.targetCPU;
  
            DataService.update(horizontalPodAutoscalerVersion, hpa.metadata.name, hpa, context)
              .then(function(hpa) { // Success
                NotificationsService.addNotification({
                  type: 'success',
                  message: 'Horizontal pod autoscaler ' + hpa.metadata.name + ' successfully updated.'
                });
  
                navigateBack();
              }, function(result) { // Failure
                $scope.disableInputs = false;
                NotificationsService.addNotification({
                  id: 'edit-hpa-error',
                  type: 'error',
                  message: 'An error occurred creating the horizontal pod autoscaler.',
                  details: getErrorDetails(result)
                });
              });
          };
  
          var resourceGroup = {};
          if ($routeParams.kind === "HorizontalPodAutoscaler") {
            // Fetch the HPA we're editing. This form knows how to edit autoscaling/v1 HPA objects
            resourceGroup = {
              resource: "horizontalpodautoscalers",
              group: "autoscaling",
              version: "v1"
            };
          } else {
            // Fetch the resource we're going to create an HPA for
            resourceGroup = {
              resource: APIService.kindToResource($routeParams.kind),
              group: $routeParams.group
            };
          }
  
          DataService.get(resourceGroup, $routeParams.name, context).then(function(resource) {
            var createHPA = function() {
              $scope.disableInputs = true;
              hideErrorNotifications();
              var hpa = {
                apiVersion: "autoscaling/v1",
                kind: "HorizontalPodAutoscaler",
                metadata: {
                  name: $scope.autoscaling.name,
                  labels: keyValueEditorUtils.mapEntries(keyValueEditorUtils.compactEntries($scope.labels))
                },
                spec: {
                  scaleTargetRef: {
                    kind: resource.kind,
                    name: resource.metadata.name,
                    apiVersion: resource.apiVersion
                  },
                  minReplicas: $scope.autoscaling.minReplicas,
                  maxReplicas: $scope.autoscaling.maxReplicas,
                  targetCPUUtilizationPercentage: $scope.autoscaling.targetCPU
                }
              };
  
              DataService.create(horizontalPodAutoscalerVersion, null, hpa, context)
                .then(function(hpa) { // Success
                  NotificationsService.addNotification({
                    type: 'success',
                    message: 'Horizontal pod autoscaler ' + hpa.metadata.name + ' successfully created.'
                  });
  
                  navigateBack();
                }, function(result) { // Failure
                  $scope.disableInputs = false;
                  NotificationsService.addNotification({
                    id: 'edit-hpa-error',
                    type: 'error',
                    message: 'An error occurred creating the horizontal pod autoscaler.',
                    details: getErrorDetails(result)
                  });
                });
            };
  
            $scope.labels = _.map(
                              _.get(resource, 'metadata.labels', {}),
                              function(val, key) {
                                return {
                                  name: key,
                                  value: val
                                };
                              });
  
            $scope.usesV2Metrics = HPAService.usesV2Metrics(resource);
  
            // Are we editing an existing HPA?
            if ($routeParams.kind === "HorizontalPodAutoscaler") {
              $scope.targetKind = _.get(resource, 'spec.scaleTargetRef.kind');
              $scope.targetName = _.get(resource, 'spec.scaleTargetRef.name');
              _.assign($scope.autoscaling, {
                minReplicas: _.get(resource, 'spec.minReplicas'),
                maxReplicas: _.get(resource, 'spec.maxReplicas'),
                targetCPU: _.get(resource, 'spec.targetCPUUtilizationPercentage')
              });
              $scope.disableInputs = false;
  
              // Update the existing HPA.
              $scope.save = function() {
                updateHPA(resource);
              };
  
              // Build the breadcrumb for the target resource. (HPAs don't have a dedicated page.)
              $scope.breadcrumbs = BreadcrumbsService.getBreadcrumbs({
                name: $scope.targetName,
                kind: $scope.targetKind,
                namespace: $routeParams.project,
                project: project,
                subpage: 'Autoscale'
              });
            } else {
              $scope.breadcrumbs = BreadcrumbsService.getBreadcrumbs({
                object: resource,
                project: project,
                subpage: 'Autoscale'
              });
  
              // Create a new HPA.
              $scope.save = createHPA;
  
              var limitRanges = {};
              var checkCPURequest = function() {
                var containers = _.get(resource, 'spec.template.spec.containers', []);
                $scope.showCPURequestWarning = !HPAService.hasCPURequest(containers, limitRanges, project);
              };
  
              // List limit ranges in this project to determine if there is a default
              // CPU request for autoscaling.
              DataService.list(limitRangesVersion, context).then(function(resp) {
                limitRanges = resp.by("metadata.name");
                checkCPURequest();
              });
            }
          });
      }));
    });
  