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

(function($, cloudStack) {
  cloudStack.lbStickyPolicy = {
    dialog: function(args) {
      return function(args) {
        var success = args.response.success;
        var context = args.context;
								
				var network;
				if('vpc' in args.context) {	//from VPC section
					var data = {
						listAll: true,
						supportedservices: 'Lb'
					};
					if(args.context.ipAddresses[0].associatednetworkid == null) {
						$.extend(data, {
							vpcid: args.context.vpc[0].id
						});
					}
					else {
						$.extend(data, {
							id: args.context.ipAddresses[0].associatednetworkid
						});
					}			
				
					$.ajax({
						url: createURL("listNetworks"),		//check whether the VPC has a network including Lb service													
						data: data,						
            async: false,						
						success: function(json) {	          					
							var items = json.listnetworksresponse.network;	
							if(items != null && items.length > 0) {
                network = items[0];
              }							
						}
					});	 
				}				
				else { //from Guest Network section				
          network = args.context.networks[0];
				}
		
        var $item = args.$item;

        var lbService = $.grep(network.service, function(service) {
          return service.name == 'Lb';
        })[0];
       
        var stickinessCapabilities = JSON.parse($.grep(
          lbService.capability,
          function(capability) {
            return capability.name == 'SupportedStickinessMethods';
          }
        )[0].value);

        var baseFields = {
          stickyName: { label: 'Sticky Name', validation: { required: true } }
        };

        $.map(
          $.map(
            stickinessCapabilities,
            function(c) { return c.paramlist; }
          ),
          function(p) {
            baseFields[p.paramname] = {
              label: _l('label.sticky.' + p.paramname),
              isHidden: true,
              isBoolean: p.isflag,
              validation: { required: p.required }
            };
          }
        );

        var conditionalFields = {
          methodname: {
            label: 'Stickiness method',
            select: function(args) {
              var $select = args.$select;
              var $form = $select.closest('form');
              var stickyOptions = [];

              stickinessCapabilities.push({ methodname: 'None', paramlist: [] });
              $(stickinessCapabilities).each(function() {
                var stickyCapability = this;

                stickyOptions.push({
                  id: stickyCapability.methodname,
                  description: stickyCapability.methodname
                });
              });

              stickyOptions = stickyOptions.sort(function() {
                return this.id != 'None';
              });

              args.response.success({
                data: stickyOptions
              }, 500);

              $select.change(function() {
                var value = $select.val();
                var showFields = [];
                var targetMethod = $.grep(stickinessCapabilities, function(stickyCapability) {
                  return stickyCapability.methodname == value;
                })[0];
                var visibleParams = $.map(targetMethod.paramlist, function(param) {
                  return param.paramname;
                });

                $select.closest('.form-item').siblings('.form-item').each(function() {
                  var $field = $(this);
                  var id = $field.attr('rel');

                  if ($.inArray(id, visibleParams) > -1) {
                    $field.css('display', 'inline-block');
                    $field.attr('sticky-method', value);
                  } else {
                    $field.hide();
                    $field.attr('sticky-method', null);
                  }
                });

                // Name always is required
                if ($select.val() != 'None') {
                  $select.closest('.form-item').siblings('.form-item[rel=stickyName]')
                    .css('display', 'inline-block');
                }

                $select.closest(':ui-dialog').dialog('option', 'position', 'center');
              });
            }
          }
        };

        var fields = $.extend(conditionalFields, baseFields);

        if (args.data) {
          var populatedFields = $.map(fields, function(field, id) {
            return id;
          });

          $(populatedFields).each(function() {
            var id = this;
            var field = fields[id];
            var dataItem = args.data[id];

            if (field.isBoolean) {
              field.isChecked = dataItem ? true : false;
            } else {
              field.defaultValue = dataItem;
            }
          });
        }

        cloudStack.dialog.createForm({
          form: {
            title: 'Configure Sticky Policy',
            desc: 'Please complete the following fields',
            fields: fields
          },
          after: function(args) {
            // Remove fields not applicable to sticky method
            args.$form.find('.form-item:hidden').remove();
            
            var data = cloudStack.serializeForm(args.$form);

            /* $item indicates that this is an existing sticky rule;
               re-create sticky rule with new parameters */
            if ($item) {
              var $loading = $('<div>').addClass('loading-overlay');

              $loading.prependTo($item);
              cloudStack.lbStickyPolicy.actions.recreate(
                $item.data('multi-custom-data').id,
                $item.data('multi-custom-data').lbRuleID,
                data,
                function() { // Complete
                  $(window).trigger('cloudStack.fullRefresh');
                },
                function(error) { // Error
                  $(window).trigger('cloudStack.fullRefresh');
                }
              );
            } else {
              success({
                data: data
              });
            }
          }
        });
      };
    },

    actions: {
      add: function(lbRuleID, data, complete, error) {
        var stickyURLData = '';
        var stickyParams = $.map(data, function(value, key) {
          return key;
        });

        var notParams = ['methodname', 'stickyName'];

        var index = 0;
        $(stickyParams).each(function() {
          var param = '&param[' + index + ']';
          var name = this.toString();
          var value = data[name];

          if (!value || $.inArray(name, notParams) > -1) return true;
          if (value == 'on') value = true;
          
          stickyURLData += param + '.name=' + name + param + '.value=' + value;

          index++;

          return true;
        });

        $.ajax({
          url: createURL('createLBStickinessPolicy' + stickyURLData),
          data: {
            lbruleid: lbRuleID,
            name: data.stickyName,
            methodname: data.methodname
          },
          success: function(json) {
            cloudStack.ui.notifications.add(
              {
                desc: 'Add new LB sticky rule',
                section: 'Network',
                poll: pollAsyncJobResult,
                _custom: {
                  jobId: json.createLBStickinessPolicy.jobid
                }
              },
              complete, {},
              error, {}
            );
          },
          error: function(json) {
            complete();
            cloudStack.dialog.notice({ message: parseXMLHttpResponse(json) });
          }
        });
      },
      recreate: function(stickyRuleID, lbRuleID, data, complete, error) {
        var addStickyPolicy = function() {
          cloudStack.lbStickyPolicy.actions.add(
            lbRuleID,
            data,
            complete,
            error
          );
        };
        
        // Delete existing rule
        if (stickyRuleID) {
          $.ajax({
            url: createURL('deleteLBStickinessPolicy'),
            data: {
              id: stickyRuleID
            },
            success: function(json) {
              cloudStack.ui.notifications.add(
                {
                  desc: 'Remove previous LB sticky rule',
                  section: 'Network',
                  poll: pollAsyncJobResult,
                  _custom: {
                    jobId: json.deleteLBstickinessrruleresponse.jobid
                  }
                },
                function() {
                  if (data.methodname != 'None') {
                    addStickyPolicy();
                  } else {
                    complete();
                  }
                }, {},
                error, {}
              );
            },
            error: function(json) {
              cloudStack.dialog.notice({
                message: parseXMLHttpResponse(json)
              });
              error();
            }
          });
        } else if (data.methodname != 'None') {
          addStickyPolicy();
        } else {
          complete();
        }
      }
    }
  };
}(jQuery, cloudStack));