"""
    SoftLayer.storage_utils
    ~~~~~~~~~~~~~~~
    Utility functions used by File and Block Storage Managers

    :license: MIT, see LICENSE for more details.
"""
from SoftLayer import exceptions
from SoftLayer import utils

# pylint: disable=too-many-lines


ENDURANCE_TIERS = {
    0.25: 100,
    2: 200,
    4: 300,
    10: 1000,
}


def populate_host_templates(hardware_ids=None,
                            virtual_guest_ids=None,
                            ip_address_ids=None,
                            subnet_ids=None):
    """Returns a populated array with the IDs provided

    :param hardware_ids: A List of SoftLayer_Hardware ids
    :param virtual_guest_ids: A List of SoftLayer_Virtual_Guest ids
    :param ip_address_ids: A List of SoftLayer_Network_Subnet_IpAddress ids
    :param subnet_ids: A List of SoftLayer_Network_Subnet ids
    :return: array of objects formatted for allowAccessFromHostList
    """
    host_templates = []
    if hardware_ids is not None:
        for hardware_id in hardware_ids:
            host_templates.append({
                'objectType': 'SoftLayer_Hardware',
                'id': hardware_id
            })

    if virtual_guest_ids is not None:
        for virtual_guest_id in virtual_guest_ids:
            host_templates.append({
                'objectType': 'SoftLayer_Virtual_Guest',
                'id': virtual_guest_id
            })

    if ip_address_ids is not None:
        for ip_address_id in ip_address_ids:
            host_templates.append({
                'objectType': 'SoftLayer_Network_Subnet_IpAddress',
                'id': ip_address_id
            })

    if subnet_ids is not None:
        for subnet_id in subnet_ids:
            host_templates.append({
                'objectType': 'SoftLayer_Network_Subnet',
                'id': subnet_id
            })
    return host_templates


def get_package(manager, category_code):
    """Returns a product package based on type of storage.

    :param manager: The storage manager which calls this function.
    :param category_code: Category code of product package.
    :return: Returns a packaged based on type of storage.
    """

    _filter = utils.NestedDict({})
    _filter['categories']['categoryCode'] = (
        utils.query_filter(category_code))
    _filter['statusCode'] = utils.query_filter('ACTIVE')

    packages = manager.client.call(
        'Product_Package', 'getAllObjects',
        filter=_filter.to_dict(),
        mask='id,name,items[prices[categories],attributes]'
    )
    if len(packages) == 0:
        raise ValueError('No packages were found for %s' % category_code)
    if len(packages) > 1:
        raise ValueError('More than one package was found for %s'
                         % category_code)

    return packages[0]


def get_location_id(manager, location):
    """Returns location id

    :param manager: The storage manager which calls this function.
    :param location: Datacenter short name
    :return: Returns location id
    """
    loc_svc = manager.client['Location_Datacenter']
    datacenters = loc_svc.getDatacenters(mask='mask[longName,id,name]')
    for datacenter in datacenters:
        if datacenter['name'] == location:
            location = datacenter['id']
            return location
    raise ValueError('Invalid datacenter name specified.')


def find_price_by_category(package, price_category):
    """Find the price in the given package that has the specified category

    :param package: The AsAService, Enterprise, or Performance product package
    :param price_category: The price category code to search for
    :return: Returns the price for the given category, or an error if not found
    """
    for item in package['items']:
        price_id = _find_price_id(item['prices'], price_category)
        if price_id:
            return price_id

    raise ValueError("Could not find price with the category, %s" % price_category)


def find_ent_space_price(package, category, size, tier_level):
    """Find the space price for the given category, size, and tier

    :param package: The Enterprise (Endurance) product package
    :param category: The category of space (endurance, replication, snapshot)
    :param size: The size for which a price is desired
    :param tier_level: The endurance tier for which a price is desired
    :return: Returns the matching price, or an error if not found
    """
    if category == 'snapshot':
        category_code = 'storage_snapshot_space'
    elif category == 'replication':
        category_code = 'performance_storage_replication'
    else:  # category == 'endurance'
        category_code = 'performance_storage_space'

    level = ENDURANCE_TIERS.get(tier_level)

    for item in package['items']:
        if int(item['capacity']) != size:
            continue
        price_id = _find_price_id(item['prices'], category_code, 'STORAGE_TIER_LEVEL', level)
        if price_id:
            return price_id

    raise ValueError("Could not find price for %s storage space" % category)


