# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

from debtcollector import removals
from keystoneauth1 import identity
from keystoneauth1 import session

import manilaclient
from manilaclient.common import constants
from manilaclient.common import httpclient
from manilaclient import exceptions
from manilaclient.v2 import availability_zones
from manilaclient.v2 import limits
from manilaclient.v2 import messages
from manilaclient.v2 import qos_types
from manilaclient.v2 import quota_classes
from manilaclient.v2 import quotas
from manilaclient.v2 import resource_locks
from manilaclient.v2 import scheduler_stats
from manilaclient.v2 import security_services
from manilaclient.v2 import services
from manilaclient.v2 import share_access_rules
from manilaclient.v2 import share_backups
from manilaclient.v2 import share_export_locations
from manilaclient.v2 import share_group_snapshots
from manilaclient.v2 import share_group_type_access
from manilaclient.v2 import share_group_types
from manilaclient.v2 import share_groups
from manilaclient.v2 import share_instance_export_locations
from manilaclient.v2 import share_instances
from manilaclient.v2 import share_network_subnets
from manilaclient.v2 import share_networks
from manilaclient.v2 import share_replica_export_locations
from manilaclient.v2 import share_replicas
from manilaclient.v2 import share_servers
from manilaclient.v2 import share_snapshot_export_locations
from manilaclient.v2 import share_snapshot_instance_export_locations
from manilaclient.v2 import share_snapshot_instances
from manilaclient.v2 import share_snapshots
from manilaclient.v2 import share_transfers
from manilaclient.v2 import share_type_access
from manilaclient.v2 import share_types
from manilaclient.v2 import shares


