#!/usr/bin/python
#
# This is a free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This Ansible library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this library.  If not, see <http://www.gnu.org/licenses/>.

ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'community'}


DOCUMENTATION = '''
---
module: ec2_elb_facts
short_description: Gather facts about EC2 Elastic Load Balancers in AWS
description:
    - Gather facts about EC2 Elastic Load Balancers in AWS
version_added: "2.0"
author:
  - "Michael Schultz (github.com/mjschultz)"
  - "Fernando Jose Pando (@nand0p)"
options:
  names:
    description:
      - List of ELB names to gather facts about. Pass this option to gather facts about a set of ELBs, otherwise, all ELBs are returned.
    aliases: ['elb_ids', 'ec2_elbs']
extends_documentation_fragment:
    - aws
    - ec2
'''

EXAMPLES = '''
# Note: These examples do not set authentication details, see the AWS Guide for details.
# Output format tries to match ec2_elb_lb module input parameters

# Gather facts about all ELBs
- action:
    module: ec2_elb_facts
  register: elb_facts

- action:
    module: debug
    msg: "{{ item.dns_name }}"
  with_items: "{{ elb_facts.elbs }}"

# Gather facts about a particular ELB
- action:
    module: ec2_elb_facts
    names: frontend-prod-elb
  register: elb_facts

- action:
    module: debug
    msg: "{{ elb_facts.elbs.0.dns_name }}"

# Gather facts about a set of ELBs
- action:
    module: ec2_elb_facts
    names:
    - frontend-prod-elb
    - backend-prod-elb
  register: elb_facts

- action:
    module: debug
    msg: "{{ item.dns_name }}"
  with_items: "{{ elb_facts.elbs }}"

'''

import traceback

from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.ec2 import (
    AWSRetry,
    connect_to_aws,
    ec2_argument_spec,
    get_aws_connection_info,
)

try:
    import boto.ec2.elb
    from boto.ec2.tag import Tag
    from boto.exception import BotoServerError
    HAS_BOTO = True
except ImportError:
    HAS_BOTO = False


class ElbInformation(object):
    """Handles ELB information."""

    def __init__(self,
                 module,
                 names,
                 region,
                 **aws_connect_params):

        self.module = module
        self.names = names
        self.region = region
        self.aws_connect_params = aws_connect_params
        self.connection = self._get_elb_connection()

    def _get_tags(self, elbname):
        params = {'LoadBalancerNames.member.1': elbname}
        elb_tags = self.connection.get_list('DescribeTags', params, [('member', Tag)])
        return dict((tag.Key, tag.Value) for tag in elb_tags if hasattr(tag, 'Key'))

    @AWSRetry.backoff(tries=5, delay=5, backoff=2.0)
    def _get_elb_connection(self):
        return connect_to_aws(boto.ec2.elb, self.region, **self.aws_connect_params)

    def _get_elb_listeners(self, listeners):
        listener_list = []

        for listener in listeners:
            listener_dict = {
                'load_balancer_port': listener[0],
                'instance_port': listener[1],
                'protocol': listener[2],
                'instance_protocol': listener[3]
            }

            try:
                ssl_certificate_id = listener[4]
            except IndexError:
                pass
            else:
                if ssl_certificate_id:
                    listener_dict['ssl_certificate_id'] = ssl_certificate_id

            listener_list.append(listener_dict)

        return listener_list

    def _get_health_check(self, health_check):
        protocol, port_path = health_check.target.split(':')
        try:
            port, path = port_path.split('/', 1)
            path = '/{0}'.format(path)
        except ValueError:
            port = port_path
            path = None

        health_check_dict = {
            'ping_protocol': protocol.lower(),
            'ping_port': int(port),
            'response_timeout': health_check.timeout,
            'interval': health_check.interval,
            'unhealthy_threshold': health_check.unhealthy_threshold,
            'healthy_threshold': health_check.healthy_threshold,
        }

        if path:
            health_check_dict['ping_path'] = path
        return health_check_dict

    @AWSRetry.backoff(tries=5, delay=5, backoff=2.0)
    def _get_elb_info(self, elb):
        elb_info = {
            'name': elb.name,
            'zones': elb.availability_zones,
            'dns_name': elb.dns_name,
            'canonical_hosted_zone_name': elb.canonical_hosted_zone_name,
            'canonical_hosted_zone_name_id': elb.canonical_hosted_zone_name_id,
            'hosted_zone_name': elb.canonical_hosted_zone_name,
            'hosted_zone_id': elb.canonical_hosted_zone_name_id,
            'instances': [instance.id for instance in elb.instances],
            'listeners': self._get_elb_listeners(elb.listeners),
            'scheme': elb.scheme,
            'security_groups': elb.security_groups,
            'health_check': self._get_health_check(elb.health_check),
            'subnets': elb.subnets,
            'instances_inservice': [],
            'instances_inservice_count': 0,
            'instances_outofservice': [],
            'instances_outofservice_count': 0,
            'instances_inservice_percent': 0.0,
            'tags': self._get_tags(elb.name)
        }

        if elb.vpc_id:
            elb_info['vpc_id'] = elb.vpc_id

        if elb.instances:
            instance_health = self.connection.describe_instance_health(elb.name)
            elb_info['instances_inservice'] = [inst.instance_id for inst in instance_health if inst.state == 'InService']
            elb_info['instances_inservice_count'] = len(elb_info['instances_inservice'])
            elb_info['instances_outofservice'] = [inst.instance_id for inst in instance_health if inst.state == 'OutOfService']
            elb_info['instances_outofservice_count'] = len(elb_info['instances_outofservice'])
            try:
                elb_info['instances_inservice_percent'] = (
                    float(elb_info['instances_inservice_count']) /
                    float(elb_info['instances_inservice_count'] + elb_info['instances_outofservice_count'])
                ) * 100.
            except ZeroDivisionError:
                elb_info['instances_inservice_percent'] = 0.
        return elb_info

    def list_elbs(self):
        elb_array, token = [], None
        get_elb_with_backoff = AWSRetry.backoff(tries=5, delay=5, backoff=2.0)(self.connection.get_all_load_balancers)
        while True:
            all_elbs = get_elb_with_backoff(marker=token)
            token = all_elbs.next_marker

            if all_elbs:
                if self.names:
                    for existing_lb in all_elbs:
                        if existing_lb.name in self.names:
                            elb_array.append(existing_lb)
                else:
                    elb_array.extend(all_elbs)
            else:
                break

            if token is None:
                break

        return list(map(self._get_elb_info, elb_array))


def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(
        names={'default': [], 'type': 'list'}
    )
    )
    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)

    if not HAS_BOTO:
        module.fail_json(msg='boto required for this module')

    try:
        region, ec2_url, aws_connect_params = get_aws_connection_info(module)
        if not region:
            module.fail_json(msg="region must be specified")

        names = module.params['names']
        elb_information = ElbInformation(
            module, names, region, **aws_connect_params)

        ec2_facts_result = dict(changed=False,
                                elbs=elb_information.list_elbs())

    except BotoServerError as err:
        module.fail_json(msg="{0}: {1}".format(err.error_code, err.error_message),
                         exception=traceback.format_exc())

    module.exit_json(**ec2_facts_result)


if __name__ == '__main__':
    main()
