#!/usr/bin/python

# (c) 2016, NetApp, Inc
# 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": ["deprecated"],
                    "supported_by": "community"}

DOCUMENTATION = """
---
module: netapp_e_storagepool
short_description: NetApp E-Series manage volume groups and disk pools
description: Create or remove volume groups and disk pools for NetApp E-series storage arrays.
version_added: '2.2'
author:
  - Kevin Hulquest (@hulquest)
  - Nathan Swartz (@ndswartz)
extends_documentation_fragment:
  - netapp_eseries.santricity.santricity.netapp.eseries
options:
  state:
    description:
      - Whether the specified storage pool should exist or not.
      - Note that removing a storage pool currently requires the removal of all defined volumes first.
    required: true
    type: str
    choices: ["present", "absent"]
  name:
    description:
      - The name of the storage pool to manage
    type: str
    required: true
  criteria_drive_count:
    description:
      - The number of disks to use for building the storage pool.
      - When I(state=="present") then I(criteria_drive_count) or I(criteria_min_usable_capacity) must be specified.
      - The pool will be expanded if this number exceeds the number of disks already in place (See expansion note below)
    required: false
    type: int
  criteria_min_usable_capacity:
    description:
      - The minimum size of the storage pool (in size_unit).
      - When I(state=="present") then I(criteria_drive_count) or I(criteria_min_usable_capacity) must be specified.
      - The pool will be expanded if this value exceeds its current size. (See expansion note below)
    required: false
    type: float
  criteria_drive_type:
    description:
      - The type of disk (hdd or ssd) to use when searching for candidates to use.
      - When not specified each drive type will be evaluated until successful drive candidates are found starting with
        the most prevalent drive type.
    required: false
    type: str
    choices: ["hdd","ssd"]
  criteria_size_unit:
    description:
      - The unit used to interpret size parameters
    choices: ["bytes", "b", "kb", "mb", "gb", "tb", "pb", "eb", "zb", "yb"]
    type: str
    default: "gb"
  criteria_drive_min_size:
    description:
      - The minimum individual drive size (in size_unit) to consider when choosing drives for the storage pool.
    type: float
  criteria_drive_interface_type:
    description:
      - The interface type to use when selecting drives for the storage pool
      - If not provided then all interface types will be considered.
    choices: ["sas", "sas4k", "fibre", "fibre520b", "scsi", "sata", "pata"]
    type: str
    required: false
  criteria_drive_require_da:
    description:
      - Ensures the storage pool will be created with only data assurance (DA) capable drives.
      - Only available for new storage pools; existing storage pools cannot be converted.
    default: false
    type: bool
    version_added: '2.9'
  criteria_drive_require_fde:
    description:
     - Whether full disk encryption ability is required for drives to be added to the storage pool
    default: false
    type: bool
  raid_level:
    description:
      - The RAID level of the storage pool to be created.
      - Required only when I(state=="present").
      - When I(raid_level=="raidDiskPool") then I(criteria_drive_count >= 10 or criteria_drive_count >= 11) is required
        depending on the storage array specifications.
      - When I(raid_level=="raid0") then I(1<=criteria_drive_count) is required.
      - When I(raid_level=="raid1") then I(2<=criteria_drive_count) is required.
      - When I(raid_level=="raid3") then I(3<=criteria_drive_count<=30) is required.
      - When I(raid_level=="raid5") then I(3<=criteria_drive_count<=30) is required.
      - When I(raid_level=="raid6") then I(5<=criteria_drive_count<=30) is required.
      - Note that raidAll will be treated as raidDiskPool and raid3 as raid5.
    required: false
    choices: ["raidAll", "raid0", "raid1", "raid3", "raid5", "raid6", "raidDiskPool"]
    type: str
    default: "raidDiskPool"
  secure_pool:
    description:
      - Enables security at rest feature on the storage pool.
      - Will only work if all drives in the pool are security capable (FDE, FIPS, or mix)
      - Warning, once security is enabled it is impossible to disable without erasing the drives.
    required: false
    type: bool
  reserve_drive_count:
    description:
      - Set the number of drives reserved by the storage pool for reconstruction operations.
      - Only valid on raid disk pools.
    type: int
    required: false
  remove_volumes:
    description:
    - Prior to removing a storage pool, delete all volumes in the pool.
    default: true
    type: bool
  erase_secured_drives:
    description:
      - If I(state=="absent") then all storage pool drives will be erase
      - If I(state=="present") then delete all available storage array drives that have security enabled.
    default: true
    type: bool
notes:
  - The expansion operations are non-blocking due to the time consuming nature of expanding volume groups
  - Traditional volume groups (raid0, raid1, raid5, raid6) are performed in steps dictated by the storage array. Each
    required step will be attempted until the request fails which is likely because of the required expansion time.
  - raidUnsupported will be treated as raid0, raidAll as raidDiskPool and raid3 as raid5.
  - Tray loss protection and drawer loss protection will be chosen if at all possible.
"""
EXAMPLES = """
- name: No disk groups
  netapp_e_storagepool:
    ssid: "{{ ssid }}"
    name: "{{ item }}"
    state: absent
    api_url: "{{ netapp_api_url }}"
    api_username: "{{ netapp_api_username }}"
    api_password: "{{ netapp_api_password }}"
    validate_certs: "{{ netapp_api_validate_certs }}"
"""
RETURN = """
msg:
    description: Success message
    returned: success
    type: str
    sample: Json facts for the pool that was created.
"""
import functools
from itertools import groupby
from time import sleep
from pprint import pformat
from ansible_collections.netapp_eseries.santricity.plugins.module_utils.netapp import NetAppESeriesModule
from ansible.module_utils._text import to_native


