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

__all__ = [
    'SLB_API_VERSION',
    'SLBDriver'
]

try:
    import simplejson as json
except ImportError:
    import json

from libcloud.common.aliyun import AliyunXmlResponse, SignedAliyunConnection
from libcloud.common.types import LibcloudError
from libcloud.loadbalancer.types import State
from libcloud.loadbalancer.base import Algorithm, Driver, LoadBalancer, Member
from libcloud.utils.misc import ReprMixin
from libcloud.utils.py3 import u
from libcloud.utils.xml import findattr, findtext, findall


SLB_API_VERSION = '2014-05-15'
SLB_API_HOST = 'slb.aliyuncs.com'
DEFAULT_SIGNATURE_VERSION = '1.0'


STATE_MAPPINGS = {
    'inactive': State.UNKNOWN,
    'active': State.RUNNING,
    'locked': State.PENDING
}


RESOURCE_EXTRA_ATTRIBUTES_MAP = {
    'balancer': {
        'create_timestamp': {
            'xpath': 'CreateTimeStamp',
            'transform_func': int
        },
        'address_type': {
            'xpath': 'AddressType',
            'transform_func': u
        },
        'region_id': {
            'xpath': 'RegionId',
            'transform_func': u
        },
        'region_id_alias': {
            'xpath': 'RegionIdAlias',
            'transform_func': u
        },
        'create_time': {
            'xpath': 'CreateTime',
            'transform_func': u
        },
        'master_zone_id': {
            'xpath': 'MasterZoneId',
            'transform_func': u
        },
        'slave_zone_id': {
            'xpath': 'SlaveZoneId',
            'transform_func': u
        },
        'network_type': {
            'xpath': 'NetworkType',
            'transform_func': u
        }
    }
}


SLB_SCHEDULER_TO_ALGORITHM = {
    'wrr': Algorithm.WEIGHTED_ROUND_ROBIN,
    'wlc': Algorithm.WEIGHTED_LEAST_CONNECTIONS
}


ALGORITHM_TO_SLB_SCHEDULER = {
    Algorithm.WEIGHTED_ROUND_ROBIN: 'wrr',
    Algorithm.WEIGHTED_LEAST_CONNECTIONS: 'wlc'
}


class SLBConnection(SignedAliyunConnection):
    api_version = SLB_API_VERSION
    host = SLB_API_HOST
    responseCls = AliyunXmlResponse
    service_name = 'slb'


class SLBLoadBalancerAttribute(object):
    """
    This class used to get listeners and backend servers related to a balancer
    listeners is a ``list`` of ``dict``, each element contains
    'ListenerPort' and 'ListenerProtocol' keys.
    backend_servers is a ``list`` of ``dict``, each element contains
    'ServerId' and 'Weight' keys.
    """
    def __init__(self, balancer, listeners, backend_servers, extra=None):
        self.balancer = balancer
        self.listeners = listeners or []
        self.backend_servers = backend_servers or []
        self.extra = extra or {}

    def is_listening(self, port):
        for listener in self.listeners:
            if listener.get('ListenerPort') == port:
                return True
        return False

    def is_attached(self, member):
        for server in self.backend_servers:
            if server.get('Serverid') == member.id:
                return True
        return False

    def __repr__(self):
        return ('<SLBLoadBalancerAttribute id=%s, ports=%s, servers=%s ...>' %
                (self.balancer.id, self.listeners, self.backend_servers))


class SLBLoadBalancerListener(ReprMixin, object):
    """
    Base SLB load balancer listener class
    """
    _repr_attributes = ['port', 'backend_port', 'scheduler', 'bandwidth']
    action = None
    option_keys = []

    def __init__(self, port, backend_port, algorithm, bandwidth, extra=None):
        self.port = port
        self.backend_port = backend_port
        self.scheduler = ALGORITHM_TO_SLB_SCHEDULER.get(algorithm, 'wrr')
        self.bandwidth = bandwidth
        self.extra = extra or {}

    @classmethod
    def create(cls, port, backend_port, algorithm, bandwidth, extra=None):
        return cls(port, backend_port, algorithm, bandwidth, extra=extra)

    def get_create_params(self):
        params = self.get_required_params()
        options = self.get_optional_params()
        options.update(params)
        return options

    def get_required_params(self):
        params = {'Action': self.action,
                  'ListenerPort': self.port,
                  'BackendServerPort': self.backend_port,
                  'Scheduler': self.scheduler,
                  'Bandwidth': self.bandwidth}
        return params

    def get_optional_params(self):
        options = {}
        for option in self.option_keys:
            if self.extra and option in self.extra:
                options[option] = self.extra[option]
        return options


