# Copyright 2014 Hewlett-Packard Development Company, L.P.
# 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.

"""This module detects whether third-party libraries, utilized by third-party
drivers, are present on the system. If they are not, it mocks them and tinkers
with sys.modules so that the drivers can be loaded by unit tests, and the unit
tests can continue to test the functionality of those drivers without the
respective external libraries' actually being present.

Any external library required by a third-party driver should be mocked here.
Current list of mocked libraries:

- proliantutils
- pysnmp
- scciclient
- hpOneView
- pywsman
- python-dracclient
"""

import sys

import mock
from oslo_utils import importutils
import six

from ironic.drivers.modules import ipmitool
from ironic.tests.unit.drivers import third_party_driver_mock_specs \
    as mock_specs


# IPMITool driver checks the system for presence of 'ipmitool' binary during
# __init__. We bypass that check in order to run the unit tests, which do not
# depend on 'ipmitool' being on the system.
ipmitool.TIMING_SUPPORT = False
ipmitool.DUAL_BRIDGE_SUPPORT = False
ipmitool.SINGLE_BRIDGE_SUPPORT = False

proliantutils = importutils.try_import('proliantutils')
if not proliantutils:
    proliantutils = mock.MagicMock(spec_set=mock_specs.PROLIANTUTILS_SPEC)
    sys.modules['proliantutils'] = proliantutils
    sys.modules['proliantutils.ilo'] = proliantutils.ilo
    sys.modules['proliantutils.ilo.client'] = proliantutils.ilo.client
    sys.modules['proliantutils.exception'] = proliantutils.exception
    sys.modules['proliantutils.utils'] = proliantutils.utils
    proliantutils.utils.process_firmware_image = mock.MagicMock()
    proliantutils.exception.IloError = type('IloError', (Exception,), {})
    command_exception = type('IloCommandNotSupportedError', (Exception,), {})
    proliantutils.exception.IloCommandNotSupportedError = command_exception
    proliantutils.exception.IloCommandNotSupportedInBiosError = type(
        'IloCommandNotSupportedInBiosError', (Exception,), {})
    proliantutils.exception.InvalidInputError = type(
        'InvalidInputError', (Exception,), {})
    proliantutils.exception.ImageExtractionFailed = type(
        'ImageExtractionFailed', (Exception,), {})
    if 'ironic.drivers.ilo' in sys.modules:
        six.moves.reload_module(sys.modules['ironic.drivers.ilo'])


hpOneView = importutils.try_import('hpOneView')
if not hpOneView:
    hpOneView = mock.MagicMock(spec_set=mock_specs.HPE_ONEVIEW_SPEC)
    sys.modules['hpOneView'] = hpOneView
    sys.modules['hpOneView.oneview_client'] = hpOneView.oneview_client
    sys.modules['hpOneView.resources'] = hpOneView.resources
    sys.modules['hpOneView.exceptions'] = hpOneView.exceptions
    hpOneView.exceptions.HPOneViewException = type('HPOneViewException',
                                                   (Exception,), {})
sys.modules['hpOneView.oneview_client'].OneViewClient = mock.MagicMock(
    spec_set=mock_specs.HPE_ONEVIEW_CLS_SPEC
)
if 'ironic.drivers.oneview' in sys.modules:
    six.moves.reload_module(sys.modules['ironic.drivers.modules.oneview'])


redfish = importutils.try_import('redfish')
if not redfish:
    redfish = mock.MagicMock(spec_set=mock_specs.REDFISH_SPEC)
    sys.modules['redfish'] = redfish
if 'ironic.drivers.oneview' in sys.modules:
    six.moves.reload_module(sys.modules['ironic.drivers.modules.oneview'])