def find_ent_endurance_tier_price(package, tier_level):
    """Find the price in the given package with the specified tier level

    :param package: The Enterprise (Endurance) product package
    :param tier_level: The endurance tier for which a price is desired
    :return: Returns the price for the given tier, or an error if not found
    """
    for item in package['items']:
        for attribute in item.get('attributes', []):
            if int(attribute['value']) == ENDURANCE_TIERS.get(tier_level):
                break
        else:
            continue

        price_id = _find_price_id(item['prices'], 'storage_tier_level')
        if price_id:
            return price_id

    raise ValueError("Could not find price for endurance tier level")


def find_endurance_tier_iops_per_gb(volume):
    """Find the tier for the given endurance volume (IOPS per GB)

    :param volume: The volume for which the tier level is desired
    :return: Returns a float value indicating the IOPS per GB for the volume
    """
    tier = volume['storageTierLevel']
    iops_per_gb = 0.25

    if tier == "LOW_INTENSITY_TIER":
        iops_per_gb = 0.25
    elif tier == "READHEAVY_TIER":
        iops_per_gb = 2
    elif tier == "WRITEHEAVY_TIER":
        iops_per_gb = 4
    elif tier == "10_IOPS_PER_GB":
        iops_per_gb = 10
    else:
        raise ValueError("Could not find tier IOPS per GB for this volume")

    return iops_per_gb


def find_perf_space_price(package, size):
    """Find the price in the given package with the specified size

    :param package: The Performance product package
    :param size: The storage space size for which a price is desired
    :return: Returns the price for the given size, or an error if not found
    """
    for item in package['items']:
        if int(item['capacity']) != size:
            continue

        price_id = _find_price_id(item['prices'], 'performance_storage_space')
        if price_id:
            return price_id

    raise ValueError("Could not find performance space price for this volume")


def find_perf_iops_price(package, size, iops):
    """Find the price in the given package with the specified size and iops

    :param package: The Performance product package
    :param size: The size of storage space for which an IOPS price is desired
    :param iops: The number of IOPS for which a price is desired
    :return: Returns the price for the size and IOPS, or an error if not found
    """
    for item in package['items']:
        if int(item['capacity']) != int(iops):
            continue

        price_id = _find_price_id(item['prices'], 'performance_storage_iops', 'STORAGE_SPACE', size)
        if price_id:
            return price_id

    raise ValueError("Could not find price for iops for the given volume")


def find_saas_endurance_space_price(package, size, tier_level):
    """Find the SaaS endurance storage space price for the size and tier

    :param package: The Storage As A Service product package
    :param size: The volume size for which a price is desired
    :param tier_level: The endurance tier for which a price is desired
    :return: Returns the price for the size and tier, or an error if not found
    """
    if tier_level != 0.25:
        tier_level = int(tier_level)
    key_name = 'STORAGE_SPACE_FOR_{0}_IOPS_PER_GB'.format(tier_level)
    key_name = key_name.replace(".", "_")
    for item in package['items']:
        if key_name not in item['keyName']:
            continue

        if 'capacityMinimum' not in item or 'capacityMaximum' not in item:
            continue

        capacity_minimum = int(item['capacityMinimum'])
        capacity_maximum = int(item['capacityMaximum'])
        if size < capacity_minimum or size > capacity_maximum:
            continue

        price_id = _find_price_id(item['prices'], 'performance_storage_space')
        if price_id:
            return price_id

    raise ValueError("Could not find price for endurance storage space")


def find_saas_endurance_tier_price(package, tier_level):
    """Find the SaaS storage tier level price for the specified tier level

    :param package: The Storage As A Service product package
    :param tier_level: The endurance tier for which a price is desired
    :return: Returns the price for the given tier, or an error if not found
    """
    target_capacity = ENDURANCE_TIERS.get(tier_level)
    for item in package['items']:
        if 'itemCategory' not in item\
                or 'categoryCode' not in item['itemCategory']\
                or item['itemCategory']['categoryCode']\
                != 'storage_tier_level':
            continue

        if int(item['capacity']) != target_capacity:
            continue

        price_id = _find_price_id(item['prices'], 'storage_tier_level')
        if price_id:
            return price_id

    raise ValueError("Could not find price for endurance tier level")


