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

package com.cloud.stack;

import java.util.List;

import org.apache.log4j.Logger;

import com.google.gson.reflect.TypeToken;

import com.cloud.stack.models.ApiConstants;
import com.cloud.stack.models.CloudStackAccount;
import com.cloud.stack.models.CloudStackCapabilities;
import com.cloud.stack.models.CloudStackDiskOffering;
import com.cloud.stack.models.CloudStackEvent;
import com.cloud.stack.models.CloudStackEventType;
import com.cloud.stack.models.CloudStackExtractTemplate;
import com.cloud.stack.models.CloudStackIdentifier;
import com.cloud.stack.models.CloudStackInfoResponse;
import com.cloud.stack.models.CloudStackInstanceGroup;
import com.cloud.stack.models.CloudStackIpAddress;
import com.cloud.stack.models.CloudStackKeyPair;
import com.cloud.stack.models.CloudStackKeyValue;
import com.cloud.stack.models.CloudStackLoadBalancerRule;
import com.cloud.stack.models.CloudStackNetwork;
import com.cloud.stack.models.CloudStackNetworkOffering;
import com.cloud.stack.models.CloudStackOsCategory;
import com.cloud.stack.models.CloudStackOsType;
import com.cloud.stack.models.CloudStackPasswordData;
import com.cloud.stack.models.CloudStackPortForwardingRule;
import com.cloud.stack.models.CloudStackResourceLimit;
import com.cloud.stack.models.CloudStackResourceTag;
import com.cloud.stack.models.CloudStackSecurityGroup;
import com.cloud.stack.models.CloudStackServiceOffering;
import com.cloud.stack.models.CloudStackSnapshot;
import com.cloud.stack.models.CloudStackSnapshotPolicy;
import com.cloud.stack.models.CloudStackTemplate;
import com.cloud.stack.models.CloudStackTemplatePermission;
import com.cloud.stack.models.CloudStackUserVm;
import com.cloud.stack.models.CloudStackVolume;
import com.cloud.stack.models.CloudStackZone;

/**
 * The goal here is to wrap the actual CloudStack API calls...
 *
 *
 */
public class CloudStackApi {
    protected final static Logger logger = Logger.getLogger(CloudStackApi.class);

    private CloudStackClient _client;

    private String apiKey;
    private String secretKey;

    /**
     *
     */
    public CloudStackApi(String cloudStackServiceHost, String port, Boolean bSslEnabled) {
        if (port != null) {
            // initialize port to 8080, incase port is NULL
            int ourPort = 8080;
            if (port != null)
                ourPort = Integer.parseInt(port);
            _client = new CloudStackClient(cloudStackServiceHost, ourPort, bSslEnabled);
        } else {
            _client = new CloudStackClient(cloudStackServiceHost);
        }
        apiKey = null;
        secretKey = null;
    }

    /**
     * @return the apiKey
     */
    public String getApiKey() {
        return apiKey;
    }

    /**
     * @return the secretKey
     */
    public String getSecretKey() {
        return secretKey;
    }

    /**
     * @param apiKey the apiKey to set
     */
    public void setApiKey(String apiKey) {
        this.apiKey = apiKey;
    }

    /**
     * @param secretKey the secretKey to set
     */
    public void setSecretKey(String secretKey) {
        this.secretKey = secretKey;
    }

    // Virtual Machines

