#!/usr/bin/python
#
# Copyright (c) 2021 Aparna Patil(@aparna-patil)
#
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import absolute_import, division, print_function
__metaclass__ = type

DOCUMENTATION = '''
---
module: azure_rm_hostgroup

version_added: "1.10.0"

short_description: Create, delete and update a dedicated host group

description:
    - Creates, deletes, and updates a dedicated host group.

options:
    resource_group:
        description:
            - Name of resource group.
        required: true
        type: str
    name:
        description:
            - The name of the dedicated host group.
        required: true
        type: str
    location:
        description:
            - Valid Azure location for host group. Defaults to location of resource group.
        type: str
    platform_fault_domain_count:
        description:
            - Number of fault domains that the host group can span.
        type: int
    zones:
        description:
            - Availability Zone to use for this host group. Only single zone is supported. The zone can be assigned only
             during creation. If not provided, the group supports all zones in the region.
        type: list
        elements: str
    state:
        description:
            - Assert the state of the host group. Use C(present) to create or update and C(absent) to delete.
        default: present
        type: str
        choices:
            - absent
            - present

extends_documentation_fragment:
    - azure.azcollection.azure
    - azure.azcollection.azure_tags

author:
    - Aparna Patil (@aparna-patil)
'''

EXAMPLES = '''
- name: Create a host group
  azure_rm_hostgroup:
    resource_group: myAzureResourceGroup
    name: myhostgroup
    location: eastus
    zones:
      - "1"
    platform_fault_domain_count: 1
    state: present

- name: Update a host group
  azure_rm_hostgroup:
    resource_group: myAzureResourceGroup
    name: myhostgroup
    location: eastus
    zones:
      - "1"
    platform_fault_domain_count: 1
    state: present
    tags:
      key1: "value1"

- name: Delete a host group
  azure_rm_hostgroup:
    resource_group: myAzureResourceGroup
    name: myhostgroup
    state: absent
'''

RETURN = '''
state:
    description:
        - Current state of the host group.
    returned: always
    type: complex
    contains:
        id:
            description:
                - The host group ID.
            returned: always
            type: str
            sample: "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myAzureResourceGroup/providers/
                     Microsoft.Compute/hostGroups/myhostgroup"
        name:
            description:
                - The host group name.
            returned: always
            type: str
            sample: 'myhostgroup'
        location:
            description:
                - The Azure Region where the resource lives.
            returned: always
            type: str
            sample: eastus
        platform_fault_domain_count:
            description:
                - Number of fault domains.
            returned: always
            type: int
            sample: 1
        zones:
            description:
                - Availability zones configured for this host group.
            returned: always
            type: list
            sample: ["1"]
        tags:
            description:
                - Resource tags.
            returned: always
            type: list
            sample: [{"key1": "value1"}]
        type:
            description:
                - The type of resource.
            returned: always
            type: str
            sample: Microsoft.Compute/hostGroups
'''

from ansible.module_utils.basic import _load_params
from ansible_collections.azure.azcollection.plugins.module_utils.azure_rm_common import AzureRMModuleBase, \
    normalize_location_name

try:
    from azure.core.exceptions import ResourceNotFoundError
except ImportError:
    # This is handled in azure_rm_common
    pass


class AzureRMHostGroup(AzureRMModuleBase):

    def __init__(self):

        _load_params()
        # define user inputs from playbook
        self.module_arg_spec = dict(
            resource_group=dict(type='str', required=True),
            name=dict(type='str', required=True),
            location=dict(type='str'),
            platform_fault_domain_count=dict(type='int'),
            zones=dict(type='list', elements='str'),
            state=dict(choices=['present', 'absent'], default='present', type='str')
        )

        required_if = [
            ('state', 'present', ['platform_fault_domain_count'])
        ]

        self.results = dict(
            changed=False,
            state=dict()
        )

        self.resource_group = None
        self.name = None
        self.state = None
        self.location = None
        self.tags = None
        self.platform_fault_domain_count = None
        self.zones = None

        super(AzureRMHostGroup, self).__init__(self.module_arg_spec,
                                               required_if=required_if,
                                               supports_check_mode=True)

    def exec_module(self, **kwargs):
        for key in list(self.module_arg_spec.keys()) + ['tags']:
            setattr(self, key, kwargs[key])

        changed = False
        results = dict()
        host_group = None

        # retrieve resource group to make sure it exists
        resource_group = self.get_resource_group(self.resource_group)
        if not self.location:
            # Set default location
            self.location = resource_group.location

        self.location = normalize_location_name(self.location)

        try:
            self.log('Fetching host group {0}'.format(self.name))
            host_group = self.compute_client.dedicated_host_groups.get(self.resource_group, self.name)
            # serialize object into a dictionary
            results = self.hostgroup_to_dict(host_group)
            if self.state == 'present':
                changed = False
                update_tags, results['tags'] = self.update_tags(results['tags'])
                if update_tags:
                    changed = True
                self.tags = results['tags']
                if self.platform_fault_domain_count != results['platform_fault_domain_count']:
                    self.fail("Error updating host group : {0}. Changing platform_fault_domain_count is not allowed."
                              .format(self.name))
                if self.zones:
                    if ('zones' in results and self.zones[0] != results['zones'][0]) or 'zones' not in results:
                        self.fail("Error updating host group : {0}. Changing property zones is not allowed."
                                  .format(self.name))
            elif self.state == 'absent':
                changed = True

        except ResourceNotFoundError:
            if self.state == 'present':
                changed = True
            else:
                changed = False

        self.results['changed'] = changed
        self.results['state'] = results

        if self.check_mode:
            return self.results

        if changed:
            if self.state == 'present':
                # create or update a dedicated host group
                host_group_new = \
                    self.compute_models.DedicatedHostGroup(location=self.location,
                                                           platform_fault_domain_count=self.platform_fault_domain_count,
                                                           zones=self.zones)
                if self.tags:
                    host_group_new.tags = self.tags
                self.results['state'] = self.create_or_update_hostgroup(host_group_new)

            elif self.state == 'absent':
                # delete a host group
                self.delete_hostgroup()
                self.results['state'] = 'Deleted'

        return self.results

    def create_or_update_hostgroup(self, host_group):
        try:
            # create the host group
            response = self.compute_client.dedicated_host_groups.create_or_update(
                resource_group_name=self.resource_group,
                host_group_name=self.name,
                parameters=host_group)
        except Exception as exc:
            self.fail("Error creating or updating host group {0} - {1}".format(self.name, str(exc)))
        return self.hostgroup_to_dict(response)

    def delete_hostgroup(self):
        try:
            # delete the host group
            response = self.compute_client.dedicated_host_groups.delete(resource_group_name=self.resource_group,
                                                                        host_group_name=self.name)
        except Exception as exc:
            self.fail("Error deleting host group {0} - {1}".format(self.name, str(exc)))
        return response

    def hostgroup_to_dict(self, hostgroup):
        result = hostgroup.as_dict()
        result['tags'] = hostgroup.tags
        return result


def main():
    AzureRMHostGroup()


if __name__ == '__main__':
    main()