def find_saas_perform_space_price(package, size):
    """Find the SaaS performance storage space price for the given size

    :param package: The Storage As A Service product package
    :param size: The volume size for which a price is desired
    :return: Returns the price for the size and tier, or an error if not found
    """
    for item in package['items']:
        if 'itemCategory' not in item\
                or 'categoryCode' not in item['itemCategory']\
                or item['itemCategory']['categoryCode']\
                != 'performance_storage_space':
            continue

        if 'capacityMinimum' not in item or 'capacityMaximum' not in item:
            continue

        capacity_minimum = int(item['capacityMinimum'])
        capacity_maximum = int(item['capacityMaximum'])
        if size < capacity_minimum or size > capacity_maximum:
            continue

        key_name = '{0}_{1}_GBS'.format(capacity_minimum, capacity_maximum)
        if item['keyName'] != key_name:
            continue
        price_id = _find_price_id(item['prices'], 'performance_storage_space')
        if price_id:
            return price_id

    raise ValueError("Could not find price for performance storage space")


def find_saas_perform_iops_price(package, size, iops):
    """Find the SaaS IOPS price for the specified size and iops

    :param package: The Storage As A Service product package
    :param size: The volume size for which a price is desired
    :param iops: The number of IOPS for which a price is desired
    :return: Returns the price for the size and IOPS, or an error if not found
    """
    for item in package['items']:
        if 'itemCategory' not in item\
                or 'categoryCode' not in item['itemCategory']\
                or item['itemCategory']['categoryCode']\
                != 'performance_storage_iops':
            continue

        if 'capacityMinimum' not in item or 'capacityMaximum' not in item:
            continue

        capacity_minimum = int(item['capacityMinimum'])
        capacity_maximum = int(item['capacityMaximum'])
        if iops < capacity_minimum or iops > capacity_maximum:
            continue

        price_id = _find_price_id(item['prices'], 'performance_storage_iops', 'STORAGE_SPACE', size)
        if price_id:
            return price_id

    raise ValueError("Could not find price for iops for the given volume")


def find_saas_snapshot_space_price(package, size, tier=None, iops=None):
    """Find the price in the SaaS package for the desired snapshot space size

    :param package: The product package of the endurance storage type
    :param size: The snapshot space size for which a price is desired
    :param tier: The tier of the volume for which space is being ordered
    :param iops: The IOPS of the volume for which space is being ordered
    :return: Returns the price for the given size, or an error if not found
    """
    if tier is not None:
        target_value = ENDURANCE_TIERS.get(tier)
        target_restriction_type = 'STORAGE_TIER_LEVEL'
    else:
        target_value = iops
        target_restriction_type = 'IOPS'

    for item in package['items']:
        if int(item['capacity']) != size:
            continue

        price_id = _find_price_id(item['prices'], 'storage_snapshot_space', target_restriction_type, target_value)
        if price_id:
            return price_id

    raise ValueError("Could not find price for snapshot space")


def find_saas_replication_price(package, tier=None, iops=None):
    """Find the price in the given package for the desired replicant volume

    :param package: The product package of the endurance storage type
    :param tier: The tier of the primary storage volume
    :param iops: The IOPS of the primary storage volume
    :return: Returns the replication price, or an error if not found
    """
    if tier is not None:
        target_value = ENDURANCE_TIERS.get(tier)
        target_item_keyname = 'REPLICATION_FOR_TIERBASED_PERFORMANCE'
        target_restriction_type = 'STORAGE_TIER_LEVEL'
    else:
        target_value = iops
        target_item_keyname = 'REPLICATION_FOR_IOPSBASED_PERFORMANCE'
        target_restriction_type = 'IOPS'

    for item in package['items']:
        if item['keyName'] != target_item_keyname:
            continue

        price_id = _find_price_id(
            item['prices'],
            'performance_storage_replication',
            target_restriction_type,
            target_value
        )
        if price_id:
            return price_id

    raise ValueError("Could not find price for replicant volume")


def find_snapshot_schedule_id(volume, snapshot_schedule_keyname):
    """Find the snapshot schedule ID for the given volume and keyname

    :param volume: The volume for which the snapshot ID is desired
    :param snapshot_schedule_keyname: The keyname of the snapshot schedule
    :return: Returns an int value indicating the volume's snapshot schedule ID
    """
    for schedule in volume['schedules']:
        if 'type' in schedule and 'keyname' in schedule['type']:
            if schedule['type']['keyname'] == snapshot_schedule_keyname:
                return schedule['id']

    raise ValueError("The given snapshot schedule ID was not found for "
                     "the given storage volume")


