// 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.sections.regions = {
    title: 'label.menu.regions',
    id: 'regions',
    sectionSelect: {
      label: 'label.select-view',
      preFilter: function() { return ['regions']; }
    },
    regionSelector: {
      dataProvider: function(args) {
        $.ajax({
          url: createURL('listRegions&listAll=true'),
          success: function(json) {
            var regions = json.listregionsresponse.region;

            args.response.success({
              data: regions ? regions : [
                { id: -1, name: _l('label.no.data') }
              ]
            });
          }
        });
      }
    },
    sections: {
      regions: {
        id: 'regions',
        type: 'select',
        title: 'label.menu.regions',
        listView: {
          section: 'regions',
          id: 'regions',
          label: 'label.menu.regions',
          fields: {
            name: { label: 'label.name' },
            id: { label: 'ID' },
            endpoint: { label: 'label.endpoint' }
          },
          actions: {
            add: {
              label: 'label.add.region',
							preFilter: function(args) {
                if(isAdmin())
                  return true;
                else
                  return false;
              },
              messages: {
                notification: function() { return 'label.add.region'; }
              },
              createForm: {
                title: 'label.add.region',
                desc: 'message.add.region',
                fields: {
                  id: { label: 'label.id', validation: { required: true } },
                  name: { label: 'label.name', validation: { required: true } },
                  endpoint: { label: 'label.endpoint', validation: { required: true } }
                }
              },
              action: function(args) {
                var data = {
                  id: args.data.id,
                  name: args.data.name,
                  endpoint: args.data.endpoint
                };

                $.ajax({
                  url: createURL('addRegion'),
                  data: data,
                  success: function(json) {
                    var item = json.addregionresponse.region;
                    args.response.success({data: item});
                    $(window).trigger('cloudStack.refreshRegions');
                  },
                  error: function(json) {
                    args.response.error(parseXMLHttpResponse(json));
                  }
                });
              },
              notification: {
                poll: function(args) {
                  args.complete();
                }
              }
            }
          },
          dataProvider: function(args) {
            $.ajax({
              url: createURL('listRegions&listAll=true'),
              success: function(json) {
                var items = json.listregionsresponse.region;
                args.response.success({								 
                  data: items
                });
              },
              error: function(json) {
                args.response.error(parseXMLHttpResponse(json));
              }
            });
          },
          detailView: {
            name: 'Region details',
            viewAll: [
              { 
                path: 'regions.GSLB', 
                label: 'GSLB' 
              },
              { 
                path: 'regions.portableIpRanges', 
                label: 'Portable IP',
                preFilter: function(args) {                  
                  if (isAdmin())
                    return true;

                  return false;
                }
              }
            ],
            actions: {
              edit: {
                label: 'label.edit.region',
                action: function(args) {
                  var data = {
                    id: args.context.regions[0].id,
                    name: args.data.name,
                    endpoint: args.data.endpoint
                  };

                  $.ajax({
                    url: createURL('updateRegion'),
                    data: data,
                    success: function(json) {
                      args.response.success();
                      $(window).trigger('cloudStack.refreshRegions');
                    },
                    error: function(json) {
                      args.response.error(parseXMLHttpResponse(json));
                    }
                  });
                }
              },
              remove: {
                label: 'label.remove.region',
                messages: {
                  notification: function() { return 'label.remove.region'; },
                  confirm: function() { return 'message.remove.region'; }
                },
                preAction: function(args) {
                  var region = args.context.regions[0];

                  /* e.g.
                  region.endpoint	== "http://localhost:8080/client/"
                  document.location.href == "http://localhost:8080/client/#"
                  */
                  /*
                  if(document.location.href.indexOf(region.endpoint) != -1) {
                    cloudStack.dialog.notice({ message: _l('You can not remove the region that you are currently in.') });
                    return false;
                  }
                  */
                  return true;
                },
                action: function(args) {
                  var region = args.context.regions[0];

                  $.ajax({
                    url: createURL('removeRegion'),
                    data: { id: region.id },
                    success: function(json) {
                      args.response.success();
                      $(window).trigger('cloudStack.refreshRegions');
                    },
                    error: function(json) {
                      args.response.error(parseXMLHttpResponse(json));
                    }
                  });
                }
              }
            },
            tabs: {
              details: {
                title: 'label.details',
                fields: [
                  {
                    id: { label: 'label.id' }
                  },
                  {
                    name: { label: 'label.name', isEditable: true },
                    endpoint: { label: 'label.endpoint', isEditable: true }
                  }
                ],
                dataProvider: function(args) {
                  $.ajax({
                    url: createURL('listRegions&listAll=true'),
                    data: { id: args.context.regions[0].id },
                    success: function(json) {
                      var region = json.listregionsresponse.region

                      args.response.success({
											  actionFilter: regionActionfilter,
                        data: region ? region[0] : {}
                      });
                    },
                    error: function(json) {
                      args.response.error(parseXMLHttpResponse(json));
                    }
                  });
                }
              }
            }
          }
        }
      },
      GSLB: {
        id: 'GSLB',
        type: 'select',
        title: 'GSLB',
        listView: {
          id: 'GSLB',
          label: 'GSLB',
          fields: {
            name: { label: 'label.name' },
						gslbdomainname: { label: 'GSLB Domain Name' },
						gslblbmethod: { label: 'Algorithm' }
          },										
					actions: {
            add: {
              label: 'Add GSLB',

              messages: {
                confirm: function(args) {
                  return 'Add GSLB';
                },
                notification: function(args) {
                  return 'Add GSLB';
                }
              },

              createForm: {
                title: 'Add GSLB',
                fields: {
                  name: {
                    label: 'label.name',                    
                    validation: { required: true }
                  },									
                  description: {
                    label: 'label.description'  
                  }, 	
                  gslbdomainname: {
                    label: 'GSLB Domain Name',
                    validation: { required: true }										
                  },			
									gslblbmethod: {					
										label: 'Algorithm',					
										select: function(args) {
											var array1 = [{id: 'roundrobin', description: 'roundrobin'}, {id: 'leastconn', description: 'leastconn'}, {id: 'proximity', description: 'proximity'}];
											args.response.success({
												data: array1
											});														
										}
									},															
									gslbservicetype: {					
										label: 'Service Type',					
										select: function(args) {
											var array1 = [{id: 'tcp', description: 'tcp'}, {id: 'udp', description: 'udp'}];
											args.response.success({
												data: array1
											});														
										},
										validation: { required: true }				
									},		
									domainid: {					
										label: 'Domain',					
										select: function(args) {
											if(isAdmin() || isDomainAdmin()) {
												$.ajax({
													url: createURL('listDomains'),
													data: { 
														listAll: true,
														details: 'min'
													},
													success: function(json) {
														var array1 = [{id: '', description: ''}];
														var domains = json.listdomainsresponse.domain;
														if(domains != null && domains.length > 0) {
															for(var i = 0; i < domains.length; i++) {
																array1.push({id: domains[i].id, description: domains[i].path});
															}
														}
														args.response.success({
															data: array1
														});
													}
												});
											}
											else {
												args.response.success({
													data: null
												});
											}
										},
										isHidden: function(args) {
											if(isAdmin() || isDomainAdmin())
												return false;
											else
												return true;
										}
									},	
									account: { 
										label: 'Account',
										isHidden: function(args) {
											if(isAdmin() || isDomainAdmin())
												return false;
											else
												return true;
										}			
									}		
                }
              },
              action: function(args) {                
								var data = {
								  name: args.data.name,									
									regionid: args.context.regions[0].id,
									gslblbmethod: args.data.gslblbmethod,
									gslbstickysessionmethodname: 'sourceip',
									gslbdomainname: args.data.gslbdomainname,
									gslbservicetype: args.data.gslbservicetype
								};	
                if(args.data.description != null && args.data.description.length > 0)
								  $.extend(data, { description: args.data.description }); 
                if(args.data.domainid != null && args.data.domainid.length > 0)
								  $.extend(data, { domainid: args.data.domainid });  								  		
                if(args.data.account != null && args.data.account.length > 0)
								  $.extend(data, { account: args.data.account });   
								
                $.ajax({
                  url: createURL('createGlobalLoadBalancerRule'),
                  data: data,                 
                  success: function(json) {		
										var jid = json.creategloballoadbalancerruleresponse.jobid;										              
										args.response.success(
											{_custom:
											 {jobId: jid,
												getUpdatedItem: function(json) {	                          									  
													return json.queryasyncjobresultresponse.jobresult.globalloadbalancer;
												}
											 }
											}
										);										
                  }
                });
              },
              notification: {
                poll: pollAsyncJobResult
              }
            }
          },
										
          dataProvider: function(args) {
            if('regions' in args.context) {
              var data = {
                regionid: args.context.regions[0].id
              };
              $.ajax({
                url: createURL('listGlobalLoadBalancerRules'),
                data: data,
                success: function(json) {                  
                  var items = json.listgloballoadbalancerrulesresponse.globalloadbalancerrule;
                  args.response.success({
                    data: items
                  });
                }
              });
            }
            else {
              args.response.success({
                data: null
              });
            }
          },
										
					detailView: {
            name: 'GSLB details',
            viewAll: { path: 'regions.lbUnderGSLB', label: 'assigned load balancing' },
            actions: {              
							remove: {
                label: 'delete GSLB',
                messages: {
                  confirm: function(args) {
                    return 'Please confirm you want to delete this GSLB';
                  },
                  notification: function(args) {
                    return 'delete GSLB';
                  }
                },
                action: function(args) {								  
									var data = {
									  id: args.context.GSLB[0].id
									};
                  $.ajax({
                    url: createURL("deleteGlobalLoadBalancerRule"),
                    data: data,                    
                    success: function(json) {                      
											var jid = json.deletegloballoadbalancerruleresponse.jobid;
                      args.response.success({
											  _custom: {
												  jobId: jid
												}
											});											
                    }
                  });
                },
                notification: {
                  poll: pollAsyncJobResult
                }
              }
						},												
						tabs: {
              details: {
                title: 'label.details',
                fields: [
								 {
								   name: { label: 'label.name' }
								 },
                 {									  
                    description: { label: 'label.description' },
						        gslbdomainname: { label: 'GSLB Domain Name' },
						        gslblbmethod: { label: 'Algorithm' },
                    gslbservicetype: { label: 'Service Type' },										
                    id: { label: 'ID' }										
                  }
                ],
                dataProvider: function(args) {									  
									var data = {
										id: args.context.GSLB[0].id
									};
									$.ajax({
										url: createURL('listGlobalLoadBalancerRules'),
										data: data,
										success: function(json) {                  
											var item = json.listgloballoadbalancerrulesresponse.globalloadbalancerrule[0];
											args.response.success({
												data: item
											});
										}
									});									
                }
              }
            }						
					}					
        }
      },
					      
      portableIpRanges: {
        id: 'portableIpRanges',
        type: 'select',
        title: 'Portable IP Ranges',
        listView: {
          id: 'portableIpRanges',
          label: 'Portable IP Ranges',
          fields: {
            startip: { label: 'label.start.IP' },
            endip: { label: 'label.end.IP' },
            gateway: { label: 'label.gateway' },
            netmask: { label: 'label.netmask' },
            vlan: { label: 'label.vlan' }                    
          },
          dataProvider: function(args) {            
            $.ajax({
              url: createURL('listPortableIpRanges'),
              data: {
                regionid: args.context.regions[0].id
              },
              success: function(json) {                
                var items = json.listportableipresponse.portableiprange;
                args.response.success({                
                  data: items
                });
              },
              error: function(json) {
                args.response.error(parseXMLHttpResponse(json));
              }
            });
          },
          actions: {
            add: {
              label: 'Add Portable IP Range',
              messages: {               
                notification: function(args) {
                  return 'Add Portable IP Range';
                }
              },
              createForm: {
                title: 'Add Portable IP Range',
                fields: {
                  startip: {
                    label: 'label.start.IP',                    
                    validation: { required: true }
                  },
                  endip: {
                    label: 'label.end.IP',                    
                    validation: { required: true }
                  },
                  gateway: {
                    label: 'label.gateway',                    
                    validation: { required: true }
                  },
                  netmask: {
                    label: 'label.netmask',                    
                    validation: { required: true }
                  },
                  vlan: {
                    label: 'label.vlan',                    
                    validation: { required: false }
                  }
                }                
              },     
              action: function(args) {                
                var data = {
                  regionid: args.context.regions[0].id,
                  startip: args.data.startip,
                  endip: args.data.endip,
                  gateway: args.data.gateway,
                  netmask: args.data.netmask                      
                };       
                if(args.data.vlan != null && args.data.vlan.length > 0) {
                  $.extend(data, {
                    vlan: args.data.vlan
                  })
                }                  
                $.ajax({
                  url: createURL('createPortableIpRange'),
                  data: data,                 
                  success: function(json) {             
                    var jid = json.createportableiprangeresponse.jobid;
                    args.response.success({
                      _custom: { 
                        jobId: jid,
                        getUpdatedItem: function(json) {                          
                          return json.queryasyncjobresultresponse.jobresult.portableiprange;
                        }
                      }
                    });                    
                  },
                  error: function(data) {
                    args.response.error(parseXMLHttpResponse(data));
                  }
                });
              },
              notification: {
                poll: pollAsyncJobResult
              }    
            }
          },
          
          detailView: {
            name: 'Portable IP Range details',
            actions: {              
              remove: {
                label: 'Delete Portable IP Range',
                messages: {
                  confirm: function(args) {
                    return 'Please confirm you want to delete Portable IP Range';
                  },
                  notification: function(args) {
                    return 'Delete Portable IP Range';
                  }
                },
                action: function(args) {           
                  var data = {
                    id: args.context.portableIpRanges[0].id
                  };                
                  $.ajax({
                    url: createURL('deletePortableIpRange'),
                    data: data,
                    async: true,
                    success: function(json) {                
                      var jid = json.deleteportablepublicipresponse.jobid;
                      args.response.success({
                        _custom: { 
                          jobId: jid
                        }
                      });     
                    },
                    error: function(data) {
                      args.response.error(parseXMLHttpResponse(data));
                    }
                  });
                },
                notification: {
                  poll: pollAsyncJobResult
                }
              }
            }, 
            tabs: {
              details: {
                title: 'label.details',
                fields: [      
                  {
                    id: { label: 'label.id' }
                  },
                  {                    
                    startip: { label: 'label.start.IP' },
                    endip: { label: 'label.end.IP' },
                    gateway: { label: 'label.gateway' },
                    netmask: { label: 'label.netmask' },
                    vlan: { label: 'label.vlan' },
                    portableipaddress: { 
                      label: 'Portable IPs',
                      converter: function(args) {                       
                        var text1 = '';
                        if(args != null) {
                          for(var i = 0; i < args.length; i++) {
                            if(i > 0) {
                              text1 += ', ';
                            }                            
                            text1 += args[i].ipaddress;
                          }
                        }                        
                        return text1;
                      }
                    }
                  }
                ],
                dataProvider: function(args) {                       
                  $.ajax({
                    url: createURL('listPortableIpRanges'),
                    data: {
                      id: args.context.portableIpRanges[0].id
                    },
                    success: function(json) {                
                      var item = json.listportableipresponse.portableiprange[0];
                      args.response.success({                
                        data: item
                      });
                    },
                    error: function(json) {
                      args.response.error(parseXMLHttpResponse(json));
                    }
                  });  
                }
              }
            }   
          }
        }
      },      
            
      lbUnderGSLB: {
        id: 'lbUnderGSLB',
        type: 'select',
        title: 'assigned load balancing',
        listView: {
          section: 'lbUnderGSLB',
          id: 'lbUnderGSLB',
          label: 'assigned load balancing',
          fields: {
            name: { label: 'label.name' },
            publicport: { label: 'label.public.port' },
	          privateport: { label: 'label.private.port' },
	          algorithm: { label: 'label.algorithm' }
          },					
	        dataProvider: function(args) {		
	          var data = {
              id: args.context.GSLB[0].id
            };
            $.ajax({
              url: createURL('listGlobalLoadBalancerRules'),
              data: data,
              success: function(json) {    
                var items = json.listgloballoadbalancerrulesresponse.globalloadbalancerrule[0].loadbalancerrule;
                args.response.success({
                  data: items
                });
              }
            });	          
          },	        
	        actions: {            
            add: {
              label: 'assign more load balancing',
              messages: {                
                notification: function(args) {
                  return 'assign more load balancing';
                }
              },
              createForm: {
                title: 'assign more load balancing',              
                fields: {                  
                  loadbalancerrule: {
                    label: 'load balancing rule',                    
                    select: function(args) {		
		      var data = {
			globalloadbalancerruleid: args.context.GSLB[0].id,
			listAll: true
		      };
		      $.ajax({
			url: createURL('listLoadBalancerRules'),
			data: data,
			success: function(json) {
			  var allLbRules = json.listloadbalancerrulesresponse.loadbalancerrule;
                          var assignedLbRules = args.context.GSLB[0].loadbalancerrule;
                          var items = [];
                          if(allLbRules != null) {
                            for(var i = 0; i < allLbRules.length; i++) {  
                              var isAssigned = false;                            
                              if(assignedLbRules != null) {
                                for(var k = 0; k < assignedLbRules.length; k++) {
                                  if(allLbRules[i].id == assignedLbRules[k].id) {
                                    isAssigned = true;
                                    break; 
                                  }
                                }
                              }
                              if(isAssigned == false) {
                                items.push(allLbRules[i]);
                              }
                            }
                          }                        
			  args.response.success({								 
			    data: items,
			    descriptionField: 'name'
			  });													
			}
		      });																						
                    }
                  }  
                }
              },
              action: function(args) {							  
		var data = {
		  id: args.context.GSLB[0].id,
		  loadbalancerrulelist: args.data.loadbalancerrule
		};			
                $.ajax({
                  url: createURL('assignToGlobalLoadBalancerRule'),
                  data: data,                 
                  success: function(json) {
                    var jid = json.assigntogloballoadbalancerruleresponse.jobid;
                    args.response.success(
                      {_custom:
                       {jobId: jid,
                        getUpdatedItem: function(json) {
                          return json.queryasyncjobresultresponse.jobresult.loadbalancerrule;
                        }
                       }
                      }
                    );
                  }
                });
              },
              notification: {
                poll: pollAsyncJobResult
              }
            }
					},						
									
					detailView: {
            name: 'load balancing details',            
            actions: {              
              remove: {
                label: 'remove load balancing from this GSLB',
                messages: {
                  notification: function() { 
									  return 'remove load balancing from GSLB'; 
									},
                  confirm: function() { 
									  return 'Please confirm you want to remove load balancing from GSLB'; 
									}
                },               
                action: function(args) {								                
                  $.ajax({
                    url: createURL('removeFromGlobalLoadBalancerRule'),
                    data: { 
										  id: args.context.lbUnderGSLB[0].id 
										},
                    success: function(json) {                      							
                      var jid = json.removefromloadbalancerruleresponse.jobid;
                      args.response.success({
											  _custom: {
												  jobId: jid
												}
											});												
                    }
                  });
                },		
								notification: {
                  poll: pollAsyncJobResult
                }								
              }
            },
            tabs: {
              details: {
                title: 'label.details',
                fields: [
                  {
                    name: { label: 'label.name' }
                  },
                  {																
										publicport: { label: 'label.public.port' },
										privateport: { label: 'label.private.port' },
										algorithm: { label: 'label.algorithm' },
										publicip: { label: 'label.public.ip' },	
                    state: { label: 'label.state' },												
										id: { label: 'label.id' },
                    cidrlist: { label: 'label.cidr' },
                    domain: { label: 'label.domain' },
                    account: { label: 'label.account' }                    								
                  }
                ],
                dataProvider: function(args) {									
									$.ajax({
										url: createURL('listLoadBalancerRules'),
										data: {
										  id: args.context.lbUnderGSLB[0].id 
										},
										success: function(json) {
											var item = json.listloadbalancerrulesresponse.loadbalancerrule[0];
											args.response.success({								 
												data: item
											});
										}
									});		
                }
              }
            }
          }
				}
			}			
    }
  };
		
	var regionActionfilter = function(args) {	  
    var allowedActions = [];    
    if(isAdmin()) {        
      allowedActions.push("edit");
			allowedActions.push("remove");
    } 
    return allowedActions;
  }	
	
})(cloudStack);