#!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright: (c) 2020, Infinidat <info@infinidat.com>
# 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


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


DOCUMENTATION = r'''
---
module: infini_port
version_added: 2.10
short_description: Add and Delete fiber channel and iSCSI ports to a host on Infinibox
description:
    - This module adds or deletes fiber channel or iSCSI ports to hosts on
      Infinibox.
author: David Ohlemacher (@ohlemacher)
options:
  name:
    description:
      - Host Name
    required: true
  state:
    description:
      - Creates mapping when present, removes when absent, or provides
        details of a mapping when stat.
    required: false
    default: present
    choices: [ "stat", "present", "absent" ]
  wwns:
    description:
      - List of wwns of the host
    required: false
    default: []
  iqns:
    description:
      - List of iqns of the host
    required: false
    default: []
extends_documentation_fragment:
    - infinibox
'''

EXAMPLES = r'''
- name: Make sure host bar is available with wwn/iqn ports
  infini_host:
    name: bar.example.com
    state: present
    wwns:
      - "00:00:00:00:00:00:00"
      - "11:11:11:11:11:11:11"
    iqns:
        - "iqn.yyyy-mm.reverse-domain:unique-string"
    system: ibox01
    user: admin
    password: secret
'''

# RETURN = r''' # '''

from ansible.module_utils.basic import AnsibleModule, missing_required_lib
from ansible_collections.infinidat.infinibox.plugins.module_utils.infinibox import \
    HAS_INFINISDK, api_wrapper, infinibox_argument_spec, \
    get_system, get_host, merge_two_dicts
from infi.dtypes.wwn import WWN
from infi.dtypes.iqn import make_iscsi_name

@api_wrapper
def update_ports(module, system):
    """
    Updated mapping of volume to host. If already mapped, exit_json with changed False.
    """
    changed = False

    host = system.hosts.get(name=module.params['host'])

    for wwn_port in module.params['wwns']:
        wwn = WWN(wwn_port)
        if not system.hosts.get_host_by_initiator_address(wwn) == host:
            if not module.check_mode:
                host.add_port(wwn)
            changed = True

    for iscsi_port in module.params['iqns']:
        iscsi_name = make_iscsi_name(iscsi_port)
        if not system.hosts.get_host_by_initiator_address(iscsi_name) == host:
            if not module.check_mode:
                host.add_port(iscsi_name)
            changed = True

    return changed


@api_wrapper
def delete_ports(module, system):
    """
    Remove ports from host.
    """
    changed = False

    host = system.hosts.get(name=module.params['host'])
    for wwn_port in module.params['wwns']:
        wwn = WWN(wwn_port)
        if system.hosts.get_host_by_initiator_address(wwn) == host:
            if not module.check_mode:
                host.remove_port(wwn)
            changed = True
    for iscsi_port in module.params['iqns']:
        iscsi_name = make_iscsi_name(iscsi_port)
        if system.hosts.get_host_by_initiator_address(iscsi_name) == host:
            if not module.check_mode:
                host.remove_port(iscsi_name)
            changed = True
    return changed


def get_sys_host(module):
    system = get_system(module)
    host = get_host(module, system)
    return (system, host)


def edit_initiator_keys(host_initiators, include_key_list):
    """
    For each host initiator, remove keys not in the include_key_list.
    For FCs, add a long address. This is the address with colons inserted.
    Return the edited host initiators list.
    """
    trimmed_initiators = []
    for init in host_initiators:
        if init['type'] == 'FC' and 'address' in init.keys():
            # Add address_long key to init whose value is the address with colons inserted.
            address_str = str(init['address'])
            address_iter = iter(address_str)
            long_address = ':'.join(a+b for a, b in zip(address_iter, address_iter))
            init['address_long'] = long_address

        trimmed_item = {key:val for key, val in init.items() if key in include_key_list}
        trimmed_initiators.append(trimmed_item)
    return trimmed_initiators


def find_host_initiators_data(module, system, host, initiator_type):
    """
    Given a host object, find its initiators that match initiator_type.
    Only include desired initiator keys for each initiator.
    Return the filtered and edited host initiator list.
    """
    request = 'initiators?page=1&page_size=1000&host_id={0}'.format(host.id)
    #print("\nrequest:", request, "initiator_type:", initiator_type)
    get_initiators_result = system.api.get(request, check_version=False)
    result_code = get_initiators_result.status_code
    if result_code != 200:
        msg = 'get initiators REST call failed. code: {0}'.format(result_code)
        module.fail_json(msg=msg)

    # Only return initiators of the desired type.
    host_initiators_by_type = [initiator for initiator in get_initiators_result.get_result() \
                               if initiator['type'] == initiator_type]


    #print("host_initiators_by_type:", host_initiators_by_type)
    #print()

    # Only include certain keys in the returned initiators
    if  initiator_type == 'FC':
        include_key_list = ['address', 'address_long', 'host_id', 'port_key', 'targets', 'type']
    elif initiator_type == 'ISCSI':
        include_key_list = ['address', 'host_id', 'port_key', 'targets', 'type']
    else:
        msg = 'Cannot search for host initiator types other than FC and ISCSI'
        module.fail_json(msg=msg)
    host_initiators_by_type = edit_initiator_keys(host_initiators_by_type, include_key_list)

    return host_initiators_by_type