def prepare_snapshot_order_object(manager, volume, capacity, tier, upgrade):
    """Prepare the snapshot space order object for the placeOrder() method

    :param manager: The File or Block manager calling this function
    :param integer volume: The volume for which snapshot space is ordered
    :param integer capacity: The snapshot space size to order, in GB
    :param float tier: The tier level of the volume, in IOPS per GB (optional)
    :param boolean upgrade: Flag to indicate if this order is an upgrade
    :return: Returns the order object for the
             Product_Order service's placeOrder() method
    """
    # Ensure the storage volume has not been cancelled
    if 'billingItem' not in volume:
        raise exceptions.SoftLayerError(
            'This volume has been cancelled; unable to order snapshot space')

    # Determine and validate the storage volume's billing item category
    billing_item_category_code = volume['billingItem']['categoryCode']
    if billing_item_category_code == 'storage_as_a_service':
        order_type_is_saas = True
    elif billing_item_category_code == 'storage_service_enterprise':
        order_type_is_saas = False
    else:
        raise exceptions.SoftLayerError(
            "Snapshot space cannot be ordered for a primary volume with a "
            "billing item category code of '%s'" % billing_item_category_code)

    # Use the volume's billing item category code to get the product package
    package = get_package(manager, billing_item_category_code)

    # Find prices based on the volume's type and billing item category
    if order_type_is_saas:  # 'storage_as_a_service' package
        volume_storage_type = volume['storageType']['keyName']
        if 'ENDURANCE' in volume_storage_type:
            if tier is None:
                tier = find_endurance_tier_iops_per_gb(volume)
            prices = [find_saas_snapshot_space_price(
                package, capacity, tier=tier)]
        elif 'PERFORMANCE' in volume_storage_type:
            if not _staas_version_is_v2_or_above(volume):
                raise exceptions.SoftLayerError(
                    "Snapshot space cannot be ordered for this performance "
                    "volume since it does not support Encryption at Rest.")
            iops = int(volume['provisionedIops'])
            prices = [find_saas_snapshot_space_price(
                package, capacity, iops=iops)]
        else:
            raise exceptions.SoftLayerError(
                "Storage volume does not have a valid storage type "
                "(with an appropriate keyName to indicate the "
                "volume is a PERFORMANCE or an ENDURANCE volume)")
    else:  # 'storage_service_enterprise' package
        if tier is None:
            tier = find_endurance_tier_iops_per_gb(volume)
        prices = [find_ent_space_price(package, 'snapshot', capacity, tier)]

    # Currently, these types are valid for snapshot space orders, whether
    # the base volume's order container was Enterprise or AsAService
    if upgrade:
        complex_type = 'SoftLayer_Container_Product_Order_'\
                       'Network_Storage_Enterprise_SnapshotSpace_Upgrade'
    else:
        complex_type = 'SoftLayer_Container_Product_Order_'\
                       'Network_Storage_Enterprise_SnapshotSpace'

    # Determine if hourly billing should be used
    hourly_billing_flag = utils.lookup(volume, 'billingItem', 'hourlyFlag')
    if hourly_billing_flag is None:
        hourly_billing_flag = False

    # Build and return the order object
    snapshot_space_order = {
        'complexType': complex_type,
        'packageId': package['id'],
        'prices': prices,
        'quantity': 1,
        'location': volume['billingItem']['location']['id'],
        'volumeId': volume['id'],
        'useHourlyPricing': hourly_billing_flag
    }

    return snapshot_space_order