# attempt to load the external 'python-dracclient' library, which is required
# by the optional drivers.modules.drac module
dracclient = importutils.try_import('dracclient')
if not dracclient:
    dracclient = mock.MagicMock(spec_set=mock_specs.DRACCLIENT_SPEC)
    dracclient.client = mock.MagicMock(
        spec_set=mock_specs.DRACCLIENT_CLIENT_MOD_SPEC)
    dracclient.constants = mock.MagicMock(
        spec_set=mock_specs.DRACCLIENT_CONSTANTS_MOD_SPEC,
        POWER_OFF=mock.sentinel.POWER_OFF,
        POWER_ON=mock.sentinel.POWER_ON,
        REBOOT=mock.sentinel.REBOOT)
    sys.modules['dracclient'] = dracclient
    sys.modules['dracclient.client'] = dracclient.client
    sys.modules['dracclient.constants'] = dracclient.constants
    sys.modules['dracclient.exceptions'] = dracclient.exceptions
    dracclient.exceptions.BaseClientException = type('BaseClientException',
                                                     (Exception,), {})
    # Now that the external library has been mocked, if anything had already
    # loaded any of the drivers, reload them.
    if 'ironic.drivers.modules.drac' in sys.modules:
        six.moves.reload_module(sys.modules['ironic.drivers.modules.drac'])

# attempt to load the external 'pysnmp' library, which is required by
# the optional drivers.modules.snmp module
pysnmp = importutils.try_import("pysnmp")
if not pysnmp:
    pysnmp = mock.MagicMock(spec_set=mock_specs.PYWSNMP_SPEC)
    sys.modules["pysnmp"] = pysnmp
    sys.modules["pysnmp.entity"] = pysnmp.entity
    sys.modules["pysnmp.entity.rfc3413"] = pysnmp.entity.rfc3413
    sys.modules["pysnmp.entity.rfc3413.oneliner"] = (
        pysnmp.entity.rfc3413.oneliner)
    sys.modules["pysnmp.entity.rfc3413.oneliner.cmdgen"] = (
        pysnmp.entity.rfc3413.oneliner.cmdgen)
    sys.modules["pysnmp.error"] = pysnmp.error
    pysnmp.error.PySnmpError = Exception
    sys.modules["pysnmp.proto"] = pysnmp.proto
    sys.modules["pysnmp.proto.rfc1902"] = pysnmp.proto.rfc1902
    # Patch the RFC1902 integer class with a python int
    pysnmp.proto.rfc1902.Integer = int


# if anything has loaded the snmp driver yet, reload it now that the
# external library has been mocked
if 'ironic.drivers.modules.snmp' in sys.modules:
    six.moves.reload_module(sys.modules['ironic.drivers.modules.snmp'])


# attempt to load the external 'scciclient' library, which is required by
# the optional drivers.modules.irmc module
scciclient = importutils.try_import('scciclient')
if not scciclient:
    mock_scciclient = mock.MagicMock(spec_set=mock_specs.SCCICLIENT_SPEC)
    sys.modules['scciclient'] = mock_scciclient
    sys.modules['scciclient.irmc'] = mock_scciclient.irmc
    sys.modules['scciclient.irmc.scci'] = mock.MagicMock(
        spec_set=mock_specs.SCCICLIENT_IRMC_SCCI_SPEC,
        POWER_OFF=mock.sentinel.POWER_OFF,
        POWER_ON=mock.sentinel.POWER_ON,
        POWER_RESET=mock.sentinel.POWER_RESET,
        MOUNT_CD=mock.sentinel.MOUNT_CD,
        UNMOUNT_CD=mock.sentinel.UNMOUNT_CD,
        MOUNT_FD=mock.sentinel.MOUNT_FD,
        UNMOUNT_FD=mock.sentinel.UNMOUNT_FD)
    sys.modules['scciclient.irmc.elcm'] = mock.MagicMock(
        spec_set=mock_specs.SCCICLIENT_IRMC_ELCM_SPEC)


# if anything has loaded the iRMC driver yet, reload it now that the
# external library has been mocked
if 'ironic.drivers.modules.irmc' in sys.modules:
    six.moves.reload_module(sys.modules['ironic.drivers.modules.irmc'])


# install mock object to prevent 'iscsi_irmc' and 'agent_irmc' from
# checking whether NFS/CIFS share file system is mounted or not.
irmc_boot = importutils.import_module(
    'ironic.drivers.modules.irmc.boot')
irmc_boot.check_share_fs_mounted_orig = irmc_boot.check_share_fs_mounted
irmc_boot.check_share_fs_mounted_patcher = mock.patch(
    'ironic.drivers.modules.irmc.boot.check_share_fs_mounted')
irmc_boot.check_share_fs_mounted_patcher.return_value = None