def get_port_fields(module, system, host):
    """
    Return a dict with desired fields from FC and ISCSI ports associated with the host.
    """
    host_fc_initiators    = find_host_initiators_data(module, system, host, initiator_type='FC')
    host_iscsi_initiators = find_host_initiators_data(module, system, host, initiator_type='ISCSI')

    field_dict = dict(
        ports=[],
    )

    connectivity_lut = {
        0: "DISCONNECTED",
        1: "DEGRADED",
        2: "DEGRADED",
        3: "CONNECTED"
    }

    ports = host.get_ports()
    for port in ports:
        if str(type(port)) == "<class 'infi.dtypes.wwn.WWN'>":
            found_initiator = False
            for initiator in host_fc_initiators:
                if initiator['address'] == str(port).replace(":", ""):
                    found_initiator = True
                    #print("initiator targets:", initiator['targets'])
                    unique_initiator_target_ids = \
                        {target['node_id'] for target in initiator['targets']}
                    port_dict = {
                        "address": str(port),
                        "address_long": initiator['address_long'],
                        "connectivity": connectivity_lut[len(unique_initiator_target_ids)],
                        "targets": initiator['targets'],
                        "type": initiator['type'],
                    }

            if not found_initiator:
                address_str = str(port)
                address_iter = iter(address_str)
                long_address = ':'.join(a+b for a, b in zip(address_iter, address_iter))
                port_dict = {
                    "address": str(port),
                    "address_long": long_address,
                    "connectivity": connectivity_lut[0],
                    "targets": [],
                    "type": "FC"
                }

            field_dict['ports'].append(port_dict)

        if str(type(port)) == "<class 'infi.dtypes.iqn.IQN'>":
            found_initiator = False
            for initiator in host_iscsi_initiators:
                if initiator['address'] == str(port):
                    found_initiator = True
                    #print("initiator targets:", initiator['targets'])
                    unique_initiator_target_ids = \
                        {target['node_id'] for target in initiator['targets']}
                    port_dict = {
                        "address": str(port),
                        "connectivity": connectivity_lut[len(unique_initiator_target_ids)],
                        "targets": initiator['targets'],
                        "type": initiator['type'],
                    }

            if not found_initiator:
                port_dict = {
                    "address": str(port),
                    "connectivity": connectivity_lut[0],
                    "targets": [],
                    "type": "ISCSI"
                }

            field_dict['ports'].append(port_dict)

    return field_dict


def handle_stat(module):
    """
    Handle stat state. Fail if host is None.
    Return json with status.
    """
    system, host = get_sys_host(module)

    host_name = module.params['host']
    if not host:
        module.fail_json(msg='Host {0} not found'.format(host_name))

    field_dict = get_port_fields(module, system, host)
    result = dict(
        changed=False,
        msg='Host {0} ports found'.format(host_name),
    )
    result = merge_two_dicts(result, field_dict)
    module.exit_json(**result)


def handle_present(module):
    """
    Handle present state. Fail if host is None.
    """
    system, host = get_sys_host(module)

    host_name = module.params['host']
    if not host:
        module.fail_json(msg='Host {0} not found'.format(host_name))

    changed = update_ports(module, system)
    if changed:
        msg = 'Mapping created for host {0}'.format(host.get_name())
    else:
        msg = 'No mapping changes were required for host {0}'.format(host.get_name())

    result = dict(
        changed=changed,
        msg=msg,
    )
    module.exit_json(**result)


def handle_absent(module):
    """
    Handle absent state. Fail if host is None.
    """
    system, host = get_sys_host(module)
    if not host:
        module.exit_json(changed=False, msg='Host {0} not found'.format(
            module.params['host']))

    changed = delete_ports(module, system)
    if changed:
        msg = 'Mapping removed from host {0}'.format(host.get_name())
    else:
        msg = 'No mapping changes were required. Mapping already removed from host {0}'.format(host.get_name())

    result = dict(
        changed=changed,
        msg=msg,
    )
    module.exit_json(**result)


def execute_state(module):
    """
    Handle states. Always logout.
    """
    state = module.params['state']
    try:
        if state == 'stat':
            handle_stat(module)
        elif state == 'present':
            handle_present(module)
        elif state == 'absent':
            handle_absent(module)
        else:
            module.fail_json(msg='Internal handler error. Invalid state: {0}'.format(state))
    finally:
        system = get_system(module)
        system.logout()


def check_options(module):
    pass


def main():
    """
    Gather auguments and manage mapping of vols to hosts.
    """
    argument_spec = infinibox_argument_spec()
    null_list = list()
    argument_spec.update(
        dict(
            host=dict(required=True),
            state=dict(default='present', choices=['stat', 'present', 'absent']),
            wwns=dict(type='list', default=list()),
            iqns=dict(type='list', default=list()),
        )
    )

    module = AnsibleModule(argument_spec, supports_check_mode=True)

    if not HAS_INFINISDK:
        module.fail_json(msg=missing_required_lib('infinisdk'))

    check_options(module)
    execute_state(module)


if __name__ == '__main__':
    main()