    /**
     * deploy a virtual machine
     *
     * @param serviceOfferingId
     * @param templateId
     * @param zoneId
     * @param account
     * @param diskOfferingId
     * @param displayName
     * @param domainId
     * @param group
     * @param hostId
     * @param hypervisor
     * @param keyPair
     * @param name
     * @param networkId
     * @param securityGroupIds
     * @param securityGroupNames
     * @param size
     * @param userData
     * @return
     * @throws Exception
     */
    public CloudStackUserVm deployVirtualMachine(String serviceOfferingId, String templateId, String zoneId, String account, String diskOfferingId, String displayName,
        String domainId, String group, String hostId, String hypervisor, String keyPair, String name, String networkId, String securityGroupIds,
        String securityGroupNames, Long size, String userData) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DEPLOY_VIRTUAL_MACHINE);
        if (cmd != null) {
            // these are required
            cmd.setParam(ApiConstants.SERVICE_OFFERING_ID, serviceOfferingId);
            cmd.setParam(ApiConstants.TEMPLATE_ID, templateId);
            cmd.setParam(ApiConstants.ZONE_ID, zoneId);
            // these aren't
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (diskOfferingId != null)
                cmd.setParam(ApiConstants.DISK_OFFERING_ID, diskOfferingId);
            if (displayName != null)
                cmd.setParam(ApiConstants.DISPLAY_NAME, displayName);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (group != null)
                cmd.setParam(ApiConstants.GROUP, group);
            if (hostId != null)
                cmd.setParam(ApiConstants.HOST_ID, hostId);
            if (hypervisor != null)
                cmd.setParam(ApiConstants.HYPERVISOR, hypervisor);
            if (keyPair != null)
                cmd.setParam(ApiConstants.SSH_KEYPAIR, keyPair);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (networkId != null)
                cmd.setParam(ApiConstants.NETWORK_IDS, networkId);
            if (securityGroupIds != null)
                cmd.setParam(ApiConstants.SECURITY_GROUP_IDS, securityGroupIds);
            if (securityGroupNames != null)
                cmd.setParam(ApiConstants.SECURITY_GROUP_NAMES, securityGroupNames);
            if (size != null)
                cmd.setParam(ApiConstants.SIZE, size.toString());
            if (userData != null)
                cmd.setParam(ApiConstants.USER_DATA, userData);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DEPLOY_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);

    }

    /**
     * destroy's a virtual machine
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackUserVm destroyVirtualMachine(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DESTROY_VIRTUAL_MACHINE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DESTROY_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
    }

    /**
     * reboot a virtual machine
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackUserVm rebootVirtualMachine(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.REBOOT_VIRTUAL_MACHINE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.REBOOT_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
    }

    /**
     * start a virtual machine
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackUserVm startVirtualMachine(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.START_VIRTUAL_MACHINE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.START_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
    }

    /**
     * stop a virtual machine
     *
     * @param id
     * @param forced
     * @return
     * @throws Exception
     */
    public CloudStackUserVm stopVirtualMachine(String id, Boolean forced) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.STOP_VIRTUAL_MACHINE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (forced != null)
                cmd.setParam(ApiConstants.FORCED, forced.toString());
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.STOP_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
    }

    /**
     * reset password for virtual machine
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackUserVm resetPasswordForVirtualMachine(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.RESET_PASSWORD_FOR_VIRTUAL_MACHINE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.RESET_PASSWORD_FOR_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
    }

    /**
     * change service for virtual machine
     *
     * @param id
     * @param serviceOfferingId
     * @return
     * @throws Exception
     */
    public CloudStackUserVm changeServiceForVirtualMachine(String id, String serviceOfferingId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CHANGE_SERVICE_FOR_VIRTUAL_MACHINE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            cmd.setParam(ApiConstants.SERVICE_OFFERING_ID, serviceOfferingId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CHANGE_SERVICE_FOR_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
    }

    /**
     * update a virtual machine
     *
     * @param id
     * @param displayName
     * @param group
     * @param haEnable
     * @param osTypeId
     * @param userData
     * @return
     * @throws Exception
     */
    public CloudStackUserVm updateVirtualMachine(String id, String displayName, String group, Boolean haEnable, String osTypeId, String userData) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_VIRTUAL_MACHINE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (displayName != null)
                cmd.setParam(ApiConstants.DISPLAY_NAME, displayName);
            if (group != null)
                cmd.setParam(ApiConstants.GROUP, group);
            if (haEnable != null)
                cmd.setParam(ApiConstants.HA_ENABLE, haEnable.toString());
            if (osTypeId != null)
                cmd.setParam(ApiConstants.OS_TYPE_ID, osTypeId);
            if (userData != null)
                cmd.setParam(ApiConstants.USER_DATA, userData);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.UPDATE_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);

    }

    /**
     * list virtual machines
     *
     * @param account
     * @param accountId
     * @param forVirtualNetwork
     * @param groupId
     * @param hostId
     * @param hypervisor
     * @param id
     * @param isRecursive
     * @param keyWord
     * @param name
     * @param networkId
     * @param podId
     * @param state
     * @param storageId
     * @param zoneId
     * @return
     * @throws Exception
     */
    public List<CloudStackUserVm> listVirtualMachines(String account, String accountId, Boolean listAll, Boolean forVirtualNetwork, String groupId, String hostId,
        String hypervisor, String id, Boolean isRecursive, String keyWord, String name, String networkId, String podId, String state, String storageId, String zoneId,
        List<CloudStackKeyValue> resourceTags) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_VIRTUAL_MACHINES);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (accountId != null)
                cmd.setParam(ApiConstants.ACCOUNT_ID, accountId);
            if (listAll != null)
                cmd.setParam(ApiConstants.LIST_ALL, listAll.toString());
            if (forVirtualNetwork != null)
                cmd.setParam(ApiConstants.FOR_VIRTUAL_NETWORK, forVirtualNetwork.toString());
            if (groupId != null)
                cmd.setParam(ApiConstants.GROUP_ID, groupId);
            if (hostId != null)
                cmd.setParam(ApiConstants.HOST_ID, hostId);
            if (hypervisor != null)
                cmd.setParam(ApiConstants.HYPERVISOR, hypervisor);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (isRecursive != null)
                cmd.setParam(ApiConstants.IS_RECURSIVE, isRecursive.toString());
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (networkId != null)
                cmd.setParam(ApiConstants.NETWORK_ID, networkId);
            if (podId != null)
                cmd.setParam(ApiConstants.POD_ID, podId);
            if (state != null)
                cmd.setParam(ApiConstants.STATE, state);
            if (storageId != null)
                cmd.setParam(ApiConstants.STORAGE_ID, storageId);
            if (zoneId != null)
                cmd.setParam(ApiConstants.ZONE_ID, zoneId);
            if (resourceTags != null && resourceTags.size() > 0)
                cmd = setParams(cmd, null, null, resourceTags);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_VIRTUAL_MACHINES_RESPONSE, ApiConstants.VIRTUAL_MACHINE,
            new TypeToken<List<CloudStackUserVm>>() {
            }.getType());
    }

    /**
     * get password from virtual machine
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackPasswordData getVMPassword(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.GET_VM_PASSWORD);
        if (cmd != null)
            cmd.setParam(ApiConstants.ID, id);
        // TODO: This probably isn't right.  Need to test with an instance that has a VM Password
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.GET_VM_PASSWORD_RESPONSE, ApiConstants.PASSWORD, CloudStackPasswordData.class);
    }

    // Templates
//<a href="user/createTemplate.html">createTemplate (A)</a>
    /**
     * create a Template
     *
     * @param displayText
     * @param name
     * @param osTypeId
     * @param bits
     * @param isFeatured
     * @param isPublic
     * @param passwordEnabled
     * @param requiresHVM
     * @param snapshotId
     * @param volumeId
     * @return
     * @throws Exception
     */
    public CloudStackTemplate createTemplate(String displayText, String name, String osTypeId, String bits, Boolean isFeatured, Boolean isPublic,
        Boolean passwordEnabled, Boolean requiresHVM, String snapshotId, String volumeId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_TEMPLATE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
            cmd.setParam(ApiConstants.NAME, name);
            cmd.setParam(ApiConstants.OS_TYPE_ID, osTypeId);
            if (bits != null)
                cmd.setParam(ApiConstants.BITS, bits);
            if (isFeatured != null)
                cmd.setParam(ApiConstants.IS_FEATURED, isFeatured.toString());
            if (isPublic != null)
                cmd.setParam(ApiConstants.IS_PUBLIC, isPublic.toString());
            if (passwordEnabled != null)
                cmd.setParam(ApiConstants.PASSWORD_ENABLED, passwordEnabled.toString());
            if (requiresHVM != null)
                cmd.setParam(ApiConstants.REQUIRES_HVM, requiresHVM.toString());
            if (snapshotId != null)
                cmd.setParam(ApiConstants.SNAPSHOT_ID, snapshotId);
            if (volumeId != null)
                cmd.setParam(ApiConstants.VOLUME_ID, volumeId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CREATE_TEMPLATE_RESPONSE, ApiConstants.TEMPLATE, CloudStackTemplate.class);
    }

    /**
     * register a template
     *
     * @param displayText
     * @param format
     * @param hypervisor
     * @param name
     * @param osTypeId
     * @param url
     * @param zoneId
     * @param account
     * @param bits
     * @param checksum
     * @param domainId
     * @param isExtractable
     * @param isFeatured
     * @param isPublic
     * @param passwordEnabled
     * @param requiresHVM
     * @return
     * @throws Exception
     */
    public List<CloudStackTemplate> registerTemplate(String displayText, String format, String hypervisor, String name, String osTypeId, String url, String zoneId,
        String account, String bits, String checksum, String domainId, Boolean isExtractable, Boolean isFeatured, Boolean isPublic, Boolean passwordEnabled,
        Boolean requiresHVM) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.REGISTER_TEMPLATE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
            cmd.setParam(ApiConstants.FORMAT, format);
            cmd.setParam(ApiConstants.HYPERVISOR, hypervisor);
            cmd.setParam(ApiConstants.NAME, name);
            cmd.setParam(ApiConstants.OS_TYPE_ID, osTypeId);
            cmd.setParam(ApiConstants.URL, url);
            cmd.setParam(ApiConstants.ZONE_ID, zoneId);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (bits != null)
                cmd.setParam(ApiConstants.BITS, bits);
            if (checksum != null)
                cmd.setParam(ApiConstants.CHECKSUM, checksum);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (isExtractable != null)
                cmd.setParam(ApiConstants.IS_EXTRACTABLE, isExtractable.toString());
            if (isFeatured != null)
                cmd.setParam(ApiConstants.IS_FEATURED, isFeatured.toString());
            if (isPublic != null)
                cmd.setParam(ApiConstants.IS_PUBLIC, isPublic.toString());
            if (passwordEnabled != null)
                cmd.setParam(ApiConstants.PASSWORD_ENABLED, passwordEnabled.toString());
            if (requiresHVM != null)
                cmd.setParam(ApiConstants.REQUIRES_HVM, requiresHVM.toString());
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.REGISTER_TEMPLATE_RESPONSE, ApiConstants.TEMPLATE, new TypeToken<List<CloudStackTemplate>>() {
        }.getType());
    }

    /**
     * update's a template
     *
     * @param id
     * @param bootable
     * @param displayText
     * @param format
     * @param name
     * @param osTypeId
     * @param passwordEnabled
     * @return
     * @throws Exception
     */
    public CloudStackTemplate updateTemplate(String id, Boolean bootable, String displayText, String format, String name, String osTypeId, Boolean passwordEnabled)
        throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_TEMPLATE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (bootable != null)
                cmd.setParam(ApiConstants.BOOTABLE, bootable.toString());
            if (displayText != null)
                cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
            if (format != null)
                cmd.setParam(ApiConstants.FORMAT, format);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (osTypeId != null)
                cmd.setParam(ApiConstants.OS_TYPE_ID, osTypeId);
            if (passwordEnabled != null)
                cmd.setParam(ApiConstants.PASSWORD_ENABLED, passwordEnabled.toString());
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.UPDATE_TEMPLATE_RESPONSE, ApiConstants.TEMPLATE, CloudStackTemplate.class);
    }

    /**
     * copy a template
     *
     * @param id (required)
     * @param destZoneId (required)
     * @param sourceZoneId (required)
     * @return
     * @throws Exception
     */
    public CloudStackTemplate copyTemplate(String id, String destZoneId, String sourceZoneId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.COPY_TEMPLATE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            cmd.setParam(ApiConstants.DESTINATION_ZONE_ID, destZoneId);
            cmd.setParam(ApiConstants.SOURCE_ZONE_ID, sourceZoneId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.COPY_TEMPLATE_RESPONSE, ApiConstants.TEMPLATE, CloudStackTemplate.class);
    }

    /**
     * Deletes a template from the system. All virtual machines using the deleted template will not be affected.
     *
     * @param id (required)
     * @param zoneId
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse deleteTemplate(String id, String zoneId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_TEMPLATE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (zoneId != null)
                cmd.setParam(ApiConstants.ZONE_ID, zoneId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DELETE_TEMPLATE_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * List all public, private, and privileged templates
     *
     * @param templateFilter (required)
     * @param account
     * @param domainId
     * @param hypervisor
     * @param id
     * @param keyWord
     * @param name
     * @param zoneId
     * @return
     * @throws Exception
     */
    public List<CloudStackTemplate> listTemplates(String templateFilter, String account, String domainId, String hypervisor, String id, String keyWord, String name,
        String zoneId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_TEMPLATES);
        if (cmd != null) {
            cmd.setParam(ApiConstants.TEMPLATE_FILTER, templateFilter);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (hypervisor != null)
                cmd.setParam(ApiConstants.HYPERVISOR, hypervisor);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (zoneId != null)
                cmd.setParam(ApiConstants.ZONE_ID, zoneId);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_TEMPLATES_RESPONSE, ApiConstants.TEMPLATE, new TypeToken<List<CloudStackTemplate>>() {
        }.getType());
    }

    /**
     * Updates a template visibility permissions. A public template is visible to all accounts within the same domain.
     * A private template is visible only to the owner of the template. A priviledged template is a private template with account
     * permissions added. Only accounts specified under the template permissions are visible to them.
     *
     * @param id
     * @param accounts
     * @param isExtractable
     * @param isFeatured
     * @param isPublic
     * @param op
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse updateTemplatePermissions(String id, String accounts, Boolean isExtractable, Boolean isFeatured, Boolean isPublic, String op)
        throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_TEMPLATE_PERMISSIONS);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (accounts != null)
                cmd.setParam(ApiConstants.ACCOUNTS, accounts);
            if (isExtractable != null)
                cmd.setParam(ApiConstants.IS_EXTRACTABLE, isExtractable.toString());
            if (isFeatured != null)
                cmd.setParam(ApiConstants.IS_FEATURED, isFeatured.toString());
            if (isPublic != null)
                cmd.setParam(ApiConstants.IS_PUBLIC, isPublic.toString());
            if (op != null)
                cmd.setParam(ApiConstants.OP, op);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.UPDATE_TEMPLATE_PERMISSIONS_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * List template visibility and all accounts that have permissions to view this template.
     *
     * @param id
     * @param account
     * @param domainId
     * @return
     * @throws Exception
     */
    public CloudStackTemplatePermission listTemplatePermissions(String id, String account, String domainId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_TEMPLATE_PERMISSIONS);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.LIST_TEMPLATE_PERMISSIONS_RESPONSE, ApiConstants.TEMPLATE_PERMISSION,
            CloudStackTemplatePermission.class);
    }

    /**
     * Extracts a template
     *
     * @param id
     * @param mode
     * @param zoneId
     * @param url
     * @return
     * @throws Exception
     */
    public CloudStackExtractTemplate extractTemplate(String id, String mode, String zoneId, String url) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.EXTRACT_TEMPLATE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            cmd.setParam(ApiConstants.MODE, mode);
            cmd.setParam(ApiConstants.ZONE_ID, zoneId);
            if (url != null)
                cmd.setParam(ApiConstants.URL, url);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.EXTRACT_TEMPLATE_RESPONSE, null, CloudStackExtractTemplate.class);
    }

    // ISO's
    /**
     * Attaches an ISO to a virtual machine
     *
     * @param id
     * @param virtualMachineId
     * @return
     * @throws Exception
     */
    public CloudStackUserVm attachIso(String id, String virtualMachineId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.ATTACH_ISO);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.ATTACH_ISO_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
    }

    /**
     * Detaches any ISO file (if any) currently attached to a virtual machine.
     *
     * @param virtualMachineId
     * @return
     * @throws Exception
     */
    public CloudStackUserVm detachIso(String virtualMachineId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DETACH_ISO);
        if (cmd != null) {
            cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DETACH_ISO_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
    }

    /**
     * Lists all available ISO files.
     *
     * @param account
     * @param bootable
     * @param domainId
     * @param hypervisor
     * @param id
     * @param isoFilter
     * @param isPublic
     * @param isReady
     * @param keyWord
     * @param name
     * @param zoneId
     * @return
     * @throws Exception
     */
    public List<CloudStackTemplate> listIsos(String account, Boolean bootable, String domainId, String hypervisor, String id, String isoFilter, Boolean isPublic,
        Boolean isReady, String keyWord, String name, String zoneId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_ISOS);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (bootable != null)
                cmd.setParam(ApiConstants.BOOTABLE, bootable.toString());
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (hypervisor != null)
                cmd.setParam(ApiConstants.HYPERVISOR, hypervisor);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (isoFilter != null)
                cmd.setParam(ApiConstants.ISO_FILTER, isoFilter);
            if (isPublic != null)
                cmd.setParam(ApiConstants.IS_PUBLIC, isPublic.toString());
            if (isReady != null)
                cmd.setParam(ApiConstants.IS_READY, isReady.toString());
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (zoneId != null)
                cmd.setParam(ApiConstants.ZONE_ID, zoneId);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_ISOS_RESPONSE, ApiConstants.TEMPLATE, new TypeToken<List<CloudStackTemplate>>() {
        }.getType());
    }

    /**
     * Registers an existing ISO into the Cloud.com Cloud.
     *
     * @param displayText
     * @param name
     * @param url
     * @param zoneId
     * @param account
     * @param bootable
     * @param domainId
     * @param isExtractable
     * @param isFeatured
     * @param isPublic
     * @param osTypeId
     * @return
     * @throws Exception
     */
    public CloudStackTemplate registerIso(String displayText, String name, String url, String zoneId, String account, Boolean bootable, String domainId,
        Boolean isExtractable, Boolean isFeatured, Boolean isPublic, String osTypeId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.REGISTER_ISO);
        if (cmd != null) {
            cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
            cmd.setParam(ApiConstants.NAME, name);
            cmd.setParam(ApiConstants.URL, url);
            cmd.setParam(ApiConstants.ZONE_ID, zoneId);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (bootable != null)
                cmd.setParam(ApiConstants.BOOTABLE, bootable.toString());
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (isExtractable != null)
                cmd.setParam(ApiConstants.IS_EXTRACTABLE, isExtractable.toString());
            if (isFeatured != null)
                cmd.setParam(ApiConstants.IS_FEATURED, isFeatured.toString());
            if (isPublic != null)
                cmd.setParam(ApiConstants.IS_PUBLIC, isPublic.toString());
            if (osTypeId != null)
                cmd.setParam(ApiConstants.OS_TYPE_ID, osTypeId);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.REGISTER_ISO_RESPONSE, ApiConstants.TEMPLATE, CloudStackTemplate.class);
    }

    /**
     * Updates an ISO
     *
     * @param id
     * @param bootable
     * @param displayText
     * @param format
     * @param name
     * @param osTypeId
     * @param passwordEnabled
     * @return
     * @throws Exception
     */
    public CloudStackTemplate updateIso(String id, Boolean bootable, String displayText, String format, String name, String osTypeId, Boolean passwordEnabled)
        throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_ISO);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (bootable != null)
                cmd.setParam(ApiConstants.BOOTABLE, bootable.toString());
            if (displayText != null)
                cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
            if (format != null)
                cmd.setParam(ApiConstants.FORMAT, format);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (osTypeId != null)
                cmd.setParam(ApiConstants.OS_TYPE_ID, osTypeId);
            if (passwordEnabled != null)
                cmd.setParam(ApiConstants.PASSWORD_ENABLED, passwordEnabled.toString());
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.UPDATE_ISO_RESPONSE, ApiConstants.TEMPLATE, CloudStackTemplate.class);
    }

    /**
     * Deletes an ISO
     *
     * @param id
     * @param zoneId
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse deleteIso(String id, String zoneId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_ISO);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            cmd.setParam(ApiConstants.ZONE_ID, zoneId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DELETE_ISO_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * Copies a template from one zone to another
     *
     * @param id
     * @param destZoneId
     * @param sourceZoneId
     * @return
     * @throws Exception
     */
    public CloudStackTemplate copyIso(String id, String destZoneId, String sourceZoneId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.COPY_ISO);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            cmd.setParam(ApiConstants.DESTINATION_ZONE_ID, destZoneId);
            cmd.setParam(ApiConstants.SOURCE_ZONE_ID, sourceZoneId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.COPY_ISO_RESPONSE, ApiConstants.TEMPLATE, CloudStackTemplate.class);
    }

    /**
     * Updates ISO permissions
     *
     * @param id
     * @param accounts
     * @param isExtractable
     * @param isFeatured
     * @param isPublic
     * @param op
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse updateIsoPermissions(String id, String accounts, Boolean isExtractable, Boolean isFeatured, Boolean isPublic, String op)
        throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_ISO_PERMISSIONS);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (accounts != null)
                cmd.setParam(ApiConstants.ACCOUNTS, accounts);
            if (isExtractable != null)
                cmd.setParam(ApiConstants.IS_EXTRACTABLE, isExtractable.toString());
            if (isFeatured != null)
                cmd.setParam(ApiConstants.IS_FEATURED, isFeatured.toString());
            if (isPublic != null)
                cmd.setParam(ApiConstants.IS_PUBLIC, isPublic.toString());
            if (op != null)
                cmd.setParam(ApiConstants.OP, op);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.UPDATE_ISO_PERMISSIONS_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * List template visibility and all accounts that have permissions to view this template
     * @param id
     * @param account
     * @param domainId
     * @return
     * @throws Exception
     */
    public List<CloudStackTemplatePermission> listIsoPermissions(String id, String account, String domainId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_ISO_PERMISSIONS);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_ISO_PERMISSIONS_RESPONSE, ApiConstants.TEMPLATE,
            new TypeToken<List<CloudStackTemplatePermission>>() {
            }.getType());
    }

    /**
     * Extracts an iso
     *
     * @param id
     * @param mode
     * @param zoneId
     * @param url
     * @return
     * @throws Exception
     */
    public CloudStackExtractTemplate extractIso(String id, String mode, String zoneId, String url) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.EXTRACT_ISO);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            cmd.setParam(ApiConstants.MODE, mode);
            cmd.setParam(ApiConstants.ZONE_ID, zoneId);
            if (url != null)
                cmd.setParam(ApiConstants.URL, url);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.EXTRACT_ISO_RESPONSE, ApiConstants.TEMPLATE, CloudStackExtractTemplate.class);
    }

    // Volumes
    /**
     * Attaches a disk volume to a virtual machine
     *
     * @param id
     * @param virtualMachineId
     * @param deviceId
     * @return
     * @throws Exception
     */
    public CloudStackVolume attachVolume(String id, String virtualMachineId, String deviceId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.ATTACH_VOLUME);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
            if (deviceId != null)
                cmd.setParam(ApiConstants.DEVICE_ID, deviceId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.ATTACH_VOLUME_RESPONSE, ApiConstants.VOLUME, CloudStackVolume.class);
    }

    /**
     * Detaches a disk volume from a virtual machine
     *
     * @param deviceId
     * @param id
     * @param virtualMachineId
     * @return
     * @throws Exception
     */
    public CloudStackVolume detachVolume(String deviceId, String id, String virtualMachineId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DETACH_VOLUME);
        if (cmd != null) {
            if (deviceId != null)
                cmd.setParam(ApiConstants.DEVICE_ID, deviceId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (virtualMachineId != null)
                cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DETACH_VOLUME_RESPONSE, ApiConstants.VOLUME, CloudStackVolume.class);
    }

    /**
     * Creates a disk volume from a disk offering. This disk volume must still be attached to a virtual machine to make use of it
     *
     * @param name
     * @param account
     * @param diskOfferingId
     * @param domainId
     * @param size
     * @param snapshotId
     * @param zoneId
     * @return
     * @throws Exception
     */
    public CloudStackVolume createVolume(String name, String account, String diskOfferingId, String domainId, Long size, String snapshotId, String zoneId)
        throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_VOLUME);
        if (cmd != null) {
            cmd.setParam(ApiConstants.NAME, name);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (diskOfferingId != null)
                cmd.setParam(ApiConstants.DISK_OFFERING_ID, diskOfferingId);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (size != null)
                cmd.setParam(ApiConstants.SIZE, size.toString());
            if (snapshotId != null)
                cmd.setParam(ApiConstants.SNAPSHOT_ID, snapshotId);
            if (zoneId != null)
                cmd.setParam(ApiConstants.ZONE_ID, zoneId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CREATE_VOLUME_RESPONSE, ApiConstants.VOLUME, CloudStackVolume.class);
    }

    /**
     * Deletes a detached disk volume
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse deleteVolume(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_VOLUME);
        if (cmd != null)
            cmd.setParam(ApiConstants.ID, id);
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DELETE_VOLUME_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * Lists all volumes
     *
     * @param account
     * @param domainId
     * @param hostId
     * @param id
     * @param isRecursive
     * @param keyWord
     * @param name
     * @param podId
     * @param type
     * @param virtualMachineId
     * @param zoneId
     * @return
     * @throws Exception
     */
    public List<CloudStackVolume> listVolumes(String account, String domainId, String hostId, String id, Boolean isRecursive, String keyWord, String name, String podId,
        String type, String virtualMachineId, String zoneId, List<CloudStackKeyValue> resourceTags) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_VOLUMES);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (hostId != null)
                cmd.setParam(ApiConstants.HOST_ID, hostId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (isRecursive != null)
                cmd.setParam(ApiConstants.IS_RECURSIVE, isRecursive.toString());
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (podId != null)
                cmd.setParam(ApiConstants.POD_ID, podId);
            if (type != null)
                cmd.setParam(ApiConstants.TYPE, type);
            if (virtualMachineId != null)
                cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
            if (zoneId != null)
                cmd.setParam(ApiConstants.ZONE_ID, zoneId);
            if (resourceTags != null && resourceTags.size() > 0)
                cmd = setParams(cmd, null, null, resourceTags);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_VOLUMES_RESPONSE, ApiConstants.VOLUME, new TypeToken<List<CloudStackVolume>>() {
        }.getType());
    }

    /**
     * Extracts volume
     *
     * @param id
     * @param mode
     * @param zoneId
     * @param url
     * @return
     * @throws Exception
     */
    public CloudStackExtractTemplate extractVolume(String id, String mode, String zoneId, String url) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.EXTRACT_VOLUME);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            cmd.setParam(ApiConstants.MODE, mode);
            cmd.setParam(ApiConstants.ZONE_ID, zoneId);
            if (url != null)
                cmd.setParam(ApiConstants.URL, url);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.EXTRACT_VOLUME_RESPONSE, ApiConstants.VOLUME, CloudStackExtractTemplate.class);
    }

    //Tags
    /**
     * Create tags
     *
     * @param resource type
     * @param resource id's
     * @param tags
     * @return
     * @throws Exception
     *
     */
    public CloudStackInfoResponse createTags(String resourceType, List<String> resourceIds, List<CloudStackKeyValue> resourceTags) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_TAGS);
        cmd = setParams(cmd, resourceType, resourceIds, resourceTags);
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CREATE_TAGS_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * Delete tags
     *
     * @param resource type
     * @param resource id's
     * @param tags
     * @return
     * @throws Exception
     *
     */
    public CloudStackInfoResponse deleteTags(String resourceType, List<String> resourceIds, List<CloudStackKeyValue> resourceTags) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_TAGS);
        cmd = setParams(cmd, resourceType, resourceIds, resourceTags);
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DELETE_TAGS_RESPONSE, null, CloudStackInfoResponse.class);
    }

    public List<CloudStackResourceTag> listTags(String account, String domainId, Boolean isRecursive, Boolean listAll, String keyWord) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_TAGS);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (isRecursive != null)
                cmd.setParam(ApiConstants.IS_RECURSIVE, isRecursive.toString());
            if (listAll != null)
                cmd.setParam(ApiConstants.LIST_ALL, listAll.toString());
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_TAGS_RESPONSE, ApiConstants.TAG, new TypeToken<List<CloudStackResourceTag>>() {
        }.getType());
    }

    private CloudStackCommand setParams(CloudStackCommand cmd, String resourceType, List<String> resourceIds, List<CloudStackKeyValue> resourceTags) {
        if (cmd != null) {
            if (resourceType != null)
                cmd.setParam(ApiConstants.RESOURCE_TYPE, resourceType);
            if (resourceIds != null && resourceIds.size() > 0) {
                String resourceIdList = resourceIds.get(0);
                for (int i = 1; i < resourceIds.size(); i++)
                    resourceIdList = resourceIdList.concat("," + resourceIds.get(i));
                cmd.setParam(ApiConstants.RESOURCE_IDS, resourceIdList);
            }
            if (resourceTags != null && resourceTags.size() > 0) {
                int i = 0;
                for (CloudStackKeyValue resourceTag : resourceTags) {
                    cmd.setParam(ApiConstants.TAGS + "[" + i + "].key", resourceTag.getKey());
                    if (resourceTag.getValue() != null)
                        cmd.setParam(ApiConstants.TAGS + "[" + i + "].value", resourceTag.getValue());
                    i++;
                }
            }
        }
        return cmd;
    }

    // Security Groups
    /**
     * Creates a security group
     *
     * @param name
     * @param account
     * @param description
     * @param domainId
     * @return
     * @throws Exception
     */
    public CloudStackSecurityGroup createSecurityGroup(String name, String account, String description, String domainId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_SECURITY_GROUP);
        if (cmd != null) {
            cmd.setParam(ApiConstants.NAME, name);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (description != null)
                cmd.setParam(ApiConstants.DESCRIPTION, description);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CREATE_SECURITY_GROUP_RESPONSE, ApiConstants.SECURITY_GROUP, CloudStackSecurityGroup.class);

    }

    /**
     * Deletes a security group
     *
     * @param account
     * @param domainId
     * @param id
     * @param name
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse deleteSecurityGroup(String account, String domainId, String id, String name) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_SECURITY_GROUP);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.DELETE_SECURITY_GROUP_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * Authorizes a particular ingress rule for this security group
     *
     * @param account
     * @param cidrList
     * @param domainId
     * @param endPort
     * @param icmpCode
     * @param icmpType
     * @param protocol
     * @param securityGroupId
     * @param securityGroupName
     * @param startPort
     * @param userSecurityGroupList List<CloudStackKeyValue>
     * @return
     * @throws Exception
     */
    public CloudStackSecurityGroup authorizeSecurityGroupIngress(String account, String cidrList, String domainId, Long endPort, String icmpCode, String icmpType,
        String protocol, String securityGroupId, String securityGroupName, Long startPort, List<CloudStackKeyValue> userSecurityGroupList) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.AUTHORIZE_SECURITY_GROUP_INGRESS);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (cidrList != null)
                cmd.setParam(ApiConstants.CIDR_LIST, cidrList);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (endPort != null)
                cmd.setParam(ApiConstants.END_PORT, endPort.toString());
            if (icmpCode != null)
                cmd.setParam(ApiConstants.ICMP_CODE, icmpCode);
            if (icmpType != null)
                cmd.setParam(ApiConstants.ICMP_TYPE, icmpType);
            if (protocol != null)
                cmd.setParam(ApiConstants.PROTOCOL, protocol);
            if (securityGroupId != null)
                cmd.setParam(ApiConstants.SECURITY_GROUP_ID, securityGroupId);
            if (securityGroupName != null)
                cmd.setParam(ApiConstants.SECURITY_GROUP_NAME, securityGroupName);
            if (startPort != null)
                cmd.setParam(ApiConstants.START_PORT, startPort.toString());
            if (userSecurityGroupList != null && userSecurityGroupList.size() > 0) {
                int i = 0;
                for (CloudStackKeyValue pair : userSecurityGroupList) {
                    cmd.setParam(ApiConstants.USER_SECURITY_GROUP_LIST + "[" + i + "].account", pair.getKey());
                    cmd.setParam(ApiConstants.USER_SECURITY_GROUP_LIST + "[" + i + "].group", pair.getValue());
                    i++;
                }
            }
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.AUTHORIZE_SECURITY_GROUP_INGRESS_RESPONSE, ApiConstants.SECURITY_GROUP,
            CloudStackSecurityGroup.class);
    }

    /**
     * Deletes a particular ingress rule from this security group.
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse revokeSecurityGroupIngress(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.REVOKE_SECURITY_GROUP_INGRESS);
        if (cmd != null)
            cmd.setParam(ApiConstants.ID, id);
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.REVOKE_SECURITY_GROUP_INGRESS_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * Lists security groups
     *
     * @param account
     * @param domainId
     * @param id
     * @param keyWord
     * @param securityGroupName
     * @param virtualMachineId
     * @return
     * @throws Exception
     */
    public List<CloudStackSecurityGroup> listSecurityGroups(String account, String domainId, String id, Boolean listAll, String keyWord, String securityGroupName,
        String virtualMachineId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_SECURITY_GROUPS);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (listAll != null)
                cmd.setParam(ApiConstants.LIST_ALL, listAll.toString());
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (securityGroupName != null)
                cmd.setParam(ApiConstants.SECURITY_GROUP_NAME, securityGroupName);
            if (virtualMachineId != null)
                cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_SECURITY_GROUPS_RESPONSE, ApiConstants.SECURITY_GROUP,
            new TypeToken<List<CloudStackSecurityGroup>>() {
            }.getType());
    }

    // Accounts
    /**
     * Lists accounts and provides detailed account information for listed accounts
     *
     * @param accountType
     * @param domainId
     * @param id
     * @param isCleanupRequired
     * @param isRecursive
     * @param keyWord
     * @param name
     * @param state
     * @return
     * @throws Exception
     */
    public List<CloudStackAccount> listAccounts(Long accountType, String domainId, String id, Boolean isCleanupRequired, Boolean isRecursive, String keyWord,
        String name, String state) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_ACCOUNTS);
        if (cmd != null) {
            if (accountType != null)
                cmd.setParam(ApiConstants.ACCOUNT_TYPE, accountType.toString());
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (isCleanupRequired != null)
                cmd.setParam(ApiConstants.IS_CLEANUP_REQUIRED, isCleanupRequired.toString());
            if (isRecursive != null)
                cmd.setParam(ApiConstants.IS_RECURSIVE, isRecursive.toString());
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (state != null)
                cmd.setParam(ApiConstants.STATE, state);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_ACCOUNTS_RESPONSE, ApiConstants.ACCOUNT, new TypeToken<List<CloudStackAccount>>() {
        }.getType());
    }

    // Snapshots
    /**
     * Creates an instant snapshot of a volume
     *
     * @param volumeId
     * @param account
     * @param domainId
     * @param policyId
     * @return
     * @throws Exception
     */
    public CloudStackSnapshot createSnapshot(String volumeId, String account, String domainId, String policyId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_SNAPSHOT);
        if (cmd != null) {
            cmd.setParam(ApiConstants.VOLUME_ID, volumeId);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (policyId != null)
                cmd.setParam(ApiConstants.POLICY_ID, policyId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CREATE_SNAPSHOT_RESPONSE, ApiConstants.SNAPSHOT, CloudStackSnapshot.class);
    }

    /**
     * list Snapshots
     *
     * @param volumeId
     * @param account
     * @param domainId
     * @param policyId
     * @return
     * @throws Exception
     */
    public List<CloudStackSnapshot> listSnapshots(String account, String domainId, String id, String intervalType, Boolean isRecursive, String keyWord, String name,
        String snapshotType, String volumeId, List<CloudStackKeyValue> resourceTags) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_SNAPSHOTS);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (intervalType != null)
                cmd.setParam(ApiConstants.INTERVAL_TYPE, intervalType);
            if (isRecursive != null)
                cmd.setParam(ApiConstants.IS_RECURSIVE, isRecursive.toString());
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (snapshotType != null)
                cmd.setParam(ApiConstants.SNAPSHOT_TYPE, snapshotType);
            if (volumeId != null)
                cmd.setParam(ApiConstants.VOLUME_ID, volumeId);
            if (resourceTags != null && resourceTags.size() > 0)
                cmd = setParams(cmd, null, null, resourceTags);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_SNAPSHOTS_RESPONSE, ApiConstants.SNAPSHOT, new TypeToken<List<CloudStackSnapshot>>() {
        }.getType());
    }

    /**
     * Deletes a snapshot of a disk volume
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse deleteSnapshot(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_SNAPSHOT);
        if (cmd != null)
            cmd.setParam(ApiConstants.ID, id);
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DELETE_SNAPSHOT_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * Creates a snapshot policy for the account
     *
     * @param intervalType
     * @param maxSnaps
     * @param schedule
     * @param timeZone
     * @param volumeId
     * @return
     * @throws Exception
     */
    public CloudStackSnapshotPolicy createSnapshotPolicy(String intervalType, Long maxSnaps, String schedule, String timeZone, String volumeId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_SNAPSHOT_POLICY);
        if (cmd != null) {
            cmd.setParam(ApiConstants.INTERVAL_TYPE, intervalType);
            cmd.setParam(ApiConstants.MAX_SNAPS, maxSnaps.toString());
            cmd.setParam(ApiConstants.SCHEDULE, schedule);
            cmd.setParam(ApiConstants.TIMEZONE, timeZone);
            cmd.setParam(ApiConstants.VOLUME_ID, volumeId);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.CREATE_SNAPSHOT_POLICY_RESPONSE, ApiConstants.SNAPSHOT, CloudStackSnapshotPolicy.class);
    }

    /**
     * Delete's snapshot policies for the account
     *
     * @param id
     * @param ids
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse deleteSnapshotPolicies(String id, String ids) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_SNAPSHOT_POLICIES);
        if (cmd != null) {
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (ids != null)
                cmd.setParam(ApiConstants.IDS, ids);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.DELETE_SNAPSHOT_POLICIES_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * List snapshot policies for the account
     *
     * @param volumeId
     * @param account
     * @param domainId
     * @param keyWord
     * @return
     * @throws Exception
     */
    public List<CloudStackSnapshotPolicy> listSnapshotPolicies(String volumeId, String account, String domainId, String keyWord) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_SNAPSHOT_POLICIES);
        if (cmd != null) {
            cmd.setParam(ApiConstants.VOLUME_ID, volumeId);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_SNAPSHOT_POLICIES_RESPONSE, ApiConstants.SNAPSHOT,
            new TypeToken<List<CloudStackSnapshotPolicy>>() {
            }.getType());
    }

    // Events
    /**
     * List events
     *
     * @param account
     * @param domainId
     * @param duration
     * @param endDate
     * @param entryTime
     * @param id
     * @param keyWord
     * @param level
     * @param startDate
     * @param type
     * @return
     * @throws Exception
     */
    public List<CloudStackEvent> listEvents(String account, String domainId, Long duration, String endDate, String entryTime, String id, String keyWord, String level,
        String startDate, String type) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_EVENTS);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (duration != null)
                cmd.setParam(ApiConstants.DURATION, duration.toString());
            if (endDate != null)
                cmd.setParam(ApiConstants.END_DATE, endDate);
            if (entryTime != null)
                cmd.setParam(ApiConstants.ENTRY_TIME, entryTime);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (level != null)
                cmd.setParam(ApiConstants.LEVEL, level);
            if (startDate != null)
                cmd.setParam(ApiConstants.START_DATE, startDate);
            if (type != null)
                cmd.setParam(ApiConstants.TYPE, type);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_EVENTS_RESPONSE, ApiConstants.EVENT, new TypeToken<List<CloudStackEvent>>() {
        }.getType());
    }

    /**
     * List event types
     *
     * @return
     * @throws Exception
     */
    public List<CloudStackEventType> listEventTypes() throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_EVENT_TYPES);
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_EVENT_TYPES_RESPONSE, ApiConstants.EVENT_TYPE, new TypeToken<List<CloudStackEventType>>() {
        }.getType());
    }

    // Guest OS
    /**
     * list OS Types
     *
     * @param id
     * @param keyWord
     * @param osCategoryId
     * @return
     * @throws Exception
     */
    public List<CloudStackOsType> listOsTypes(String id, String keyWord, String osCategoryId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_OS_TYPES);
        if (cmd != null) {
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (osCategoryId != null)
                cmd.setParam(ApiConstants.OS_CATEGORY_ID, osCategoryId);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_OS_TYPES_RESPONSE, ApiConstants.OS_TYPE, new TypeToken<List<CloudStackOsType>>() {
        }.getType());
    }

    /**
     * list OS Categories
     *
     * @param id
     * @param keyWord
     * @return
     * @throws Exception
     */
    public List<CloudStackOsCategory> listOsCategories(String id, String keyWord) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_OS_CATEGORIES);
        if (cmd != null) {
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_OS_CATEGORIES_RESPONSE, ApiConstants.OS_CATEGORY, new TypeToken<List<CloudStackOsCategory>>() {
        }.getType());
    }

    // Service Offering
    /**
     * list available Service offerings
     *
     * @param domainId
     * @param id
     * @param isSystem
     * @param keyWord
     * @param name
     * @param systemVmType
     * @param virtualMachineId
     * @return
     * @throws Exception
     */
    public List<CloudStackServiceOffering> listServiceOfferings(String domainId, String id, Boolean isSystem, String keyWord, String name, String systemVmType,
        String virtualMachineId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_SERVICE_OFFERINGS);
        if (cmd != null) {
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (isSystem != null)
                cmd.setParam(ApiConstants.IS_SYSTEM, isSystem.toString());
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (systemVmType != null)
                cmd.setParam(ApiConstants.SYSTEM_VM_TYPE, systemVmType);
            if (virtualMachineId != null)
                cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_SERVICE_OFFERINGS_RESPONSE, ApiConstants.SERVICE_OFFERING,
            new TypeToken<List<CloudStackServiceOffering>>() {
            }.getType());
    }

    // Disk Offerings
    /**
     * list available disk offerings
     *
     * @param domainId
     * @param id
     * @param keyWord
     * @param name
     * @return
     * @throws Exception
     */
    public List<CloudStackDiskOffering> listDiskOfferings(String domainId, String id, String keyWord, String name) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_DISK_OFFERINGS);
        if (cmd != null) {
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_DISK_OFFERINGS_RESPONSE, ApiConstants.DISK_OFFERING,
            new TypeToken<List<CloudStackDiskOffering>>() {
            }.getType());
    }

    // SSH keys
    /**
     * register an SSH Key Pair
     *
     * @param name
     * @param publicKey
     * @return
     * @throws Exception
     */
    public CloudStackKeyPair registerSSHKeyPair(String name, String publicKey) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.REGISTER_SSH_KEY_PAIR);
        if (cmd != null) {
            cmd.setParam(ApiConstants.NAME, name);
            cmd.setParam(ApiConstants.PUBLIC_KEY, publicKey);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.REGISTER_SSH_KEY_PAIR_RESPONSE, ApiConstants.KEY_PAIR, CloudStackKeyPair.class);
    }

    /**
     * Create an SSH Key Pair
     *
     * @param name
     * @param account
     * @param domainId
     * @return
     * @throws Exception
     */
    public CloudStackKeyPair createSSHKeyPair(String name, String account, String domainId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_SSH_KEY_PAIR);
        if (cmd != null) {
            cmd.setParam(ApiConstants.NAME, name);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.CREATE_SSH_KEY_PAIR_RESPONSE, ApiConstants.KEY_PAIR, CloudStackKeyPair.class);
    }

    /**
     * delete an SSH Key Pair
     *
     * @param name
     * @param account
     * @param domainId
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse deleteSSHKeyPair(String name, String account, String domainId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_SSH_KEY_PAIR);
        if (cmd != null) {
            cmd.setParam(ApiConstants.NAME, name);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.DELETE_SSH_KEY_PAIR_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * return list of SSH Key Pairs
     *
     * @param fingerprint
     * @param keyWord
     * @param name
     * @return
     * @throws Exception
     */
    public List<CloudStackKeyPair> listSSHKeyPairs(String fingerprint, String keyWord, String name) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_SSH_KEY_PAIRS);
        if (cmd != null) {
            if (fingerprint != null)
                cmd.setParam(ApiConstants.FINGERPRINT, fingerprint);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_SSH_KEY_PAIRS_RESPONSE, "sshkeypair", new TypeToken<List<CloudStackKeyPair>>() {
        }.getType());
    }

    // IpAddresses
    /**
     * associate an ip address
     *
     * @param zoneId
     * @param account
     * @param domainId
     * @param networkId
     * @return
     * @throws Exception
     */
    public CloudStackIpAddress associateIpAddress(String zoneId, String account, String domainId, String networkId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.ASSOCIATE_IP_ADDRESS);
        if (cmd != null) {
            // previous zoneId was required according to api docs, but Management Server UI doesn't use it...
            if (zoneId != null)
                cmd.setParam(ApiConstants.ZONE_ID, zoneId);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (networkId != null)
                cmd.setParam(ApiConstants.NETWORK_ID, networkId);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.ASSOCIATE_IP_ADDRESS_RESPONSE, null, CloudStackIpAddress.class);
    }

    /**
     * disassociate an ipaddress from an instance
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse disassociateIpAddress(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DISASSOCIATE_IP_ADDRESS);
        if (cmd != null)
            cmd.setParam(ApiConstants.ID, id);
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DISASSOCIATE_IP_ADDRESS_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * lists of allocate public ip addresses
     *
     * @param account
     * @param allocatedOnly
     * @param domainId
     * @param forVirtualNetwork
     * @param id
     * @return
     */
    public List<CloudStackIpAddress> listPublicIpAddresses(String account, Boolean allocatedOnly, String domainId, Boolean forVirtualNetwork, String id,
        String ipAddress, String keyWord, String vlanId, String zoneId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_PUBLIC_IP_ADDRESSES);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (allocatedOnly != null)
                cmd.setParam(ApiConstants.ALLOCATED_ONLY, allocatedOnly.toString());
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (forVirtualNetwork != null)
                cmd.setParam(ApiConstants.FOR_VIRTUAL_NETWORK, forVirtualNetwork.toString());
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (ipAddress != null)
                cmd.setParam(ApiConstants.IP_ADDRESS, ipAddress);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (vlanId != null)
                cmd.setParam(ApiConstants.VLAN_ID, vlanId);
            if (zoneId != null)
                cmd.setParam(ApiConstants.ZONE_ID, zoneId);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_PUBLIC_IP_ADDRESSES_RESPONSE, ApiConstants.PUBLIC_IP_ADDRESS,
            new TypeToken<List<CloudStackIpAddress>>() {
            }.getType());
    }

    // Firewall
    /**
     * list port forwarding rules
     *
     * @param account
     * @param domainId
     * @param id
     * @param ipAddressId
     * @param keyWord
     * @return
     * @throws Exception
     */
    public List<CloudStackPortForwardingRule> listPortForwardingRules(String account, String domainId, String id, Long ipAddressId, String keyWord) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_PORT_FORWARDING_RULES);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (ipAddressId != null)
                cmd.setParam(ApiConstants.IP_ADDRESS_ID, ipAddressId.toString());
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_PORT_FORWARDING_RULES_RESPONSE, ApiConstants.PORT_FORWARDING_RULE,
            new TypeToken<List<CloudStackPortForwardingRule>>() {
            }.getType());
    }

    /**
     * Create a Port Forwarding Rule
     *
     * @param ipAddressId
     * @param privatePort
     * @param protocol
     * @param publicPort
     * @param virtualMachineId
     * @param cidrList
     * @param privateEndPort
     * @param publicEndPort
     * @return
     * @throws Exception
     */
    public CloudStackPortForwardingRule createPortForwardingRule(String ipAddressId, Long privatePort, String protocol, Long publicPort, String virtualMachineId,
        String cidrList, Long privateEndPort, Long publicEndPort) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_PORT_FORWARDING_RULE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.IP_ADDRESS_ID, ipAddressId);
            cmd.setParam(ApiConstants.PRIVATE_PORT, privatePort.toString());
            cmd.setParam(ApiConstants.PROTOCOL, protocol);
            cmd.setParam(ApiConstants.PUBLIC_PORT, publicPort.toString());
            cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
            if (cidrList != null)
                cmd.setParam(ApiConstants.CIDR_LIST, cidrList);
            if (privateEndPort != null)
                cmd.setParam(ApiConstants.PRIVATE_END_PORT, privateEndPort.toString());
            if (publicEndPort != null)
                cmd.setParam(ApiConstants.PUBLIC_END_PORT, publicEndPort.toString());
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CREATE_PORT_FORWARDING_RULE_RESPONSE, ApiConstants.PORT_FORWARDING_RULE,
            CloudStackPortForwardingRule.class);
    }

    /**
     * Delete a Port Forwarding Rule
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse deletePortForwardingRule(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_PORT_FORWARDING_RULE);
        if (cmd != null)
            cmd.setParam(ApiConstants.ID, id);
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DELETE_PORT_FORWARDING_RULE_RESPONSE, null, CloudStackInfoResponse.class);
    }

    // NAT
    /**
     * enable Static Nat
     *
     * @param ipAddressId
     * @param virtualMachineId
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse enableStaticNat(String ipAddressId, String virtualMachineId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.ENABLE_STATIC_NAT);
        if (cmd != null) {
            cmd.setParam(ApiConstants.IP_ADDRESS_ID, ipAddressId);
            cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.ENABLE_STATIC_NAT_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * Creates an ip forwarding rule
     *
     * @param ipAddressId
     * @param protocol
     * @param startPort
     * @param endPort
     * @return
     * @throws Exception
     */
    public CloudStackPortForwardingRule createIpForwardingRule(String ipAddressId, String protocol, Long startPort, Long endPort) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_IP_FORWARDING_RULE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.IP_ADDRESS_ID, ipAddressId);
            cmd.setParam(ApiConstants.PROTOCOL, protocol);
            cmd.setParam(ApiConstants.START_PORT, startPort.toString());
            if (endPort != null)
                cmd.setParam(ApiConstants.END_PORT, endPort.toString());
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CREATE_IP_FORWARDING_RULE_RESPONSE, ApiConstants.IP_FORWARDING_RULE,
            CloudStackPortForwardingRule.class);
    }

    /**
     * Deletes an ip forwarding rule
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse deleteIpForwardingRule(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_IP_FORWARDING_RULE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DELETE_IP_FORWARDING_RULE_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * List the ip forwarding rules
     *
     * @param account
     * @param domainId
     * @param id
     * @param ipAddressId
     * @param keyWord
     * @param virtualMachineId
     * @return
     * @throws Exception
     */
    public List<CloudStackPortForwardingRule> listIpForwardingRules(String account, String domainId, String id, String ipAddressId, String keyWord,
        String virtualMachineId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_IP_FORWARDING_RULES);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (ipAddressId != null)
                cmd.setParam(ApiConstants.IP_ADDRESS_ID, ipAddressId);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (virtualMachineId != null)
                cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_IP_FORWARDING_RULES_RESPONSE, ApiConstants.IP_FORWARDING_RULE,
            new TypeToken<List<CloudStackPortForwardingRule>>() {
            }.getType());
    }

    /**
     * Disables static rule for given ip address
     *
     * @param ipAddressId
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse disableStaticNat(String ipAddressId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DISABLE_STATIC_NAT);
        if (cmd != null)
            cmd.setParam(ApiConstants.IP_ADDRESS_ID, ipAddressId);
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DISABLE_STATIC_NAT_RESPONSE, null, CloudStackInfoResponse.class);
    }

    // Load Balancer
    /**
     * Creates a load balancer rule
     *
     * @param algorithm
     * @param name
     * @param privatePort
     * @param publicIpId
     * @param publicPort
     * @param description
     * @return
     * @throws Exception
     */
    public CloudStackLoadBalancerRule createLoadBalancerRule(String algorithm, String name, Long privatePort, String publicIpId, Long publicPort, String description)
        throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_LOAD_BALANCER_RULE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ALGORITHM, algorithm);
            cmd.setParam(ApiConstants.NAME, name);
            cmd.setParam(ApiConstants.PRIVATE_PORT, privatePort.toString());
            cmd.setParam(ApiConstants.PUBLIC_IP_ID, publicIpId);
            cmd.setParam(ApiConstants.PUBLIC_PORT, publicPort.toString());
            if (description != null)
                cmd.setParam(ApiConstants.DESCRIPTION, description);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.CREATE_LOAD_BALANCER_RULE_RESPONSE, ApiConstants.LOAD_BALANCER, CloudStackLoadBalancerRule.class);
    }

    /**
     * Deletes a load balancer rule
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse deleteLoadBalancer(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_LOAD_BALANCER_RULE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.DELETE_LOAD_BALANCER_RULE_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * Removes a virtual machine or a list of virtual machines from a load balancer rule
     *
     * @param id
     * @param virtualMachineIds
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse removeFromLoadBalancerRule(String id, String virtualMachineIds) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.REMOVE_FROM_LOAD_BALANCER_RULE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            cmd.setParam(ApiConstants.VIRTUAL_MACHINE_IDS, virtualMachineIds);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.REMOVE_FROM_LOAD_BALANCER_RULE_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * Assigns virtual machine or a list of virtual machines to a load balancer rule.
     *
     * @param id
     * @param virtualMachineIds
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse assignToLoadBalancerRule(String id, String virtualMachineIds) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.ASSIGN_TO_LOAD_BALANCER_RULE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            cmd.setParam(ApiConstants.VIRTUAL_MACHINE_IDS, virtualMachineIds);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.ASSIGN_TO_LOAD_BALANCER_RULE_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * Lists load balancer rules
     *
     * @param account
     * @param domainId
     * @param id
     * @param keyWord
     * @param name
     * @param publicIpId
     * @param virtualMachineId
     * @param zoneId
     * @return
     * @throws Exception
     */
    public List<CloudStackLoadBalancerRule> listLoadBalancerRules(String account, String domainId, String id, String keyWord, String name, String publicIpId,
        String virtualMachineId, String zoneId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_LOAD_BALANCER_RULES);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (publicIpId != null)
                cmd.setParam(ApiConstants.PUBLIC_IP_ID, publicIpId);
            if (virtualMachineId != null)
                cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
            if (zoneId != null)
                cmd.setParam(ApiConstants.ZONE_ID, zoneId);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_LOAD_BALANCER_RULES_RESPONSE, ApiConstants.LOAD_BALANCER,
            new TypeToken<List<CloudStackLoadBalancerRule>>() {
            }.getType());
    }

    /**
     * List all virtual machine instances that are assigned a load balancer rule
     *
     * @param id
     * @param applied
     * @param keyWord
     * @return
     * @throws Exception
     */
    public List<CloudStackUserVm> listLoadBalancerRuleInstances(String id, Boolean applied, String keyWord) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_LOAD_BALANCER_RULE_INSTANCES);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (applied != null)
                cmd.setParam(ApiConstants.APPLIED, applied.toString());
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_LOAD_BALANCER_RULE_INSTANCES_RESPONSE, ApiConstants.VIRTUAL_MACHINE,
            new TypeToken<List<CloudStackUserVm>>() {
            }.getType());
    }

    /**
     * Updates load balancer
     *
     * @param id
     * @param algorithm
     * @param description
     * @param name
     * @return
     * @throws Exception
     */
    public CloudStackLoadBalancerRule updateLoadBalancerRule(String id, String algorithm, String description, String name) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_LOAD_BALANCER_RULE);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (algorithm != null)
                cmd.setParam(ApiConstants.ALGORITHM, algorithm);
            if (description != null)
                cmd.setParam(ApiConstants.DESCRIPTION, description);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.UPDATE_LOAD_BALANCER_RULE_RESPONSE, ApiConstants.LOAD_BALANCER, CloudStackLoadBalancerRule.class);
    }

    // VM Group

    /**
     * create an instance group
     *
     * @param name
     * @param account
     * @param domainId
     * @return
     * @throws Exception
     */
    public CloudStackInstanceGroup createInstanceGroup(String name, String account, String domainId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_INSTANCE_GROUP);
        if (cmd != null) {
            cmd.setParam(ApiConstants.NAME, name);
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CREATE_INSTANCE_GROUP_RESPONSE, ApiConstants.INSTANCE_GROUP, CloudStackInstanceGroup.class);

    }

    /**
     * delete an instance group
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse deleteInstanceGroup(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_INSTANCE_GROUP);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DELETE_INSTANCE_GROUP_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * Update an instance group
     *
     * @param id
     * @param name
     * @return
     * @throws Exception
     */
    public CloudStackInstanceGroup updateInstanceGroup(String id, String name) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_INSTANCE_GROUP);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.UPDATE_INSTANCE_GROUP_RESPONSE, ApiConstants.INSTANCE_GROUP, CloudStackInstanceGroup.class);
    }

    /**
     * List instance groups
     *
     * @param account
     * @param domainId
     * @param id
     * @param keyWord
     * @param name
     * @return
     * @throws Exception
     */
    public List<CloudStackInstanceGroup> listInstanceGroups(String account, String domainId, String id, String keyWord, String name) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_INSTANCE_GROUPS);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_INSTANCE_GROUPS_RESPONSE, ApiConstants.INSTANCE_GROUP,
            new TypeToken<List<CloudStackInstanceGroup>>() {
            }.getType());

    }

    // Networks
    /**
     * Creates a network
     *
     * @param displayText
     * @param name
     * @param networkOfferingId
     * @param zoneId
     * @param account
     * @param domainId
     * @param isDefault
     * @param startIp
     * @param endIp
     * @param gateway
     * @param netmask
     * @param isShared
     * @param networkDomain
     * @param tags
     * @param vlan
     * @return
     * @throws Exception
     */
    public CloudStackNetwork createNetwork(String displayText, String name, String networkOfferingId, String zoneId, String account, String domainId, Boolean isDefault,
        String startIp, String endIp, String gateway, String netmask, Boolean isShared, String networkDomain, String tags, String vlan) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_NETWORK);
        if (cmd != null) {
            // required params
            cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
            cmd.setParam(ApiConstants.NAME, name);
            cmd.setParam(ApiConstants.NETWORK_OFFERING_ID, networkOfferingId);
            cmd.setParam(ApiConstants.ZONE_ID, zoneId);
            // optional params
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (endIp != null)
                cmd.setParam(ApiConstants.END_IP, endIp);
            if (gateway != null)
                cmd.setParam(ApiConstants.GATEWAY, gateway);
            if (isDefault != null)
                cmd.setParam(ApiConstants.IS_DEFAULT, isDefault.toString());
            if (isShared != null)
                cmd.setParam(ApiConstants.IS_SHARED, isShared.toString());
            if (netmask != null)
                cmd.setParam(ApiConstants.NETMASK, netmask);
            if (networkDomain != null)
                cmd.setParam(ApiConstants.NETWORK_DOMAIN, networkDomain);
            if (startIp != null)
                cmd.setParam(ApiConstants.START_IP, startIp);
            if (tags != null)
                cmd.setParam(ApiConstants.TAGS, tags);
            if (vlan != null)
                cmd.setParam(ApiConstants.VLAN, vlan);
        }
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.CREATE_NETWORK_RESPONSE, ApiConstants.NETWORK, CloudStackNetwork.class);
    }

    /**
     * delete a network
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackInfoResponse deleteNetwork(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_NETWORK);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DELETE_NETWORK_RESPONSE, null, CloudStackInfoResponse.class);
    }

    /**
     * list Networks
     *
     * @param account
     * @param domainId
     * @param id
     * @param isDefault
     * @param isShared
     * @param isSystem
     * @param keyWord
     * @param trafficType
     * @param type
     * @param zoneId
     * @return
     * @throws Exception
     */
    public List<CloudStackNetwork> listNetworks(String account, String domainId, String id, Boolean isDefault, Boolean isShared, Boolean isSystem, String keyWord,
        String trafficType, String type, String zoneId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_NETWORKS);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (isDefault != null)
                cmd.setParam(ApiConstants.IS_DEFAULT, isDefault.toString());
            if (isShared != null)
                cmd.setParam(ApiConstants.IS_SHARED, isShared.toString());
            if (isSystem != null)
                cmd.setParam(ApiConstants.IS_SYSTEM, isSystem.toString());
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (trafficType != null)
                cmd.setParam(ApiConstants.TRAFFIC_TYPE, trafficType);
            if (type != null)
                cmd.setParam(ApiConstants.TYPE, type);
            if (zoneId != null)
                cmd.setParam(ApiConstants.ZONE_ID, zoneId);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_NETWORKS_RESPONSE, ApiConstants.NETWORK, new TypeToken<List<CloudStackNetwork>>() {
        }.getType());

    }

    /**
     * Reapplies all ip addresses for the particular network
     *
     * @param id
     * @return
     * @throws Exception
     */
    public CloudStackIpAddress restartNetwork(String id) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.RESTART_NETWORK);
        if (cmd != null)
            cmd.setParam(ApiConstants.ID, id);
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.RESTART_NETWORK_RESPONSE, ApiConstants.PUBLIC_IP_ADDRESS, CloudStackIpAddress.class);
    }

    /**
     * update a network
     *
     * @param id
     * @param displayText
     * @param name
     * @param networkDomain
     * @param tags
     * @return
     * @throws Exception
     */
    public CloudStackNetwork updateNetwork(String id, String displayText, String name, String networkDomain, String tags) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_NETWORK);
        if (cmd != null) {
            cmd.setParam(ApiConstants.ID, id);
            if (displayText != null)
                cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (networkDomain != null)
                cmd.setParam(ApiConstants.NETWORK_DOMAIN, networkDomain);
            if (tags != null)
                cmd.setParam(ApiConstants.TAGS, tags);
        }
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.UPDATE_NETWORK_RESPONSE, ApiConstants.NETWORK, CloudStackNetwork.class);
    }

    // Hypervisor
    /**
     * list Hypervisors
     *
     * @param zoneId
     * @return
     * @throws Exception
     */
    public List<CloudStackEventType> listHypervisors(String zoneId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_HYPERVISORS);
        if (cmd != null)
            cmd.setParam(ApiConstants.ZONE_ID, zoneId);
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_HYPERVISORS_RESPONSE, ApiConstants.HYPERVISOR, new TypeToken<List<CloudStackEventType>>() {
        }.getType());
    }

    // Zones
    /**
     * list Zones
     *
     * @param available
     * @param domainId
     * @param id
     * @param keyWord
     * @return
     * @throws Exception
     */
    public List<CloudStackZone> listZones(Boolean available, String domainId, String id, String keyWord) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_ZONES);
        if (cmd != null) {
            if (available != null)
                cmd.setParam(ApiConstants.AVAILABLE, available.toString());
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_ZONES_RESPONSE, ApiConstants.ZONE, new TypeToken<List<CloudStackZone>>() {
        }.getType());

    }

    // Network Offerings
    /**
     * List available network offerings
     *
     * @param availability
     * @param displayText
     * @param guestIpType
     * @param id
     * @param isDefault
     * @param isShared
     * @param keyWord
     * @param name
     * @param specifyVLan
     * @param trafficType
     * @param zoneId
     * @return
     * @throws Exception
     */
    public List<CloudStackNetworkOffering> listNetworkOfferings(String availability, String displayText, String guestIpType, String id, Boolean isDefault,
        Boolean isShared, String keyWord, String name, String specifyVLan, String trafficType, String zoneId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_NETWORK_OFFERINGS);
        if (cmd != null) {
            if (availability != null)
                cmd.setParam(ApiConstants.AVAILABILITY, availability);
            if (displayText != null)
                cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
            if (guestIpType != null)
                cmd.setParam(ApiConstants.GUEST_IP_TYPE, guestIpType);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (isDefault != null)
                cmd.setParam(ApiConstants.IS_DEFAULT, isDefault.toString());
            if (isShared != null)
                cmd.setParam(ApiConstants.IS_SHARED, isShared.toString());
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (name != null)
                cmd.setParam(ApiConstants.NAME, name);
            if (specifyVLan != null)
                cmd.setParam(ApiConstants.SPECIFY_VLAN, specifyVLan);
            if (trafficType != null)
                cmd.setParam(ApiConstants.TRAFFIC_TYPE, trafficType);
            if (zoneId != null)
                cmd.setParam(ApiConstants.ZONE_ID, zoneId);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_NETWORK_OFFERINGS_RESPONSE, ApiConstants.NETWORK_OFFERING,
            new TypeToken<List<CloudStackNetworkOffering>>() {
            }.getType());
    }

    // Configuration
    /**
     * list Capaibilities
     *
     * @return
     * @throws Exception
     */
    public CloudStackCapabilities listCapabilities() throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_CAPABILITIES);
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.LIST_CAPABILITIES_RESPONSE, ApiConstants.CAPABILITY, CloudStackCapabilities.class);
    }

    // Limits
    /**
     * list resource limits
     *
     * @param account
     * @param domainId
     * @param id
     * @param keyWord
     * @param resourceType
     * @return
     * @throws Exception
     */
    public List<CloudStackResourceLimit> listResourceLimits(String account, String domainId, String id, String keyWord, String resourceType) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_RESOURCE_LIMITS);
        if (cmd != null) {
            if (account != null)
                cmd.setParam(ApiConstants.ACCOUNT, account);
            if (domainId != null)
                cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
            if (id != null)
                cmd.setParam(ApiConstants.ID, id);
            if (keyWord != null)
                cmd.setParam(ApiConstants.KEYWORD, keyWord);
            if (resourceType != null)
                cmd.setParam(ApiConstants.RESOURCE_TYPE, resourceType);
        }
        return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_RESOURCE_LIMITS_RESPONSE, ApiConstants.RESOURCE_LIMIT,
            new TypeToken<List<CloudStackResourceLimit>>() {
            }.getType());

    }

    // Cloud Identifier
    /**
     * Returns a cloud identifier
     *
     * @param userId
     * @return
     * @throws Exception
     */
    public CloudStackIdentifier getCloudIdentifier(String userId) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_RESOURCE_LIMITS);
        if (cmd != null)
            cmd.setParam(ApiConstants.USER_ID, userId);

        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.GET_CLOUD_IDENTIFIER_RESPONSE, ApiConstants.CLOUD_IDENTIFIER, CloudStackIdentifier.class);
    }

}