def prepare_volume_order_object(manager, storage_type, location, size,
                                iops, tier, snapshot_size, service_offering,
                                volume_type, hourly_billing_flag=False):
    """Prepare the order object which is submitted to the placeOrder() method

    :param manager: The File or Block manager calling this function
    :param storage_type: "performance" or "endurance"
    :param location: Requested datacenter location name for the ordered volume
    :param size: Desired size of the volume, in GB
    :param iops: Number of IOPs for a "Performance" volume order
    :param tier: Tier level to use for an "Endurance" volume order
    :param snapshot_size: The size of snapshot space for the volume (optional)
    :param service_offering: Requested offering package to use for the order
    :param volume_type: The type of the volume to order ('file' or 'block')
    :param hourly_billing_flag: Billing type, monthly (False) or hourly (True)
    :return: Returns the order object for the
             Product_Order service's placeOrder() method
    """
    # Ensure the volume storage type is valid
    if storage_type != 'performance' and storage_type != 'endurance':
        raise exceptions.SoftLayerError(
            "Volume storage type must be either performance or endurance")

    # Find the ID for the requested location
    try:
        location_id = get_location_id(manager, location)
    except ValueError as ex:
        message = "Invalid datacenter name specified. Please provide the lower case short name (e.g.: dal09)"
        raise exceptions.SoftLayerError(message) from ex

    # Determine the category code to use for the order (and product package)
    order_type_is_saas, order_category_code = _get_order_type_and_category(
        service_offering,
        storage_type,
        volume_type
    )

    # Get the product package for the given category code
    package = get_package(manager, order_category_code)

    # Based on the storage type and product package, build up the complex type
    # and array of price codes to include in the order object
    base_type_name = 'SoftLayer_Container_Product_Order_Network_'
    if order_type_is_saas:
        complex_type = base_type_name + 'Storage_AsAService'
        if storage_type == 'performance':
            prices = [
                find_price_by_category(package, order_category_code),
                find_price_by_category(package, 'storage_' + volume_type),
                find_saas_perform_space_price(package, size),
                find_saas_perform_iops_price(package, size, iops)
            ]
            if snapshot_size is not None:
                prices.append(find_saas_snapshot_space_price(
                    package, snapshot_size, iops=iops))
        else:  # storage_type == 'endurance'
            prices = [
                find_price_by_category(package, order_category_code),
                find_price_by_category(package, 'storage_' + volume_type),
                find_saas_endurance_space_price(package, size, tier),
                find_saas_endurance_tier_price(package, tier)
            ]
            if snapshot_size is not None:
                prices.append(find_saas_snapshot_space_price(
                    package, snapshot_size, tier=tier))
    else:  # offering package is enterprise or performance
        if storage_type == 'performance':
            if volume_type == 'block':
                complex_type = base_type_name + 'PerformanceStorage_Iscsi'
            else:
                complex_type = base_type_name + 'PerformanceStorage_Nfs'
            prices = [
                find_price_by_category(package, order_category_code),
                find_perf_space_price(package, size),
                find_perf_iops_price(package, size, iops),
            ]
        else:  # storage_type == 'endurance'
            complex_type = base_type_name + 'Storage_Enterprise'
            prices = [
                find_price_by_category(package, order_category_code),
                find_price_by_category(package, 'storage_' + volume_type),
                find_ent_space_price(package, 'endurance', size, tier),
                find_ent_endurance_tier_price(package, tier),
            ]
            if snapshot_size is not None:
                prices.append(find_ent_space_price(
                    package, 'snapshot', snapshot_size, tier))

    # Build and return the order object
    order = {
        'complexType': complex_type,
        'packageId': package['id'],
        'prices': prices,
        'quantity': 1,
        'location': location_id,
        'useHourlyPricing': hourly_billing_flag
    }

    if order_type_is_saas:
        order['volumeSize'] = size
        if storage_type == 'performance':
            order['iops'] = iops

    return order


def _get_order_type_and_category(service_offering, storage_type, volume_type):
    if service_offering == 'storage_as_a_service':
        order_type_is_saas = True
        order_category_code = 'storage_as_a_service'
    elif service_offering == 'enterprise':
        order_type_is_saas = False
        if storage_type == 'endurance':
            order_category_code = 'storage_service_enterprise'
        else:
            raise exceptions.SoftLayerError(
                "The requested offering package, '%s', is not available for "
                "the '%s' storage type." % (service_offering, storage_type))
    elif service_offering == 'performance':
        order_type_is_saas = False
        if storage_type == 'performance':
            if volume_type == 'block':
                order_category_code = 'performance_storage_iscsi'
            else:
                order_category_code = 'performance_storage_nfs'
        else:
            raise exceptions.SoftLayerError(
                "The requested offering package, '%s', is not available for "
                "the '%s' storage type." % (service_offering, storage_type))
    else:
        raise exceptions.SoftLayerError(
            "The requested service offering package is not valid. "
            "Please check the available options and try again.")

    return order_type_is_saas, order_category_code