class SLBLoadBalancerHttpListener(SLBLoadBalancerListener):
    """
    This class represents a rule to route http request to the backends.
    """
    action = 'CreateLoadBalancerHTTPListener'
    option_keys = ['XForwardedFor', 'StickySessionType', 'CookieTimeout',
                   'Cookie', 'HealthCheckDomain', 'HealthCheckURI',
                   'HealthCheckConnectPort', 'HealthyThreshold',
                   'UnhealthyThreshold', 'HealthCheckTimeout',
                   'HealthCheckInterval', 'HealthCheckHttpCode']

    def __init__(self, port, backend_port, algorithm, bandwidth,
                 sticky_session, health_check, extra=None):
        super(SLBLoadBalancerHttpListener, self).__init__(
            port, backend_port, algorithm, bandwidth, extra=extra)
        self.sticky_session = sticky_session
        self.health_check = health_check

    def get_required_params(self):
        params = super(SLBLoadBalancerHttpListener,
                       self).get_required_params()
        params['StickySession'] = self.sticky_session
        params['HealthCheck'] = self.health_check
        return params

    @classmethod
    def create(cls, port, backend_port, algorithm, bandwidth, extra={}):
        if 'StickySession' not in extra:
            raise AttributeError('StickySession is required')
        if 'HealthCheck' not in extra:
            raise AttributeError('HealthCheck is required')
        sticky_session = extra['StickySession']
        health_check = extra['HealthCheck']
        return cls(port, backend_port, algorithm, bandwidth, sticky_session,
                   health_check, extra=extra)


class SLBLoadBalancerHttpsListener(SLBLoadBalancerListener):
    """
    This class represents a rule to route https request to the backends.
    """
    action = 'CreateLoadBalancerHTTPSListener'
    option_keys = ['XForwardedFor', 'StickySessionType', 'CookieTimeout',
                   'Cookie', 'HealthCheckDomain', 'HealthCheckURI',
                   'HealthCheckConnectPort', 'HealthyThreshold',
                   'UnhealthyThreshold', 'HealthCheckTimeout',
                   'HealthCheckInterval', 'HealthCheckHttpCode']

    def __init__(self, port, backend_port, algorithm, bandwidth,
                 sticky_session, health_check, certificate_id, extra=None):
        super(SLBLoadBalancerHttpsListener, self).__init__(
            port, backend_port, algorithm, bandwidth, extra=extra)
        self.sticky_session = sticky_session
        self.health_check = health_check
        self.certificate_id = certificate_id

    def get_required_params(self):
        params = super(SLBLoadBalancerHttpsListener,
                       self).get_required_params()
        params['StickySession'] = self.sticky_session
        params['HealthCheck'] = self.health_check
        params['ServerCertificateId'] = self.certificate_id
        return params

    @classmethod
    def create(cls, port, backend_port, algorithm, bandwidth, extra={}):
        if 'StickySession' not in extra:
            raise AttributeError('StickySession is required')
        if 'HealthCheck' not in extra:
            raise AttributeError('HealthCheck is required')
        if 'ServerCertificateId' not in extra:
            raise AttributeError('ServerCertificateId is required')
        sticky_session = extra['StickySession']
        health_check = extra['HealthCheck']
        certificate_id = extra['ServerCertificateId']
        return cls(port, backend_port, algorithm, bandwidth, sticky_session,
                   health_check, certificate_id, extra=extra)


class SLBLoadBalancerTcpListener(SLBLoadBalancerListener):
    """
    This class represents a rule to route tcp request to the backends.
    """
    action = 'CreateLoadBalancerTCPListener'
    option_keys = ['PersistenceTimeout', 'HealthCheckType',
                   'HealthCheckDomain', 'HealthCheckURI',
                   'HealthCheckConnectPort', 'HealthyThreshold',
                   'UnhealthyThreshold', 'HealthCheckConnectTimeout',
                   'HealthCheckInterval', 'HealthCheckHttpCode']


class SLBLoadBalancerUdpListener(SLBLoadBalancerTcpListener):
    """
    This class represents a rule to route udp request to the backends.
    """
    action = 'CreateLoadBalancerUDPListener'
    option_keys = ['PersistenceTimeout', 'HealthCheckConnectPort',
                   'HealthyThreshold', 'UnhealthyThreshold',
                   'HealthCheckConnectTimeout', 'HealthCheckInterval']


