# Copyright (c) 2016 Dell Inc. or its subsidiaries.
# All Rights Reserved.
#
# Licensed 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.

from __future__ import division

import contextlib
from distutils import version
import functools
import json

from oslo_log import log as logging
from oslo_utils import fnmatch
from oslo_utils import units
import six

from cinder import coordination
from cinder import exception
from cinder.i18n import _
from cinder.objects import fields
from cinder.volume import group_types
from cinder.volume import volume_types
from cinder.volume import volume_utils
from cinder.zonemanager import utils as zm_utils

LOG = logging.getLogger(__name__)
BACKEND_QOS_CONSUMERS = frozenset(['back-end', 'both'])
QOS_MAX_IOPS = 'maxIOPS'
QOS_MAX_BWS = 'maxBWS'


def dump_provider_location(location_dict):
    sorted_keys = sorted(location_dict.keys())
    return '|'.join('%(k)s^%(v)s' % {'k': k, 'v': location_dict[k]}
                    for k in sorted_keys)


def build_provider_location(system, lun_type, lun_id, version):
    """Builds provider_location for volume or snapshot.

    :param system: Unity serial number
    :param lun_id: LUN ID in Unity
    :param lun_type: 'lun'
    :param version: driver version
    """
    location_dict = {'system': system,
                     'type': lun_type,
                     'id': six.text_type(lun_id),
                     'version': version}
    return dump_provider_location(location_dict)


def extract_provider_location(provider_location, key):
    """Extracts value of the specified field from provider_location string.

    :param provider_location: provider_location string
    :param key: field name of the value that to be extracted
    :return: value of the specified field if it exists, otherwise,
             None is returned
    """
    if provider_location:
        for kvp in provider_location.split('|'):
            fields = kvp.split('^')
            if len(fields) == 2 and fields[0] == key:
                return fields[1]
        else:
            LOG.warning('"%(key)s" is not found in provider '
                        'location "%(location)s."',
                        {'key': key, 'location': provider_location})
    else:
        LOG.warning('Empty provider location received.')


def byte_to_gib(byte):
    return byte / units.Gi


def byte_to_mib(byte):
    return byte / units.Mi


def gib_to_mib(gib):
    return gib * units.Ki


def validate_pool_names(conf_pools, array_pools):
    if not conf_pools:
        LOG.debug('No storage pools are specified. This host will manage '
                  'all the pools on the Unity system.')
        return array_pools

    conf_pools = set(map(lambda i: i.strip(), conf_pools))
    array_pools = set(map(lambda i: i.strip(), array_pools))
    existed = conf_pools & array_pools

    if not existed:
        msg = (_('No storage pools to be managed exist. Please check '
                 'your configuration. The available storage pools on the '
                 'system are %s.') % array_pools)
        raise exception.VolumeBackendAPIException(data=msg)

    return existed


def extract_iscsi_uids(connector):
    if 'initiator' not in connector:
        msg = _("Host %s doesn't have iSCSI initiator.") % connector['host']
        raise exception.VolumeBackendAPIException(data=msg)

    return [connector['initiator']]


def extract_fc_uids(connector):
    if 'wwnns' not in connector or 'wwpns' not in connector:
        msg = _("Host %s doesn't have FC initiators.") % connector['host']
        LOG.error(msg)
        raise exception.VolumeBackendAPIException(data=msg)

    wwnns = connector['wwnns']
    wwpns = connector['wwpns']
    wwns = [(node + port).upper() for node, port in zip(wwnns, wwpns)]

    def _to_wwn(wwn):
        # Format the wwn to include the colon
        # For example, convert 1122200000051E55E100 to
        # 11:22:20:00:00:05:1E:55:A1:00
        return ':'.join(wwn[i:i + 2] for i in range(0, len(wwn), 2))

    return list(map(_to_wwn, wwns))


def convert_ip_to_portal(ip):
    is_ipv6_without_brackets = ':' in ip and ip[-1] != ']'
    if is_ipv6_without_brackets:
        return '[%s]:3260' % ip
    return '%s:3260' % ip