def prepare_replicant_order_object(manager, snapshot_schedule, location,
                                   tier, volume, volume_type, iops):
    """Prepare the order object which is submitted to the placeOrder() method

    :param manager: The File or Block manager calling this function
    :param snapshot_schedule: The primary volume's snapshot
                              schedule to use for replication
    :param location: The location for the ordered replicant volume
    :param tier: The tier (IOPS per GB) of the primary volume
    :param volume: The primary volume as a SoftLayer_Network_Storage object
    :param volume_type: The type of the primary volume ('file' or 'block')
    :return: Returns the order object for the
             Product_Order service's placeOrder() method
    """
    # Ensure the primary volume and snapshot space are not set for cancellation
    if 'billingItem' not in volume\
            or volume['billingItem'].get('cancellationDate'):
        raise exceptions.SoftLayerError(
            'This volume is set for cancellation; '
            'unable to order replicant volume')

    for child in volume['billingItem']['activeChildren']:
        if child['categoryCode'] == 'storage_snapshot_space'\
                and child.get('cancellationDate'):
            raise exceptions.SoftLayerError(
                'The snapshot space for this volume is set for '
                'cancellation; unable to order replicant volume')

    # Find the ID for the requested location
    try:
        location_id = get_location_id(manager, location)
    except ValueError as ex:
        message = "Invalid datacenter name specified. Please provide the lower case short name (e.g.: dal09)"
        raise exceptions.SoftLayerError(message) from ex

    # Get sizes and properties needed for the order
    volume_size = int(volume['capacityGb'])

    billing_item_category_code = volume['billingItem']['categoryCode']
    if billing_item_category_code == 'storage_as_a_service':
        order_type_is_saas = True
    elif billing_item_category_code == 'storage_service_enterprise':
        order_type_is_saas = False
    else:
        raise exceptions.SoftLayerError(
            "A replicant volume cannot be ordered for a primary volume with a "
            "billing item category code of '%s'" % billing_item_category_code)

    if 'snapshotCapacityGb' in volume:
        snapshot_size = int(volume['snapshotCapacityGb'])
    else:
        raise exceptions.SoftLayerError(
            "Snapshot capacity not found for the given primary volume")

    snapshot_schedule_id = find_snapshot_schedule_id(
        volume,
        'SNAPSHOT_' + snapshot_schedule
    )

    # Use the volume's billing item category code to get the product package
    package = get_package(manager, billing_item_category_code)

    # Find prices based on the primary volume's type and billing item category
    if order_type_is_saas:  # 'storage_as_a_service' package
        complex_type = 'SoftLayer_Container_Product_Order_'\
                       'Network_Storage_AsAService'
        volume_storage_type = volume['storageType']['keyName']
        if 'ENDURANCE' in volume_storage_type:
            volume_is_performance = False
            if tier is None:
                tier = find_endurance_tier_iops_per_gb(volume)
            prices = [
                find_price_by_category(package, billing_item_category_code),
                find_price_by_category(package, 'storage_' + volume_type),
                find_saas_endurance_space_price(package, volume_size, tier),
                find_saas_endurance_tier_price(package, tier),
                find_saas_snapshot_space_price(
                    package, snapshot_size, tier=tier),
                find_saas_replication_price(package, tier=tier)
            ]
        elif 'PERFORMANCE' in volume_storage_type:
            if not _staas_version_is_v2_or_above(volume):
                raise exceptions.SoftLayerError(
                    "A replica volume cannot be ordered for this performance "
                    "volume since it does not support Encryption at Rest.")
            volume_is_performance = True

            prices = [
                find_price_by_category(package, billing_item_category_code),
                find_price_by_category(package, 'storage_' + volume_type),
                find_saas_perform_space_price(package, volume_size),
                find_saas_perform_iops_price(package, volume_size, iops),
                find_saas_snapshot_space_price(
                    package, snapshot_size, iops=iops),
                find_saas_replication_price(package, iops=iops)
            ]
        else:
            raise exceptions.SoftLayerError(
                "Storage volume does not have a valid storage type "
                "(with an appropriate keyName to indicate the "
                "volume is a PERFORMANCE or an ENDURANCE volume)")
    else:  # 'storage_service_enterprise' package
        complex_type = 'SoftLayer_Container_Product_Order_'\
                       'Network_Storage_Enterprise'
        volume_is_performance = False
        if tier is None:
            tier = find_endurance_tier_iops_per_gb(volume)
        prices = [
            find_price_by_category(package, billing_item_category_code),
            find_price_by_category(package, 'storage_' + volume_type),
            find_ent_space_price(package, 'endurance', volume_size, tier),
            find_ent_endurance_tier_price(package, tier),
            find_ent_space_price(package, 'snapshot', snapshot_size, tier),
            find_ent_space_price(package, 'replication', volume_size, tier)
        ]

    # Determine if hourly billing should be used
    hourly_billing_flag = utils.lookup(volume, 'billingItem', 'hourlyFlag')
    if hourly_billing_flag is None:
        hourly_billing_flag = False

    # Build and return the order object
    replicant_order = {
        'complexType': complex_type,
        'packageId': package['id'],
        'prices': prices,
        'quantity': 1,
        'location': location_id,
        'originVolumeId': volume['id'],
        'originVolumeScheduleId': snapshot_schedule_id,
        'useHourlyPricing': hourly_billing_flag
    }

    if order_type_is_saas:
        replicant_order['volumeSize'] = volume_size
        if volume_is_performance:
            replicant_order['iops'] = iops

    return replicant_order