class SLBServerCertificate(ReprMixin, object):
    _repr_attributes = ['id', 'name', 'fingerprint']

    def __init__(self, id, name, fingerprint):
        self.id = id
        self.name = name
        self.fingerprint = fingerprint


PROTOCOL_TO_LISTENER_MAP = {
    'http': SLBLoadBalancerHttpListener,
    'https': SLBLoadBalancerHttpsListener,
    'tcp': SLBLoadBalancerTcpListener,
    'udp': SLBLoadBalancerUdpListener
}


class SLBDriver(Driver):
    """
    Aliyun SLB load balancer driver.
    """
    name = 'Aliyun Server Load Balancer'
    website = 'https://www.aliyun.com/product/slb'
    connectionCls = SLBConnection
    path = '/'
    namespace = None

    _VALUE_TO_ALGORITHM_MAP = SLB_SCHEDULER_TO_ALGORITHM

    _ALGORITHM_TO_VALUE_MAP = ALGORITHM_TO_SLB_SCHEDULER

    def __init__(self, access_id, secret, region):
        super(SLBDriver, self).__init__(access_id, secret)
        self.region = region

    def list_protocols(self):
        return list(PROTOCOL_TO_LISTENER_MAP.keys())

    def list_balancers(self, ex_balancer_ids=None, ex_filters=None):
        """
        List all loadbalancers

        @inherits :class:`Driver.list_balancers`

        :keyword ex_balancer_ids: a list of balancer ids to filter results
                                  Only balancers which's id in this list
                                  will be returned
        :type ex_balancer_ids: ``list`` of ``str``

        :keyword ex_filters: attributes to filter results. Only balancers
                             which have all the desired attributes
                             and values will be returned
        :type ex_filters: ``dict``
        """

        params = {'Action': 'DescribeLoadBalancers',
                  'RegionId': self.region}
        if ex_balancer_ids and isinstance(ex_balancer_ids, list):
            params['LoadBalancerId'] = ','.join(ex_balancer_ids)

        if ex_filters and isinstance(ex_filters, dict):
            ex_filters.update(params)
            params = ex_filters
        resp_body = self.connection.request(self.path, params=params).object
        return self._to_balancers(resp_body)

    def create_balancer(self, name, port, protocol, algorithm, members,
                        ex_bandwidth=None, ex_internet_charge_type=None,
                        ex_address_type=None, ex_vswitch_id=None,
                        ex_master_zone_id=None, ex_slave_zone_id=None,
                        ex_client_token=None,
                        **kwargs):
        """
        Create a new load balancer instance

        @inherits: :class:`Driver.create_balancer`

        :keyword ex_bandwidth: The max bandwidth limit for `paybybandwidth`
                               internet charge type, in Mbps unit
        :type ex_bandwidth: ``int`` in range [1, 1000]

        :keyword ex_internet_charge_type: The internet charge type
        :type ex_internet_charge_type: a ``str`` of `paybybandwidth`
                                       or `paybytraffic`

        :keyword ex_address_type: The listening IP address type
        :type ex_address_type: a ``str`` of `internet` or `intranet`

        :keyword ex_vswitch_id: The vswitch id in a VPC network
        :type ex_vswitch_id: ``str``

        :keyword ex_master_zone_id: The id of the master availability zone
        :type ex_master_zone_id: ``str``

        :keyword ex_slave_zone_id: The id of the slave availability zone
        :type ex_slave_zone_id: ``str``

        :keyword ex_client_token: The token generated by client to
                                  identify requests
        :type ex_client_token: ``str``
        """

        # 1.Create load balancer
        params = {'Action': 'CreateLoadBalancer',
                  'RegionId': self.region}
        if name:
            params['LoadBalancerName'] = name
        if not port:
            raise AttributeError('port is required')
        if not protocol:
            # NOTE(samsong8610): Use http listener as default
            protocol = 'http'
        if protocol not in PROTOCOL_TO_LISTENER_MAP:
            raise AttributeError('unsupport protocol %s' % protocol)

        # Bandwidth in range [1, 1000] Mbps
        bandwidth = -1
        if ex_bandwidth:
            try:
                bandwidth = int(ex_bandwidth)
            except ValueError:
                raise AttributeError('ex_bandwidth should be a integer in '
                                     'range [1, 1000].')
            params['Bandwidth'] = bandwidth

        if ex_internet_charge_type:
            if ex_internet_charge_type.lower() == 'paybybandwidth':
                if bandwidth == -1:
                    raise AttributeError('PayByBandwidth internet charge type'
                                         ' need ex_bandwidth be set')
            params['InternetChargeType'] = ex_internet_charge_type

        if ex_address_type:
            if ex_address_type.lower() not in ('internet', 'intranet'):
                raise AttributeError('ex_address_type should be "internet" '
                                     'or "intranet"')
            params['AddressType'] = ex_address_type

        if ex_vswitch_id:
            params['VSwitchId'] = ex_vswitch_id

        if ex_master_zone_id:
            params['MasterZoneId'] = ex_master_zone_id
        if ex_slave_zone_id:
            params['SlaveZoneId'] = ex_slave_zone_id

        if ex_client_token:
            params['ClientToken'] = ex_client_token

        if members and isinstance(members, list):
            backend_ports = [member.port for member in members]
            if len(set(backend_ports)) != 1:
                raise AttributeError('the ports of members should be unique')
            # NOTE(samsong8610): If members do not provide backend port,
            #                    default to listening port
            backend_port = backend_ports[0] or port
        else:
            backend_port = port

        balancer = None
        try:
            resp_body = self.connection.request(self.path, params).object
            balancer = self._to_balancer(resp_body)
            balancer.port = port

            # 2.Add backend servers
            if members is None:
                members = []
            for member in members:
                self.balancer_attach_member(balancer, member)
            # 3.Create listener
            # NOTE(samsong8610): Assume only create a listener which uses all
            #                    the bandwidth.
            self.ex_create_listener(balancer, backend_port, protocol,
                                    algorithm, bandwidth, **kwargs)
            self.ex_start_listener(balancer, port)
            return balancer
        except Exception as e:
            if balancer is not None:
                try:
                    self.destroy_balancer(balancer)
                except Exception:
                    pass
            raise e

    def destroy_balancer(self, balancer):
        params = {'Action': 'DeleteLoadBalancer',
                  'LoadBalancerId': balancer.id}
        resp = self.connection.request(self.path, params)
        return resp.success()

    def get_balancer(self, balancer_id):
        balancers = self.list_balancers(ex_balancer_ids=[balancer_id])
        if len(balancers) != 1:
            raise LibcloudError('could not find load balancer with id %s' %
                                balancer_id)
        return balancers[0]

    def balancer_attach_compute_node(self, balancer, node):
        if len(node.public_ips) > 0:
            ip = node.public_ips[0]
        else:
            ip = node.private_ips[0]
        member = Member(id=node.id, ip=ip, port=balancer.port)
        return self.balancer_attach_member(balancer, member)

    def balancer_attach_member(self, balancer, member):
        params = {'Action': 'AddBackendServers',
                  'LoadBalancerId': balancer.id}
        if member and isinstance(member, Member):
            params['BackendServers'] = self._to_servers_json([member])
        self.connection.request(self.path, params)
        return member

    def balancer_detach_member(self, balancer, member):
        params = {'Action': 'RemoveBackendServers',
                  'LoadBalancerId': balancer.id}
        if member and isinstance(member, Member):
            params['BackendServers'] = self._list_to_json([member.id])
        self.connection.request(self.path, params)
        return member

    def balancer_list_members(self, balancer):
        attribute = self.ex_get_balancer_attribute(balancer)
        members = [Member(server['ServerId'], None, None, balancer=balancer,
                          extra={'Weight': server['Weight']})
                   for server in attribute.backend_servers]
        return members

    def ex_get_balancer_attribute(self, balancer):
        """
        Get balancer attribute

        :param balancer: the balancer to get attribute
        :type balancer: ``LoadBalancer``

        :return: the balancer attribute
        :rtype: ``SLBLoadBalancerAttribute``
        """

        params = {'Action': 'DescribeLoadBalancerAttribute',
                  'LoadBalancerId': balancer.id}
        resp_body = self.connection.request(self.path, params).object
        attribute = self._to_balancer_attribute(resp_body)
        return attribute

    def ex_list_listeners(self, balancer):
        """
        Get all listener related to the given balancer

        :param balancer: the balancer to list listeners
        :type balancer: ``LoadBalancer``

        :return: a list of listeners
        :rtype: ``list`` of ``SLBLoadBalancerListener``
        """

        attribute = self.ex_get_balancer_attribute(balancer)
        listeners = [SLBLoadBalancerListener(each['ListenerPort'], None,
                                             None, None)
                     for each in attribute.listeners]
        return listeners

    def ex_create_listener(self, balancer, backend_port, protocol, algorithm,
                           bandwidth, **kwargs):
        """
        Create load balancer listening rule.

        :param balancer: the balancer which the rule belongs to.
                         The listener created will listen on the port of the
                         the balancer as default. 'ListenerPort' in kwargs
                         will *OVERRIDE* it.
        :type balancer: ``LoadBalancer``

        :param backend_port: the backend server port
        :type backend_port: ``int``

        :param protocol: the balancer protocol, default to http
        :type protocol: ``str``

        :param algorithm: the balancer routing algorithm
        :type algorithm: ``Algorithm``

        :param bandwidth: the listener bandwidth limits
        :type bandwidth: ``str``

        :return: the created listener
        :rtype: ``SLBLoadBalancerListener``
        """

        cls = PROTOCOL_TO_LISTENER_MAP.get(protocol,
                                           SLBLoadBalancerHttpListener)
        if 'ListenerPort' in kwargs:
            port = kwargs['ListenerPort']
        else:
            port = balancer.port
        listener = cls.create(port, backend_port, algorithm,
                              bandwidth, extra=kwargs)
        params = listener.get_create_params()
        params['LoadBalancerId'] = balancer.id
        params['RegionId'] = self.region
        resp = self.connection.request(self.path, params)
        return resp.success()

    def ex_start_listener(self, balancer, port):
        """
        Start balancer's listener listening the given port.

        :param balancer: a load balancer
        :type balancer: ``LoadBalancer``

        :param port: listening port
        :type port: ``int``

        :return: whether operation is success
        :rtype: ``bool``
        """

        params = {'Action': 'StartLoadBalancerListener',
                  'LoadBalancerId': balancer.id,
                  'ListenerPort': port}
        resp = self.connection.request(self.path, params)
        return resp.success()

    def ex_stop_listener(self, balancer, port):
        """
        Stop balancer's listener listening the given port.

        :param balancer: a load balancer
        :type balancer: ``LoadBalancer``

        :param port: listening port
        :type port: ``int``

        :return: whether operation is success
        :rtype: ``bool``
        """

        params = {'Action': 'StopLoadBalancerListener',
                  'LoadBalancerId': balancer.id,
                  'ListenerPort': port}
        resp = self.connection.request(self.path, params)
        return resp.success()

    def ex_upload_certificate(self, name, server_certificate,
                              private_key):
        """
        Upload certificate and private key for https load balancer listener

        :param name: the certificate name
        :type name: ``str``

        :param server_certificate: the content of the certificate to upload
                                   in PEM format
        :type server_certificate: ``str``

        :param private_key: the content of the private key to upload
                            in PEM format
        :type private_key: ``str``

        :return: new created certificate info
        :rtype: ``SLBServerCertificate``
        """

        params = {'Action': 'UploadServerCertificate',
                  'RegionId': self.region,
                  'ServerCertificate': server_certificate,
                  'PrivateKey': private_key}
        if name:
            params['ServerCertificateName'] = name
        resp_body = self.connection.request(self.path, params).object
        return self._to_server_certificate(resp_body)

    def ex_list_certificates(self, certificate_ids=[]):
        """
        List all server certificates

        :param certificate_ids: certificate ids to filter results
        :type certificate_ids: ``str``

        :return: certificates
        :rtype: ``SLBServerCertificate``
        """

        params = {'Action': 'DescribeServerCertificates',
                  'RegionId': self.region}
        if certificate_ids and isinstance(certificate_ids, list):
            params['ServerCertificateId'] = ','.join(certificate_ids)

        resp_body = self.connection.request(self.path, params).object
        cert_elements = findall(resp_body,
                                'ServerCertificates/ServerCertificate',
                                namespace=self.namespace)
        certificates = [self._to_server_certificate(el)
                        for el in cert_elements]
        return certificates

    def ex_delete_certificate(self, certificate_id):
        """
        Delete the given server certificate

        :param certificate_id: the id of the certificate to delete
        :type certificate_id: ``str``

        :return: whether process is success
        :rtype: ``bool``
        """

        params = {'Action': 'DeleteServerCertificate',
                  'RegionId': self.region,
                  'ServerCertificateId': certificate_id}
        resp = self.connection.request(self.path, params)
        return resp.success()

    def ex_set_certificate_name(self, certificate_id, name):
        """
        Set server certificate name.

        :param certificate_id: the id of the server certificate to update
        :type certificate_id: ``str``

        :param name: the new name
        :type name: ``str``

        :return: whether updating is success
        :rtype: ``bool``
        """

        params = {'Action': 'SetServerCertificateName',
                  'RegionId': self.region,
                  'ServerCertificateId': certificate_id,
                  'ServerCertificateName': name}
        resp = self.connection.request(self.path, params)
        return resp.success()

    def _to_balancers(self, element):
        xpath = 'LoadBalancers/LoadBalancer'
        return [self._to_balancer(el)
                for el in findall(element=element, xpath=xpath,
                                  namespace=self.namespace)]

    def _to_balancer(self, el):
        _id = findtext(element=el, xpath='LoadBalancerId',
                       namespace=self.namespace)
        name = findtext(element=el, xpath='LoadBalancerName',
                        namespace=self.namespace)
        status = findtext(element=el, xpath='LoadBalancerStatus',
                          namespace=self.namespace)
        state = STATE_MAPPINGS.get(status, State.UNKNOWN)
        address = findtext(element=el, xpath='Address',
                           namespace=self.namespace)
        extra = self._get_extra_dict(
            el, RESOURCE_EXTRA_ATTRIBUTES_MAP['balancer'])

        balancer = LoadBalancer(id=_id, name=name, state=state, ip=address,
                                port=None, driver=self, extra=extra)
        return balancer

    def _create_list_params(self, params, items, label):
        """
        return parameter list
        """
        if isinstance(items, str):
            items = [items]
        for index, item in enumerate(items):
            params[label % (index + 1)] = item
        return params

    def _get_extra_dict(self, element, mapping):
        """
        Extract attributes from the element based on rules provided in the
        mapping dictionary.

        :param      element: Element to parse the values from.
        :type       element: xml.etree.ElementTree.Element.

        :param      mapping: Dictionary with the extra layout
        :type       node: :class:`Node`

        :rtype: ``dict``
        """
        extra = {}
        for attribute, values in mapping.items():
            transform_func = values['transform_func']
            value = findattr(element=element,
                             xpath=values['xpath'],
                             namespace=self.namespace)
            if value:
                try:
                    extra[attribute] = transform_func(value)
                except Exception:
                    extra[attribute] = None
            else:
                extra[attribute] = value

        return extra

    def _to_servers_json(self, members):
        servers = []
        for each in members:
            server = {'ServerId': each.id,
                      'Weight': '100'}
            if 'Weight' in each.extra:
                server['Weight'] = each.extra['Weight']
            servers.append(server)
        try:
            return json.dumps(servers)
        except Exception:
            raise AttributeError('could not convert member to backend server')

    def _to_balancer_attribute(self, element):
        balancer = self._to_balancer(element)
        port_proto_elements = findall(
            element, 'ListenerPortsAndProtocol/ListenerPortAndProtocol',
            namespace=self.namespace)
        if len(port_proto_elements) > 0:
            listeners = [self._to_port_and_protocol(el)
                         for el in port_proto_elements]
        else:
            port_elements = findall(element, 'ListenerPorts/ListenerPort',
                                    namespace=self.namespace)
            listeners = [{'ListenerPort': el.text, 'ListenerProtocol': 'http'}
                         for el in port_elements]
        server_elements = findall(element,
                                  'BackendServers/BackendServer',
                                  namespace=self.namespace)
        backend_servers = [self._to_server_and_weight(el)
                           for el in server_elements]
        return SLBLoadBalancerAttribute(balancer, listeners, backend_servers)

    def _to_port_and_protocol(self, el):
        port = findtext(el, 'ListenerPort', namespace=self.namespace)
        protocol = findtext(el, 'ListenerProtocol', namespace=self.namespace)
        return {'ListenerPort': port, 'ListenerProtocol': protocol}

    def _to_server_and_weight(self, el):
        server_id = findtext(el, 'ServerId', namespace=self.namespace)
        weight = findtext(el, 'Weight', namespace=self.namespace)
        return {'ServerId': server_id, 'Weight': weight}

    def _to_server_certificate(self, el):
        _id = findtext(el, 'ServerCertificateId', namespace=self.namespace)
        name = findtext(el, 'ServerCertificateName', namespace=self.namespace)
        fingerprint = findtext(el, 'Fingerprint', namespace=self.namespace)
        return SLBServerCertificate(id=_id, name=name,
                                    fingerprint=fingerprint)

    def _list_to_json(self, value):
        try:
            return json.dumps(value)
        except Exception:
            return '[]'