def convert_to_itor_tgt_map(zone_mapping):
    """Function to process data from lookup service.

    :param zone_mapping: mapping is the data from the zone lookup service
         with below format

        {
             <San name>: {
                 'initiator_port_wwn_list':
                 ('200000051e55a100', '200000051e55a121'..)
                 'target_port_wwn_list':
                 ('100000051e55a100', '100000051e55a121'..)

             }

        }
    """
    target_wwns = []
    itor_tgt_map = {}
    for san_name in zone_mapping:
        one_map = zone_mapping[san_name]
        for target in one_map['target_port_wwn_list']:
            if target not in target_wwns:
                target_wwns.append(target)
        for initiator in one_map['initiator_port_wwn_list']:
            itor_tgt_map[initiator] = one_map['target_port_wwn_list']
    LOG.debug("target_wwns: %(tgt_wwns)s\n init_targ_map: %(itor_tgt_map)s",
              {'tgt_wwns': target_wwns,
               'itor_tgt_map': itor_tgt_map})
    return target_wwns, itor_tgt_map


def get_pool_name(volume):
    return volume_utils.extract_host(volume.host, 'pool')


def get_pool_name_from_host(host):
    return volume_utils.extract_host(host['host'], 'pool')


def get_backend_name_from_volume(volume):
    return volume_utils.extract_host(volume.host, 'backend')


def get_backend_name_from_host(host):
    return volume_utils.extract_host(host['host'], 'backend')


def get_extra_spec(volume, spec_key):
    spec_value = None
    type_id = volume.volume_type_id
    if type_id is not None:
        extra_specs = volume_types.get_volume_type_extra_specs(type_id)
        if spec_key in extra_specs:
            spec_value = extra_specs[spec_key]
    return spec_value


def group_is_cg(group):
    result = get_group_specs(group, 'consistent_group_snapshot_enabled')
    return result == '<is> True'


def get_group_specs(group, spec_key):
    spec_value = None
    if group.group_type_id:
        group_specs = group_types.get_group_type_specs(group.group_type_id)
        if spec_key in group_specs:
            spec_value = group_specs[spec_key]
    return spec_value


def ignore_exception(func, *args, **kwargs):
    try:
        func(*args, **kwargs)
    except Exception as ex:
        LOG.warning('Error occurred but ignored. Function: %(func_name)s, '
                    'args: %(args)s, kwargs: %(kwargs)s, '
                    'exception: %(ex)s.',
                    {'func_name': func, 'args': args,
                     'kwargs': kwargs, 'ex': ex})


@contextlib.contextmanager
def assure_cleanup(enter_func, exit_func, use_enter_return):
    """Assures the resource is cleaned up. Used as a context.

    :param enter_func: the function to execute when entering the context.
    :param exit_func: the function to execute when leaving the context.
    :param use_enter_return: the flag indicates whether to pass the return
                             value of enter_func in to the exit_func.
    """

    enter_return = None
    try:
        if isinstance(enter_func, functools.partial):
            enter_func_name = enter_func.func.__name__
        else:
            enter_func_name = enter_func.__name__
        LOG.debug(('Entering context. Function: %(func_name)s, '
                   'use_enter_return: %(use)s.'),
                  {'func_name': enter_func_name,
                   'use': use_enter_return})
        enter_return = enter_func()
        yield enter_return
    finally:
        if isinstance(exit_func, functools.partial):
            exit_func_name = exit_func.func.__name__
        else:
            exit_func_name = exit_func.__name__
        LOG.debug(('Exiting context. Function: %(func_name)s, '
                   'use_enter_return: %(use)s.'),
                  {'func_name': exit_func_name,
                   'use': use_enter_return})
        if enter_return is not None:
            if use_enter_return:
                ignore_exception(exit_func, enter_return)
            else:
                ignore_exception(exit_func)


def create_lookup_service():
    return zm_utils.create_lookup_service()