def get_most_common_elements(iterator):
    """Returns a generator containing a descending list of most common elements."""
    if not isinstance(iterator, list):
        raise TypeError("iterator must be a list.")

    grouped = [(key, len(list(group))) for key, group in groupby(sorted(iterator))]
    return sorted(grouped, key=lambda x: x[1], reverse=True)


def memoize(func):
    """Generic memoizer for any function with any number of arguments including zero."""

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        class MemoizeFuncArgs(dict):
            def __missing__(self, _key):
                self[_key] = func(*args, **kwargs)
                return self[_key]

        key = str((args, kwargs)) if args and kwargs else "no_argument_response"
        return MemoizeFuncArgs().__getitem__(key)

    return wrapper


class NetAppESeriesStoragePool(NetAppESeriesModule):
    EXPANSION_TIMEOUT_SEC = 10
    DEFAULT_DISK_POOL_MINIMUM_DISK_COUNT = 11

    def __init__(self):
        version = "02.00.0000.0000"
        ansible_options = dict(
            state=dict(required=True, choices=["present", "absent"], type="str"),
            name=dict(required=True, type="str"),
            criteria_size_unit=dict(choices=["bytes", "b", "kb", "mb", "gb", "tb", "pb", "eb", "zb", "yb"],
                                    default="gb", type="str"),
            criteria_drive_count=dict(type="int"),
            criteria_drive_interface_type=dict(choices=["sas", "sas4k", "fibre", "fibre520b", "scsi", "sata", "pata"],
                                               type="str"),
            criteria_drive_type=dict(choices=["ssd", "hdd"], type="str", required=False),
            criteria_drive_min_size=dict(type="float"),
            criteria_drive_require_da=dict(type="bool", required=False),
            criteria_drive_require_fde=dict(type="bool", required=False),
            criteria_min_usable_capacity=dict(type="float"),
            raid_level=dict(choices=["raidAll", "raid0", "raid1", "raid3", "raid5", "raid6", "raidDiskPool"],
                            default="raidDiskPool"),
            erase_secured_drives=dict(type="bool", default=True),
            secure_pool=dict(type="bool", default=False),
            reserve_drive_count=dict(type="int"),
            remove_volumes=dict(type="bool", default=True))

        required_if = [["state", "present", ["raid_level"]]]
        super(NetAppESeriesStoragePool, self).__init__(ansible_options=ansible_options,
                                                       web_services_version=version,
                                                       supports_check_mode=True,
                                                       required_if=required_if)

        args = self.module.params
        self.state = args["state"]
        self.ssid = args["ssid"]
        self.name = args["name"]
        self.criteria_drive_count = args["criteria_drive_count"]
        self.criteria_min_usable_capacity = args["criteria_min_usable_capacity"]
        self.criteria_size_unit = args["criteria_size_unit"]
        self.criteria_drive_min_size = args["criteria_drive_min_size"]
        self.criteria_drive_type = args["criteria_drive_type"]
        self.criteria_drive_interface_type = args["criteria_drive_interface_type"]
        self.criteria_drive_require_fde = args["criteria_drive_require_fde"]
        self.criteria_drive_require_da = args["criteria_drive_require_da"]
        self.raid_level = args["raid_level"]
        self.erase_secured_drives = args["erase_secured_drives"]
        self.secure_pool = args["secure_pool"]
        self.reserve_drive_count = args["reserve_drive_count"]
        self.remove_volumes = args["remove_volumes"]
        self.pool_detail = None

        # Change all sizes to be measured in bytes
        if self.criteria_min_usable_capacity:
            self.criteria_min_usable_capacity = int(self.criteria_min_usable_capacity *
                                                    self.SIZE_UNIT_MAP[self.criteria_size_unit])
        if self.criteria_drive_min_size:
            self.criteria_drive_min_size = int(self.criteria_drive_min_size *
                                               self.SIZE_UNIT_MAP[self.criteria_size_unit])
        self.criteria_size_unit = "bytes"

        # Adjust unused raid level option to reflect documentation
        if self.raid_level == "raidAll":
            self.raid_level = "raidDiskPool"
        if self.raid_level == "raid3":
            self.raid_level = "raid5"

    @property
    @memoize
    def available_drives(self):
        """Determine the list of available drives"""
        return [drive["id"] for drive in self.drives if drive["available"] and drive["status"] == "optimal"]

    @property
    @memoize
    def available_drive_types(self):
        """Determine the types of available drives sorted by the most common first."""
        types = [drive["driveMediaType"] for drive in self.drives]
        return [entry[0] for entry in get_most_common_elements(types)]

    @property
    @memoize
    def available_drive_interface_types(self):
        """Determine the types of available drives."""
        interfaces = [drive["phyDriveType"] for drive in self.drives]
        return [entry[0] for entry in get_most_common_elements(interfaces)]

    @property
    def storage_pool_drives(self):
        """Retrieve list of drives found in storage pool."""
        return [drive for drive in self.drives if drive["currentVolumeGroupRef"] == self.pool_detail["id"] and not drive["hotSpare"]]

    @property
    def expandable_drive_count(self):
        """Maximum number of drives that a storage pool can be expanded at a given time."""
        capabilities = None
        if self.raid_level == "raidDiskPool":
            return len(self.available_drives)

        try:
            rc, capabilities = self.request("storage-systems/%s/capabilities" % self.ssid)
        except Exception as error:
            self.module.fail_json(msg="Failed to fetch maximum expandable drive count. Array id [%s].  Error[%s]."
                                      % (self.ssid, to_native(error)))

        return capabilities["featureParameters"]["maxDCEDrives"]

    @property
    def disk_pool_drive_minimum(self):
        """Provide the storage array's minimum disk pool drive count."""
        rc, attr = self.request("storage-systems/%s/symbol/getSystemAttributeDefaults" % self.ssid, ignore_errors=True)

        # Standard minimum is 11 drives but some allow 10 drives. 10 will be the default
        if (rc != 200 or "minimumDriveCount" not in attr["defaults"]["diskPoolDefaultAttributes"].keys() or
                attr["defaults"]["diskPoolDefaultAttributes"]["minimumDriveCount"] == 0):
            return self.DEFAULT_DISK_POOL_MINIMUM_DISK_COUNT

        return attr["defaults"]["diskPoolDefaultAttributes"]["minimumDriveCount"]

    def get_available_drive_capacities(self, drive_id_list=None):
        """Determine the list of available drive capacities."""
        if drive_id_list:
            available_drive_capacities = set([int(drive["usableCapacity"]) for drive in self.drives
                                              if drive["id"] in drive_id_list and drive["available"] and
                                              drive["status"] == "optimal"])
        else:
            available_drive_capacities = set([int(drive["usableCapacity"]) for drive in self.drives
                                              if drive["available"] and drive["status"] == "optimal"])

        self.module.log("available drive capacities: %s" % available_drive_capacities)
        return list(available_drive_capacities)

    @property
    def drives(self):
        """Retrieve list of drives found in storage pool."""
        drives = None
        try:
            rc, drives = self.request("storage-systems/%s/drives" % self.ssid)
        except Exception as error:
            self.module.fail_json(msg="Failed to fetch disk drives. Array id [%s].  Error[%s]."
                                      % (self.ssid, to_native(error)))

        return drives

    def is_drive_count_valid(self, drive_count):
        """Validate drive count criteria is met."""
        if self.criteria_drive_count and drive_count < self.criteria_drive_count:
            return False

        if self.raid_level == "raidDiskPool":
            return drive_count >= self.disk_pool_drive_minimum
        if self.raid_level == "raid0":
            return drive_count > 0
        if self.raid_level == "raid1":
            return drive_count >= 2 and (drive_count % 2) == 0
        if self.raid_level in ["raid3", "raid5"]:
            return 3 <= drive_count <= 30
        if self.raid_level == "raid6":
            return 5 <= drive_count <= 30
        return False

    @property
    def storage_pool(self):
        """Retrieve storage pool information."""
        storage_pools_resp = None
        try:
            rc, storage_pools_resp = self.request("storage-systems/%s/storage-pools" % self.ssid)
        except Exception as err:
            self.module.fail_json(msg="Failed to get storage pools. Array id [%s]. Error[%s]. State[%s]."
                                      % (self.ssid, to_native(err), self.state))

        pool_detail = [pool for pool in storage_pools_resp if pool["name"] == self.name]
        return pool_detail[0] if pool_detail else dict()

    @property
    def storage_pool_volumes(self):
        """Retrieve list of volumes associated with storage pool."""
        volumes_resp = None
        try:
            rc, volumes_resp = self.request("storage-systems/%s/volumes" % self.ssid)
        except Exception as err:
            self.module.fail_json(msg="Failed to get storage pools. Array id [%s]. Error[%s]. State[%s]."
                                      % (self.ssid, to_native(err), self.state))

        group_ref = self.storage_pool["volumeGroupRef"]
        storage_pool_volume_list = [volume["id"] for volume in volumes_resp if volume["volumeGroupRef"] == group_ref]
        return storage_pool_volume_list

    def get_ddp_capacity(self, expansion_drive_list):
        """Return the total usable capacity based on the additional drives."""

        def get_ddp_error_percent(_drive_count, _extent_count):
            """Determine the space reserved for reconstruction"""
            if _drive_count <= 36:
                if _extent_count <= 600:
                    return 0.40
                elif _extent_count <= 1400:
                    return 0.35
                elif _extent_count <= 6200:
                    return 0.20
                elif _extent_count <= 50000:
                    return 0.15
            elif _drive_count <= 64:
                if _extent_count <= 600:
                    return 0.20
                elif _extent_count <= 1400:
                    return 0.15
                elif _extent_count <= 6200:
                    return 0.10
                elif _extent_count <= 50000:
                    return 0.05
            elif _drive_count <= 480:
                if _extent_count <= 600:
                    return 0.20
                elif _extent_count <= 1400:
                    return 0.15
                elif _extent_count <= 6200:
                    return 0.10
                elif _extent_count <= 50000:
                    return 0.05

            self.module.fail_json(msg="Drive count exceeded the error percent table. Array[%s]" % self.ssid)

        def get_ddp_reserved_drive_count(_disk_count):
            """Determine the number of reserved drive."""
            reserve_count = 0

            if self.reserve_drive_count:
                reserve_count = self.reserve_drive_count
            elif _disk_count >= 256:
                reserve_count = 8
            elif _disk_count >= 192:
                reserve_count = 7
            elif _disk_count >= 128:
                reserve_count = 6
            elif _disk_count >= 64:
                reserve_count = 4
            elif _disk_count >= 32:
                reserve_count = 3
            elif _disk_count >= 12:
                reserve_count = 2
            elif _disk_count == 11:
                reserve_count = 1

            return reserve_count

        if self.pool_detail:
            drive_count = len(self.storage_pool_drives) + len(expansion_drive_list)
        else:
            drive_count = len(expansion_drive_list)

        drive_usable_capacity = min(min(self.get_available_drive_capacities()),
                                    min(self.get_available_drive_capacities(expansion_drive_list)))
        drive_data_extents = ((drive_usable_capacity - 8053063680) / 536870912)
        maximum_stripe_count = (drive_count * drive_data_extents) / 10

        error_percent = get_ddp_error_percent(drive_count, drive_data_extents)
        error_overhead = (drive_count * drive_data_extents / 10 * error_percent + 10) / 10

        total_stripe_count = maximum_stripe_count - error_overhead
        stripe_count_per_drive = total_stripe_count / drive_count
        reserved_stripe_count = get_ddp_reserved_drive_count(drive_count) * stripe_count_per_drive
        available_stripe_count = total_stripe_count - reserved_stripe_count

        return available_stripe_count * 4294967296

    @memoize
    def get_candidate_drives(self):
        """Retrieve set of drives candidates for creating a new storage pool."""

        def get_candidate_drive_request():
            """Perform request for new volume creation."""
            candidates_list = list()
            drive_types = [self.criteria_drive_type] if self.criteria_drive_type else self.available_drive_types
            interface_types = [self.criteria_drive_interface_type] \
                if self.criteria_drive_interface_type else self.available_drive_interface_types

            for interface_type in interface_types:
                for drive_type in drive_types:
                    candidates = None
                    volume_candidate_request_data = dict(
                        type="diskPool" if self.raid_level == "raidDiskPool" else "traditional",
                        diskPoolVolumeCandidateRequestData=dict(
                            reconstructionReservedDriveCount=65535))
                    candidate_selection_type = dict(
                        candidateSelectionType="count",
                        driveRefList=dict(driveRef=self.available_drives))
                    criteria = dict(raidLevel=self.raid_level,
                                    phyDriveType=interface_type,
                                    dssPreallocEnabled=False,
                                    securityType="capable" if self.criteria_drive_require_fde else "none",
                                    driveMediaType=drive_type,
                                    onlyProtectionInformationCapable=True if self.criteria_drive_require_da else False,
                                    volumeCandidateRequestData=volume_candidate_request_data,
                                    allocateReserveSpace=False,
                                    securityLevel="fde" if self.criteria_drive_require_fde else "none",
                                    candidateSelectionType=candidate_selection_type)

                    try:
                        rc, candidates = self.request("storage-systems/%s/symbol/getVolumeCandidates?verboseError"
                                                      "Response=true" % self.ssid, data=criteria, method="POST")
                    except Exception as error:
                        self.module.fail_json(msg="Failed to retrieve volume candidates. Array [%s]. Error [%s]."
                                                  % (self.ssid, to_native(error)))

                    if candidates:
                        candidates_list.extend(candidates["volumeCandidate"])

            # Sort output based on tray and then drawer protection first
            tray_drawer_protection = list()
            tray_protection = list()
            drawer_protection = list()
            no_protection = list()
            sorted_candidates = list()
            for item in candidates_list:
                if item["trayLossProtection"]:
                    if item["drawerLossProtection"]:
                        tray_drawer_protection.append(item)
                    else:
                        tray_protection.append(item)
                elif item["drawerLossProtection"]:
                    drawer_protection.append(item)
                else:
                    no_protection.append(item)

            if tray_drawer_protection:
                sorted_candidates.extend(tray_drawer_protection)
            if tray_protection:
                sorted_candidates.extend(tray_protection)
            if drawer_protection:
                sorted_candidates.extend(drawer_protection)
            if no_protection:
                sorted_candidates.extend(no_protection)

            return sorted_candidates

        # Determine the appropriate candidate list
        for candidate in get_candidate_drive_request():

            # Evaluate candidates for required drive count, collective drive usable capacity and minimum drive size
            if self.criteria_drive_count:
                if self.criteria_drive_count != int(candidate["driveCount"]):
                    continue
            if self.criteria_min_usable_capacity:
                if ((self.raid_level == "raidDiskPool" and self.criteria_min_usable_capacity >
                     self.get_ddp_capacity(candidate["driveRefList"]["driveRef"])) or
                        self.criteria_min_usable_capacity > int(candidate["usableSize"])):
                    continue
            if self.criteria_drive_min_size:
                if self.criteria_drive_min_size > min(self.get_available_drive_capacities(candidate["driveRefList"]["driveRef"])):
                    continue

            return candidate

        self.module.fail_json(msg="Not enough drives to meet the specified criteria. Array [%s]." % self.ssid)

    @memoize
    def get_expansion_candidate_drives(self):
        """Retrieve required expansion drive list.

        Note: To satisfy the expansion criteria each item in the candidate list must added specified group since there
        is a potential limitation on how many drives can be incorporated at a time.
            * Traditional raid volume groups must be added two drives maximum at a time. No limits on raid disk pools.

        :return list(candidate): list of candidate structures from the getVolumeGroupExpansionCandidates symbol endpoint
        """

        def get_expansion_candidate_drive_request():
            """Perform the request for expanding existing volume groups or disk pools.

            Note: the list of candidate structures do not necessarily produce candidates that meet all criteria.
            """
            candidates_list = None
            url = "storage-systems/%s/symbol/getVolumeGroupExpansionCandidates?verboseErrorResponse=true" % self.ssid
            if self.raid_level == "raidDiskPool":
                url = "storage-systems/%s/symbol/getDiskPoolExpansionCandidates?verboseErrorResponse=true" % self.ssid

            try:
                rc, candidates_list = self.request(url, method="POST", data=self.pool_detail["id"])
            except Exception as error:
                self.module.fail_json(msg="Failed to retrieve volume candidates. Array [%s]. Error [%s]."
                                          % (self.ssid, to_native(error)))

            return candidates_list["candidates"]

        required_candidate_list = list()
        required_additional_drives = 0
        required_additional_capacity = 0
        total_required_capacity = 0

        # determine whether and how much expansion is need to satisfy the specified criteria
        if self.criteria_min_usable_capacity:
            total_required_capacity = self.criteria_min_usable_capacity
            required_additional_capacity = self.criteria_min_usable_capacity - int(self.pool_detail["totalRaidedSpace"])

        if self.criteria_drive_count:
            required_additional_drives = self.criteria_drive_count - len(self.storage_pool_drives)

        # Determine the appropriate expansion candidate list
        if required_additional_drives > 0 or required_additional_capacity > 0:
            for candidate in get_expansion_candidate_drive_request():

                if self.criteria_drive_min_size:
                    if self.criteria_drive_min_size > min(self.get_available_drive_capacities(candidate["drives"])):
                        continue

                if self.raid_level == "raidDiskPool":
                    if (len(candidate["drives"]) >= required_additional_drives and
                            self.get_ddp_capacity(candidate["drives"]) >= total_required_capacity):
                        required_candidate_list.append(candidate)
                        break
                else:
                    required_additional_drives -= len(candidate["drives"])
                    required_additional_capacity -= int(candidate["usableCapacity"])
                    required_candidate_list.append(candidate)

                # Determine if required drives and capacities are satisfied
                if required_additional_drives <= 0 and required_additional_capacity <= 0:
                    break
            else:
                self.module.fail_json(msg="Not enough drives to meet the specified criteria. Array [%s]." % self.ssid)

        return required_candidate_list

    def get_reserve_drive_count(self):
        """Retrieve the current number of reserve drives for raidDiskPool (Only for raidDiskPool)."""

        if not self.pool_detail:
            self.module.fail_json(msg="The storage pool must exist. Array [%s]." % self.ssid)

        if self.raid_level != "raidDiskPool":
            self.module.fail_json(msg="The storage pool must be a raidDiskPool. Pool [%s]. Array [%s]."
                                      % (self.pool_detail["id"], self.ssid))

        return self.pool_detail["volumeGroupData"]["diskPoolData"]["reconstructionReservedDriveCount"]

    def get_maximum_reserve_drive_count(self):
        """Retrieve the maximum number of reserve drives for storage pool (Only for raidDiskPool)."""
        if self.raid_level != "raidDiskPool":
            self.module.fail_json(msg="The storage pool must be a raidDiskPool. Pool [%s]. Array [%s]."
                                      % (self.pool_detail["id"], self.ssid))

        drives_ids = list()

        if self.pool_detail:
            drives_ids.extend(self.storage_pool_drives)
            for candidate in self.get_expansion_candidate_drives():
                drives_ids.extend((candidate["drives"]))
        else:
            candidate = self.get_candidate_drives()
            drives_ids.extend(candidate["driveRefList"]["driveRef"])

        drive_count = len(drives_ids)
        maximum_reserve_drive_count = min(int(drive_count * 0.2 + 1), drive_count - 10)
        if maximum_reserve_drive_count > 10:
            maximum_reserve_drive_count = 10

        return maximum_reserve_drive_count

    def set_reserve_drive_count(self, check_mode=False):
        """Set the reserve drive count for raidDiskPool."""
        changed = False

        if self.raid_level == "raidDiskPool" and self.reserve_drive_count:
            maximum_count = self.get_maximum_reserve_drive_count()

            if self.reserve_drive_count < 0 or self.reserve_drive_count > maximum_count:
                self.module.fail_json(msg="Supplied reserve drive count is invalid or exceeds the maximum allowed. "
                                          "Note that it may be necessary to wait for expansion operations to complete "
                                          "before the adjusting the reserve drive count. Maximum [%s]. Array [%s]."
                                          % (maximum_count, self.ssid))

            if self.reserve_drive_count != self.get_reserve_drive_count():
                changed = True

            if not check_mode:
                try:
                    rc, resp = self.request("storage-systems/%s/symbol/setDiskPoolReservedDriveCount" % self.ssid,
                                            method="POST", data=dict(volumeGroupRef=self.pool_detail["id"],
                                                                     newDriveCount=self.reserve_drive_count))
                except Exception as error:
                    self.module.fail_json(msg="Failed to set reserve drive count for disk pool. Disk Pool [%s]."
                                              " Array [%s]." % (self.pool_detail["id"], self.ssid))

        return changed

    def erase_all_available_secured_drives(self, check_mode=False):
        """Erase all available drives that have encryption at rest feature enabled."""
        changed = False
        drives_list = list()
        for drive in self.drives:
            if drive["available"] and drive["fdeEnabled"]:
                changed = True
                drives_list.append(drive["id"])

        if drives_list and not check_mode:
            try:
                rc, resp = self.request("storage-systems/%s/symbol/reprovisionDrive?verboseErrorResponse=true"
                                        % self.ssid, method="POST", data=dict(driveRef=drives_list))
            except Exception as error:
                self.module.fail_json(msg="Failed to erase all secured drives. Array [%s]" % self.ssid)

        return changed

    def create_storage_pool(self):
        """Create new storage pool."""
        url = "storage-systems/%s/symbol/createVolumeGroup?verboseErrorResponse=true" % self.ssid
        request_body = dict(label=self.name,
                            candidate=self.get_candidate_drives())

        if self.raid_level == "raidDiskPool":
            url = "storage-systems/%s/symbol/createDiskPool?verboseErrorResponse=true" % self.ssid

            request_body.update(
                dict(backgroundOperationPriority="useDefault",
                     criticalReconstructPriority="useDefault",
                     degradedReconstructPriority="useDefault",
                     poolUtilizationCriticalThreshold=65535,
                     poolUtilizationWarningThreshold=0))

            if self.reserve_drive_count:
                request_body.update(dict(volumeCandidateData=dict(
                    diskPoolVolumeCandidateData=dict(reconstructionReservedDriveCount=self.reserve_drive_count))))

        try:
            rc, resp = self.request(url, method="POST", data=request_body)
        except Exception as error:
            self.module.fail_json(msg="Failed to create storage pool. Array id [%s].  Error[%s]."
                                      % (self.ssid, to_native(error)))

        # Update drive and storage pool information
        self.pool_detail = self.storage_pool

    def delete_storage_pool(self):
        """Delete storage pool."""
        storage_pool_drives = [drive["id"] for drive in self.storage_pool_drives if drive["fdeEnabled"]]
        try:
            delete_volumes_parameter = "?delete-volumes=true" if self.remove_volumes else ""
            rc, resp = self.request("storage-systems/%s/storage-pools/%s%s"
                                    % (self.ssid, self.pool_detail["id"], delete_volumes_parameter), method="DELETE")
        except Exception as error:
            self.module.fail_json(msg="Failed to delete storage pool. Pool id [%s]. Array id [%s].  Error[%s]."
                                      % (self.pool_detail["id"], self.ssid, to_native(error)))

        if storage_pool_drives and self.erase_secured_drives:
            try:
                rc, resp = self.request("storage-systems/%s/symbol/reprovisionDrive?verboseErrorResponse=true"
                                        % self.ssid, method="POST", data=dict(driveRef=storage_pool_drives))
            except Exception as error:
                self.module.fail_json(msg="Failed to erase drives prior to creating new storage pool. Array [%s]."
                                          " Error [%s]." % (self.ssid, to_native(error)))

    def secure_storage_pool(self, check_mode=False):
        """Enable security on an existing storage pool"""
        self.pool_detail = self.storage_pool
        needs_secure_pool = False

        if not self.secure_pool and self.pool_detail["securityType"] == "enabled":
            self.module.fail_json(msg="It is not possible to disable storage pool security! See array documentation.")
        if self.secure_pool and self.pool_detail["securityType"] != "enabled":
            needs_secure_pool = True

        if needs_secure_pool and not check_mode:
            try:
                rc, resp = self.request("storage-systems/%s/storage-pools/%s" % (self.ssid, self.pool_detail["id"]),
                                        data=dict(securePool=True), method="POST")
            except Exception as error:
                self.module.fail_json(msg="Failed to secure storage pool. Pool id [%s]. Array [%s]. Error"
                                          " [%s]." % (self.pool_detail["id"], self.ssid, to_native(error)))

        self.pool_detail = self.storage_pool
        return needs_secure_pool

    def migrate_raid_level(self, check_mode=False):
        """Request storage pool raid level migration."""
        needs_migration = self.raid_level != self.pool_detail["raidLevel"]
        if needs_migration and self.pool_detail["raidLevel"] == "raidDiskPool":
            self.module.fail_json(msg="Raid level cannot be changed for disk pools")

        if needs_migration and not check_mode:
            sp_raid_migrate_req = dict(raidLevel=self.raid_level)

            try:
                rc, resp = self.request("storage-systems/%s/storage-pools/%s/raid-type-migration"
                                        % (self.ssid, self.name), data=sp_raid_migrate_req, method="POST")
            except Exception as error:
                self.module.fail_json(msg="Failed to change the raid level of storage pool. Array id [%s]."
                                          "  Error[%s]." % (self.ssid, to_native(error)))

        self.pool_detail = self.storage_pool
        return needs_migration

    def expand_storage_pool(self, check_mode=False):
        """Add drives to existing storage pool.

        :return bool: whether drives were required to be added to satisfy the specified criteria."""
        expansion_candidate_list = self.get_expansion_candidate_drives()
        changed_required = bool(expansion_candidate_list)
        estimated_completion_time = 0.0

        # build expandable groupings of traditional raid candidate
        required_expansion_candidate_list = list()
        while expansion_candidate_list:
            subset = list()
            while expansion_candidate_list and len(subset) < self.expandable_drive_count:
                subset.extend(expansion_candidate_list.pop()["drives"])
            required_expansion_candidate_list.append(subset)

        if required_expansion_candidate_list and not check_mode:
            url = "storage-systems/%s/symbol/startVolumeGroupExpansion?verboseErrorResponse=true" % self.ssid
            if self.raid_level == "raidDiskPool":
                url = "storage-systems/%s/symbol/startDiskPoolExpansion?verboseErrorResponse=true" % self.ssid

            while required_expansion_candidate_list:
                candidate_drives_list = required_expansion_candidate_list.pop()
                request_body = dict(volumeGroupRef=self.pool_detail["volumeGroupRef"],
                                    driveRef=candidate_drives_list)
                try:
                    rc, resp = self.request(url, method="POST", data=request_body)
                except Exception as error:
                    rc, actions_resp = self.request("storage-systems/%s/storage-pools/%s/action-progress"
                                                    % (self.ssid, self.pool_detail["id"]), ignore_errors=True)
                    if rc == 200 and actions_resp:
                        actions = [action["currentAction"] for action in actions_resp
                                   if action["volumeRef"] in self.storage_pool_volumes]
                        self.module.fail_json(msg="Failed to add drives to the storage pool possibly because of actions"
                                                  " in progress. Actions [%s]. Pool id [%s]. Array id [%s]. Error[%s]."
                                                  % (", ".join(actions), self.pool_detail["id"], self.ssid,
                                                     to_native(error)))

                    self.module.fail_json(msg="Failed to add drives to storage pool. Pool id [%s]. Array id [%s]."
                                              "  Error[%s]." % (self.pool_detail["id"], self.ssid, to_native(error)))

                # Wait for expansion completion unless it is the last request in the candidate list
                if required_expansion_candidate_list:
                    for dummy in range(self.EXPANSION_TIMEOUT_SEC):
                        rc, actions_resp = self.request("storage-systems/%s/storage-pools/%s/action-progress"
                                                        % (self.ssid, self.pool_detail["id"]), ignore_errors=True)
                        if rc == 200:
                            for action in actions_resp:
                                if (action["volumeRef"] in self.storage_pool_volumes and
                                        action["currentAction"] == "remappingDce"):
                                    sleep(1)
                                    estimated_completion_time = action["estimatedTimeToCompletion"]
                                    break
                            else:
                                estimated_completion_time = 0.0
                                break

        return changed_required, estimated_completion_time

    def apply(self):
        """Apply requested state to storage array."""
        changed = False

        if self.state == "present":
            if self.criteria_drive_count is None and self.criteria_min_usable_capacity is None:
                self.module.fail_json(msg="One of criteria_min_usable_capacity or criteria_drive_count must be"
                                          " specified.")
            if self.criteria_drive_count and not self.is_drive_count_valid(self.criteria_drive_count):
                self.module.fail_json(msg="criteria_drive_count must be valid for the specified raid level.")

        self.pool_detail = self.storage_pool
        self.module.log(pformat(self.pool_detail))

        if self.state == "present" and self.erase_secured_drives:
            self.erase_all_available_secured_drives(check_mode=True)

        # Determine whether changes need to be applied to the storage array
        if self.pool_detail:

            if self.state == "absent":
                changed = True

            elif self.state == "present":

                if self.criteria_drive_count and self.criteria_drive_count < len(self.storage_pool_drives):
                    self.module.fail_json(msg="Failed to reduce the size of the storage pool. Array [%s]. Pool [%s]."
                                              % (self.ssid, self.pool_detail["id"]))

                if self.criteria_drive_type and self.criteria_drive_type != self.pool_detail["driveMediaType"]:
                    self.module.fail_json(msg="Failed! It is not possible to modify storage pool media type."
                                              " Array [%s]. Pool [%s]." % (self.ssid, self.pool_detail["id"]))

                if (self.criteria_drive_require_da is not None and self.criteria_drive_require_da !=
                        self.pool_detail["protectionInformationCapabilities"]["protectionInformationCapable"]):
                    self.module.fail_json(msg="Failed! It is not possible to modify DA-capability. Array [%s]."
                                              " Pool [%s]." % (self.ssid, self.pool_detail["id"]))

                # Evaluate current storage pool for required change.
                needs_expansion, estimated_completion_time = self.expand_storage_pool(check_mode=True)
                if needs_expansion:
                    changed = True
                if self.migrate_raid_level(check_mode=True):
                    changed = True
                if self.secure_storage_pool(check_mode=True):
                    changed = True
                if self.set_reserve_drive_count(check_mode=True):
                    changed = True

        elif self.state == "present":
            changed = True

        # Apply changes to storage array
        msg = "No changes were required for the storage pool [%s]."
        if changed and not self.module.check_mode:
            if self.state == "present":
                if self.erase_secured_drives:
                    self.erase_all_available_secured_drives()

                if self.pool_detail:
                    change_list = list()

                    # Expansion needs to occur before raid level migration to account for any sizing needs.
                    expanded, estimated_completion_time = self.expand_storage_pool()
                    if expanded:
                        change_list.append("expanded")
                    if self.migrate_raid_level():
                        change_list.append("raid migration")
                    if self.secure_storage_pool():
                        change_list.append("secured")
                    if self.set_reserve_drive_count():
                        change_list.append("adjusted reserve drive count")

                    if change_list:
                        msg = "Following changes have been applied to the storage pool [%s]: " + ", ".join(change_list)

                    if expanded:
                        msg += "\nThe expansion operation will complete in an estimated %s minutes."\
                               % estimated_completion_time
                else:
                    self.create_storage_pool()
                    msg = "Storage pool [%s] was created."

                    if self.secure_storage_pool():
                        msg = "Storage pool [%s] was created and secured."
                    if self.set_reserve_drive_count():
                        msg += " Adjusted reserve drive count."

            elif self.pool_detail:
                self.delete_storage_pool()
                msg = "Storage pool [%s] removed."

        self.pool_detail = self.storage_pool
        self.module.log(pformat(self.pool_detail))
        self.module.log(msg % self.name)
        self.module.exit_json(msg=msg % self.name, changed=changed, **self.pool_detail)


def main():
    storage_pool = NetAppESeriesStoragePool()
    storage_pool.apply()


if __name__ == "__main__":
    main()