def prepare_duplicate_order_object(manager, origin_volume, iops, tier,
                                   duplicate_size, duplicate_snapshot_size,
                                   volume_type, hourly_billing_flag=False,
                                   dependent_duplicate=False):
    """Prepare the duplicate order to submit to SoftLayer_Product::placeOrder()

    :param manager: The File or Block manager calling this function
    :param origin_volume: The origin volume which is being duplicated
    :param iops: The IOPS for the duplicate volume (performance)
    :param tier: The tier level for the duplicate volume (endurance)
    :param duplicate_size: The requested size for the duplicate volume
    :param duplicate_snapshot_size: The size for the duplicate snapshot space
    :param volume_type: The type of the origin volume ('file' or 'block')
    :param hourly_billing_flag: Billing type, monthly (False) or hourly (True)
    :param dependent_duplicate: Duplicate type, normal (False) or dependent
        duplicate (True)
    :return: Returns the order object to be passed to the
             placeOrder() method of the Product_Order service
    """

    # Verify that the origin volume has not been cancelled
    if 'billingItem' not in origin_volume:
        raise exceptions.SoftLayerError(
            "The origin volume has been cancelled; "
            "unable to order duplicate volume")

    # Verify that the origin volume has snapshot space (needed for duplication)
    if isinstance(utils.lookup(origin_volume, 'snapshotCapacityGb'), str):
        origin_snapshot_size = int(origin_volume['snapshotCapacityGb'])
    else:
        raise exceptions.SoftLayerError(
            "Snapshot space not found for the origin volume. "
            "Origin snapshot space is needed for duplication.")

    # Obtain the datacenter location ID for the duplicate
    if isinstance(utils.lookup(origin_volume, 'billingItem',
                               'location', 'id'), int):
        location_id = origin_volume['billingItem']['location']['id']
    else:
        raise exceptions.SoftLayerError(
            "Cannot find origin volume's location")

    # Ensure the origin volume is STaaS v2 or higher
    # and supports Encryption at Rest
    if not _staas_version_is_v2_or_above(origin_volume):
        raise exceptions.SoftLayerError(
            "This volume cannot be duplicated since it "
            "does not support Encryption at Rest.")

    # If no specific snapshot space was requested for the duplicate,
    # use the origin snapshot space size
    if duplicate_snapshot_size is None:
        duplicate_snapshot_size = origin_snapshot_size

    # Use the origin volume size if no size was specified for the duplicate
    if duplicate_size is None:
        duplicate_size = origin_volume['capacityGb']

    # Get the appropriate package for the order
    # ('storage_as_a_service' is currently used for duplicate volumes)
    package = get_package(manager, 'storage_as_a_service')

    # Determine the IOPS or tier level for the duplicate volume, along with
    # the type and prices for the order
    origin_storage_type = origin_volume['storageType']['keyName']
    if 'PERFORMANCE' in origin_storage_type:
        volume_is_performance = True
        if iops is None:
            iops = int(origin_volume.get('provisionedIops', 0))
            if iops <= 0:
                raise exceptions.SoftLayerError("Cannot find origin volume's provisioned IOPS")
        # Set up the price array for the order
        prices = [
            find_price_by_category(package, 'storage_as_a_service'),
            find_price_by_category(package, 'storage_' + volume_type),
            find_saas_perform_space_price(package, duplicate_size),
            find_saas_perform_iops_price(package, duplicate_size, iops),
        ]
        # Add the price code for snapshot space as well, unless 0 GB was given
        if duplicate_snapshot_size > 0:
            prices.append(find_saas_snapshot_space_price(
                package, duplicate_snapshot_size, iops=iops))

    elif 'ENDURANCE' in origin_storage_type:
        volume_is_performance = False
        if tier is None:
            tier = find_endurance_tier_iops_per_gb(origin_volume)
        # Set up the price array for the order
        prices = [
            find_price_by_category(package, 'storage_as_a_service'),
            find_price_by_category(package, 'storage_' + volume_type),
            find_saas_endurance_space_price(package, duplicate_size, tier),
            find_saas_endurance_tier_price(package, tier),
        ]
        # Add the price code for snapshot space as well, unless 0 GB was given
        if duplicate_snapshot_size > 0:
            prices.append(find_saas_snapshot_space_price(
                package, duplicate_snapshot_size, tier=tier))

    else:
        raise exceptions.SoftLayerError(
            "Origin volume does not have a valid storage type "
            "(with an appropriate keyName to indicate the "
            "volume is a PERFORMANCE or an ENDURANCE volume)")

    duplicate_order = {
        'complexType': 'SoftLayer_Container_Product_Order_'
                       'Network_Storage_AsAService',
        'packageId': package['id'],
        'prices': prices,
        'volumeSize': duplicate_size,
        'quantity': 1,
        'location': location_id,
        'duplicateOriginVolumeId': origin_volume['id'],
        'useHourlyPricing': hourly_billing_flag
    }

    if volume_is_performance:
        duplicate_order['iops'] = iops

    if dependent_duplicate:
        duplicate_order['isDependentDuplicateFlag'] = 1

    return duplicate_order