def get_backend_qos_specs(volume):
    type_id = volume.volume_type_id
    if type_id is None:
        return None

    qos_specs = volume_types.get_volume_type_qos_specs(type_id)
    if qos_specs is None:
        return None

    qos_specs = qos_specs['qos_specs']
    if qos_specs is None:
        return None

    consumer = qos_specs['consumer']
    # Front end QoS specs are handled by nova. We ignore them here.
    if consumer not in BACKEND_QOS_CONSUMERS:
        return None

    max_iops = qos_specs['specs'].get(QOS_MAX_IOPS)
    max_bws = qos_specs['specs'].get(QOS_MAX_BWS)
    if max_iops is None and max_bws is None:
        return None

    return {
        'id': qos_specs['id'],
        QOS_MAX_IOPS: max_iops,
        QOS_MAX_BWS: max_bws,
    }


def remove_empty(option, value_list):
    if value_list:
        value_list = list(filter(None, map(str.strip, value_list)))
        if not value_list:
            raise exception.InvalidConfigurationValue(option=option,
                                                      value=value_list)
        return value_list
    return None


def match_any(full, patterns):
    matched = list(
        filter(lambda x: any(fnmatch.fnmatchcase(x, p) for p in patterns),
               full))
    unmatched = list(
        filter(lambda x: not any(fnmatch.fnmatchcase(x, p) for p in patterns),
               full))
    unmatched_patterns = list(
        filter(lambda p: not any(fnmatch.fnmatchcase(x, p) for x in full),
               patterns))
    return matched, unmatched, unmatched_patterns


def is_before_4_1(ver):
    return version.LooseVersion(ver) < version.LooseVersion('4.1')


def lock_if(condition, lock_name):
    if condition:
        return coordination.synchronized(lock_name)
    else:
        return functools.partial


def append_capabilities(func):
    capabilities = {
        'thin_provisioning_support': True,
        'thick_provisioning_support': True,
        'consistent_group_snapshot_enabled': True,
        'fast_support': True,
        'consistent_group_replication_enabled': True
    }

    @six.wraps(func)
    def _inner(*args, **kwargs):
        output = func(*args, **kwargs)
        output.update(capabilities)
        return output

    return _inner


def is_multiattach_to_host(volume_attachment, host_name):
    # When multiattach is enabled, a volume could be attached to two or more
    # instances which are hosted on one nova host.
    # Because unity cannot recognize the volume is attached to two or more
    # instances, we should keep the volume attached to the nova host until
    # the volume is detached from the last instance.
    if not volume_attachment:
        return False

    attachment = [a for a in volume_attachment
                  if a.attach_status == fields.VolumeAttachStatus.ATTACHED and
                  a.attached_host == host_name]
    return len(attachment) > 1


def load_replication_data(rep_data_str):
    # rep_data_str is string dumped from a dict like:
    # {
    #     'default': 'rep_session_name_failed_over',
    #     'backend_id_1': 'rep_session_name_1',
    #     'backend_id_2': 'rep_session_name_2'
    # }
    return json.loads(rep_data_str)


def dump_replication_data(model_update, rep_data):
    # rep_data is a dict like:
    # {
    #     'backend_id_1': 'rep_session_name_1',
    #     'backend_id_2': 'rep_session_name_2'
    # }
    model_update['replication_driver_data'] = json.dumps(rep_data)
    return model_update


def enable_replication_status(model_update, rep_data):
    model_update['replication_status'] = fields.ReplicationStatus.ENABLED
    return dump_replication_data(model_update, rep_data)


def error_replication_status(model_update):
    # model_update is a dict like:
    # {
    #     'volume_id': volume.id,
    #     'updates': {
    #         'provider_id': new_provider_id,
    #         'provider_location': new_provider_location,
    #         'replication_status': fields.ReplicationStatus.FAILOVER_ERROR,
    #         ...
    #     }
    # }
    model_update['updates']['replication_status'] = (
        fields.ReplicationStatus.FAILOVER_ERROR
    )
    return model_update