class Client:
    """Top-level object to access the OpenStack Manila API.

    Create an instance with your creds::

        >>> client = Client(username=USERNAME,
                            password=PASSWORD,
                            auth_url=AUTH_URL,
                            project_name=PROJECT_NAME)

    Or, alternatively, you can create a client instance using the
    keystoneauth1.session API::

        >>> from keystoneauth1.identity import v3
        >>> from keystoneauth1 import session
        >>> from manilaclient import client
        >>> auth = v3.Password(auth_url=AUTH_URL,
                               username=USERNAME,
                               user_domain_name=USER_DOMAIN_NAME,
                               password=PASSWORD,
                               project_name=PROJECT_ID,
                               project_domain_name=PROJECT_DOMAIN_NAME)
        >>> sess = session.Session(auth=auth)
        >>> manila = client.Client(VERSION, session=sess)

    Then call methods on its managers::

        >>> client.shares.list()
        ...
    """

    @removals.removed_kwarg(
        'use_keyring',
        message='This parameter is no longer supported and has no effect.',
        version='5.8.0',
        removal_version='6.0.0',
    )
    @removals.removed_kwarg(
        'force_new_token',
        message='This parameter is no longer supported and has no effect.',
        version='5.8.0',
        removal_version='6.0.0',
    )
    @removals.removed_kwarg(
        'cached_token_lifetime',
        message='This parameter is no longer supported and has no effect.',
        version='5.8.0',
        removal_version='6.0.0',
    )
    def __init__(
        self,
        username=None,
        project_id=None,
        auth_url=None,
        insecure=False,
        timeout=None,
        tenant_id=None,
        project_name=None,
        region_name=None,
        endpoint_type='publicURL',
        extensions=None,
        service_type=constants.V2_SERVICE_TYPE,
        service_name=None,
        retries=None,
        http_log_debug=False,
        input_auth_token=None,
        session=None,
        auth=None,
        cacert=None,
        service_catalog_url=None,
        user_agent='python-manilaclient',
        use_keyring=False,
        force_new_token=False,
        cached_token_lifetime=300,
        api_version=manilaclient.API_MIN_VERSION,
        user_id=None,
        user_domain_id=None,
        user_domain_name=None,
        project_domain_id=None,
        project_domain_name=None,
        cert=None,
        password=None,
        **kwargs,
    ):
        self.username = username
        self.password = password
        self.tenant_id = tenant_id or project_id
        self.tenant_name = project_name

        self.user_id = user_id
        self.project_id = project_id or tenant_id
        self.project_name = project_name
        self.user_domain_id = user_domain_id
        self.user_domain_name = user_domain_name
        self.project_domain_id = project_domain_id
        self.project_domain_name = project_domain_name

        self.endpoint_type = endpoint_type
        self.auth_url = auth_url
        self.region_name = region_name

        self.cacert = cacert
        self.cert = cert
        self.insecure = insecure

        self.project_id = tenant_id if tenant_id is not None else project_id
        self.keystone_client = None
        self.session = session

        self.api_version = api_version

        # NOTE(u_glide): token authorization has highest priority.
        # That's why session and/or password will be ignored
        # if token is provided.
        if input_auth_token:
            # Raw token path - no keystoneauth session available
            if not service_catalog_url:
                msg = (
                    "For token-based authentication you should "
                    "provide 'input_auth_token' and "
                    "'service_catalog_url'."
                )
                raise exceptions.ClientException(msg)
            self.client = httpclient.HTTPClient(
                service_catalog_url,
                input_auth_token,
                user_agent,
                insecure=insecure,
                cacert=cacert,
                cert=cert,
                timeout=timeout,
                retries=retries,
                http_log_debug=http_log_debug,
                api_version=self.api_version,
            )
        else:
            if not session:
                # Legacy path - create auth plugin and session ourselves
                auth, session = self._get_keystone_auth_and_session()

            self.keystone_client = httpclient.SessionClient(
                session=session,
                auth=auth,
                interface=endpoint_type,
                service_type=service_type,
                service_name=service_name,
                region_name=region_name,
                endpoint_override=service_catalog_url,
                retries=retries,
                http_log_debug=http_log_debug,
                api_version=self.api_version,
                user_agent=user_agent,
                timeout=timeout,
            )

            if not service_catalog_url:
                service_catalog_url = (
                    self.keystone_client.session.get_endpoint(
                        self.keystone_client.auth,
                        interface=endpoint_type,
                        service_type=service_type,
                        region_name=region_name,
                    )
                )
                if not service_catalog_url:
                    raise RuntimeError(
                        "Could not find Manila endpoint in catalog"
                    )
                self.keystone_client.endpoint_override = service_catalog_url

            self.client = self.keystone_client

        self.availability_zones = availability_zones.AvailabilityZoneManager(
            self
        )
        self.limits = limits.LimitsManager(self)
        self.transfers = share_transfers.ShareTransferManager(self)
        self.messages = messages.MessageManager(self)
        self.qos_types = qos_types.QosTypeManager(self)
        self.services = services.ServiceManager(self)
        self.security_services = security_services.SecurityServiceManager(self)
        self.share_networks = share_networks.ShareNetworkManager(self)
        self.share_network_subnets = (
            share_network_subnets.ShareNetworkSubnetManager(self)
        )

        self.quota_classes = quota_classes.QuotaClassSetManager(self)
        self.quotas = quotas.QuotaSetManager(self)

        self.resource_locks = resource_locks.ResourceLockManager(self)

        self.shares = shares.ShareManager(self)
        self.share_export_locations = (
            share_export_locations.ShareExportLocationManager(self)
        )
        self.share_groups = share_groups.ShareGroupManager(self)
        self.share_group_snapshots = (
            share_group_snapshots.ShareGroupSnapshotManager(self)
        )
        self.share_group_type_access = (
            share_group_type_access.ShareGroupTypeAccessManager(self)
        )
        self.share_group_types = share_group_types.ShareGroupTypeManager(self)
        self.share_instances = share_instances.ShareInstanceManager(self)
        self.share_instance_export_locations = (
            share_instance_export_locations.ShareInstanceExportLocationManager(
                self
            )
        )
        self.share_snapshots = share_snapshots.ShareSnapshotManager(self)
        self.share_snapshot_instances = (
            share_snapshot_instances.ShareSnapshotInstanceManager(self)
        )
        self.share_snapshot_export_locations = (
            share_snapshot_export_locations.ShareSnapshotExportLocationManager(
                self
            )
        )
        self.share_snapshot_instance_export_locations = share_snapshot_instance_export_locations.ShareSnapshotInstanceExportLocationManager(  # noqa: E501
            self
        )

        self.share_types = share_types.ShareTypeManager(self)
        self.share_type_access = share_type_access.ShareTypeAccessManager(self)
        self.share_servers = share_servers.ShareServerManager(self)
        self.share_replicas = share_replicas.ShareReplicaManager(self)
        self.share_replica_export_locations = (
            share_replica_export_locations.ShareReplicaExportLocationManager(
                self
            )
        )
        self.pools = scheduler_stats.PoolManager(self)
        self.share_access_rules = share_access_rules.ShareAccessRuleManager(
            self
        )
        self.share_backups = share_backups.ShareBackupManager(self)

        self._load_extensions(extensions)

    def _load_extensions(self, extensions):
        if not extensions:
            return

        for extension in extensions:
            if extension.manager_class:
                setattr(self, extension.name, extension.manager_class(self))

    def _get_keystone_auth_and_session(self):
        """Create keystoneauth1 auth plugin and session for authentication.

        Returns:
            tuple: (auth_plugin, session) for use with keystoneauth1
        """
        # Create session with SSL settings
        if self.insecure:
            verify = False
        else:
            verify = self.cacert or True
        ks_session = session.Session(verify=verify, cert=self.cert)

        # Discover Keystone v3 endpoint
        ks_discover = session.discover.Discover(ks_session, self.auth_url)
        auth_url = ks_discover.url_for('v3.0')
        if not auth_url:
            raise exceptions.CommandError(
                'Unable to determine the Keystone version to authenticate '
                'with using the given auth_url.'
            )

        # Create v3 Password auth plugin
        auth = identity.v3.Password(
            auth_url=auth_url,
            username=self.username,
            password=self.password,
            user_id=self.user_id,
            user_domain_name=self.user_domain_name,
            user_domain_id=self.user_domain_id,
            project_id=self.project_id or self.tenant_id,
            project_name=self.project_name,
            project_domain_name=self.project_domain_name,
            project_domain_id=self.project_domain_id,
        )

        return auth, ks_session