def prepare_modify_order_object(manager, volume, new_iops, new_tier, new_size):
    """Prepare the modification order to submit to SoftLayer_Product::placeOrder()

    :param manager: The File or Block manager calling this function
    :param volume: The volume which is being modified
    :param new_iops: The new IOPS for the volume (performance)
    :param new_tier: The new tier level for the volume (endurance)
    :param new_size: The requested new size for the volume
    :return: Returns the order object to be passed to the placeOrder() method of the Product_Order service
    """

    # Verify that the origin volume has not been cancelled
    if 'billingItem' not in volume:
        raise exceptions.SoftLayerError("The volume has been cancelled; unable to modify volume.")

    # Ensure the origin volume is STaaS v2 or higher and supports Encryption at Rest
    if not _staas_version_is_v2_or_above(volume):
        raise exceptions.SoftLayerError("This volume cannot be modified since it does not support Encryption at Rest.")

    # Get the appropriate package for the order ('storage_as_a_service' is currently used for modifying volumes)
    package = get_package(manager, 'storage_as_a_service')

    # Based on volume storage type, ensure at least one volume property is being modified,
    # use current values if some are not specified, and lookup price codes for the order
    volume_storage_type = volume['storageType']['keyName']
    if 'PERFORMANCE' in volume_storage_type:
        volume_is_performance = True
        if new_size is None and new_iops is None:
            raise exceptions.SoftLayerError("A size or IOPS value must be given to modify this performance volume.")

        if new_size is None:
            new_size = volume['capacityGb']
        elif new_iops is None:
            new_iops = int(volume.get('provisionedIops', 0))
            if new_iops <= 0:
                raise exceptions.SoftLayerError("Cannot find volume's provisioned IOPS.")

        # Set up the prices array for the order
        prices = [
            find_price_by_category(package, 'storage_as_a_service'),
            find_saas_perform_space_price(package, new_size),
            find_saas_perform_iops_price(package, new_size, new_iops),
        ]

    elif 'ENDURANCE' in volume_storage_type:
        volume_is_performance = False
        if new_size is None and new_tier is None:
            raise exceptions.SoftLayerError("A size or tier value must be given to modify this endurance volume.")

        if new_size is None:
            new_size = volume['capacityGb']
        elif new_tier is None:
            new_tier = find_endurance_tier_iops_per_gb(volume)

        # Set up the prices array for the order
        prices = [
            find_price_by_category(package, 'storage_as_a_service'),
            find_saas_endurance_space_price(package, new_size, new_tier),
            find_saas_endurance_tier_price(package, new_tier),
        ]

    else:
        raise exceptions.SoftLayerError("Volume does not have a valid storage type (with an appropriate "
                                        "keyName to indicate the volume is a PERFORMANCE or an ENDURANCE volume).")

    modify_order = {
        'complexType': 'SoftLayer_Container_Product_Order_Network_Storage_AsAService_Upgrade',
        'packageId': package['id'],
        'prices': prices,
        'volume': {'id': volume['id']},
        'volumeSize': new_size
    }

    if volume_is_performance:
        modify_order['iops'] = new_iops

    return modify_order


def block_or_file(storage_type_keyname):
    """returns either 'block' or 'file'

    :param storage_type_keyname: the Network_Storage['storageType']['keyName']
    :returns: 'block' or 'file'
    """
    return 'block' if 'BLOCK_STORAGE' in storage_type_keyname else 'file'


def _has_category(categories, category_code):
    return any(
        True
        for category
        in categories
        if category['categoryCode'] == category_code
    )


def _staas_version_is_v2_or_above(volume):
    return int(volume['staasVersion']) > 1 and volume['hasEncryptionAtRest']


def _find_price_id(prices, category, restriction_type=None, restriction_value=None):
    for price in prices:
        # Only collect prices from valid location groups.
        if price['locationGroupId']:
            continue

        if restriction_type is not None and restriction_value is not None:
            if restriction_type != price['capacityRestrictionType']\
                    or restriction_value < int(price['capacityRestrictionMinimum'])\
                    or restriction_value > int(price['capacityRestrictionMaximum']):
                continue

        if not _has_category(price['categories'], category):
            continue

        return {'id': price['id']}