ironic_inspector_client = importutils.try_import('ironic_inspector_client')
if not ironic_inspector_client:
    ironic_inspector_client = mock.MagicMock(
        spec_set=mock_specs.IRONIC_INSPECTOR_CLIENT_SPEC)
    ironic_inspector_client.ClientV1 = mock_specs.InspectorClientV1Specs
    sys.modules['ironic_inspector_client'] = ironic_inspector_client
    if 'ironic.drivers.modules.inspector' in sys.modules:
        six.moves.reload_module(
            sys.modules['ironic.drivers.modules.inspector'])


class MockKwargsException(Exception):
    def __init__(self, *args, **kwargs):
        super(MockKwargsException, self).__init__(*args)
        self.kwargs = kwargs


ucssdk = importutils.try_import('UcsSdk')
if not ucssdk:
    ucssdk = mock.MagicMock()
    sys.modules['UcsSdk'] = ucssdk
    sys.modules['UcsSdk.utils'] = ucssdk.utils
    sys.modules['UcsSdk.utils.power'] = ucssdk.utils.power
    sys.modules['UcsSdk.utils.management'] = ucssdk.utils.management
    sys.modules['UcsSdk.utils.exception'] = ucssdk.utils.exception
    ucssdk.utils.exception.UcsOperationError = (
        type('UcsOperationError', (MockKwargsException,), {}))
    ucssdk.utils.exception.UcsConnectionError = (
        type('UcsConnectionError', (MockKwargsException,), {}))
    if 'ironic.drivers.modules.ucs' in sys.modules:
        six.moves.reload_module(
            sys.modules['ironic.drivers.modules.ucs'])

imcsdk = importutils.try_import('ImcSdk')
if not imcsdk:
    imcsdk = mock.MagicMock()
    imcsdk.ImcException = Exception
    sys.modules['ImcSdk'] = imcsdk
    if 'ironic.drivers.modules.cimc' in sys.modules:
        six.moves.reload_module(
            sys.modules['ironic.drivers.modules.cimc'])


sushy = importutils.try_import('sushy')
if not sushy:
    sushy = mock.MagicMock(
        spec_set=mock_specs.SUSHY_CONSTANTS_SPEC,
        BOOT_SOURCE_TARGET_PXE='Pxe',
        BOOT_SOURCE_TARGET_HDD='Hdd',
        BOOT_SOURCE_TARGET_CD='Cd',
        BOOT_SOURCE_TARGET_BIOS_SETUP='BiosSetup',
        SYSTEM_POWER_STATE_ON='on',
        SYSTEM_POWER_STATE_POWERING_ON='powering on',
        SYSTEM_POWER_STATE_OFF='off',
        SYSTEM_POWER_STATE_POWERING_OFF='powering off',
        RESET_ON='on',
        RESET_FORCE_OFF='force off',
        RESET_GRACEFUL_SHUTDOWN='graceful shutdown',
        RESET_GRACEFUL_RESTART='graceful restart',
        RESET_FORCE_RESTART='force restart',
        RESET_NMI='nmi',
        BOOT_SOURCE_ENABLED_CONTINUOUS='continuous',
        BOOT_SOURCE_ENABLED_ONCE='once'
    )

    sys.modules['sushy'] = sushy
    if 'ironic.drivers.modules.redfish' in sys.modules:
        six.moves.reload_module(
            sys.modules['ironic.drivers.modules.redfish'])

xclarity_client = importutils.try_import('xclarity_client')
if not xclarity_client:
    xclarity_client = mock.MagicMock(spec_set=mock_specs.XCLARITY_SPEC)
    sys.modules['xclarity_client'] = xclarity_client
    sys.modules['xclarity_client.client'] = xclarity_client.client
    states = mock.MagicMock(
        spec_set=mock_specs.XCLARITY_STATES_SPEC,
        STATE_POWER_ON="power on",
        STATE_POWER_OFF="power off",
        STATE_POWERING_ON="powering_on",
        STATE_POWERING_OFF="powering_off")
    sys.modules['xclarity_client.states'] = states
    sys.modules['xclarity_client.exceptions'] = xclarity_client.exceptions
    sys.modules['xclarity_client.utils'] = xclarity_client.utils
    xclarity_client.exceptions.XClarityException = type('XClarityException',
                                                        (Exception,), {})
    sys.modules['xclarity_client.models'] = xclarity_client.models
