# Copyright (c) 2014 TrilioData, Inc.
# All Rights Reserved.

import logging
from workloadmgrclient.client import get_client_class, HTTPClient
from workloadmgrclient.v1 import testbubbles
from workloadmgrclient.v1 import workload_transfers as transfers
from workloadmgrclient.v1 import config_backup
from workloadmgrclient.v1.managers import (
    FileSearchManager,
    GlobalJobSchedulerManager,
    RestoreManager,
    SettingsManager,
    SnapshotManager,
    TrustManager,
    WorkloadManager,
    WorkloadPolicyManager,
    WorkloadTypeManager,
    ProjectQuotaTypeManager,
    AllowedQuotaManager,
)


LOG = logging.getLogger(__name__)


def make_client(instance):
    """Returns an Tvault' workloads manager client."""
    workloadmgr_client = get_client_class(version="1")
    LOG.debug("Instantiating workloadmgr client: %s", workloadmgr_client)
    instance.initialize()
    url = instance._auth_url
    url = url.rstrip("/")
    param_dict = {
        'username': instance._username,
        'password': instance._password,
        'auth_url': url,
        'project_id': instance._project_id,
        'region_name': instance._region_name,
        'endpoint_type': instance._endpoint_type,
        'cacert': instance._ca_cert,
        'domain_name': instance._os_domain_id,
        'user_domain_name': instance._user_domain_name,
        'os_user_domain_id': instance._os_user_domain_id,
        'insecure': getattr(instance, '_insecure', False),
    }
    if instance._project_domain_name:
        param_dict["project_domain_name"] = instance._project_domain_name
    else:
        param_dict["os_project_domain_id"] = instance._os_project_domain_id

    client = workloadmgr_client(**param_dict)
    return client


class Client(object):
    """
    Top-level object to access the OpenStack Workload API.

    Create an instance with your creds::

        >>> client = Client(USERNAME, PASSWORD, PROJECT_ID, AUTH_URL)

    Then call methods on its managers::

        >>> client.workloads.list()
        ...

    """

    def __init__(
        self,
        username,
        password,
        project_id=None,
        auth_url="",
        domain_name="default",
        os_user_domain_id=None,
        os_project_domain_id=None,
        insecure=False,
        timeout=None,
        tenant_id=None,
        proxy_tenant_id=None,
        proxy_token=None,
        region_name=None,
        endpoint_type="publicURL",
        extensions=None,
        service_type="workloads",
        service_name=None,
        retries=None,
        http_log_debug=False,
        cacert=None,
        user_domain_name=None,
        project_domain_name=None
    ):

        self.file_search = FileSearchManager(self)
        self.workloads = WorkloadManager(self)
        self.workload_types = WorkloadTypeManager(self)
        self.snapshots = SnapshotManager(self)
        self.restores = RestoreManager(self)
        self.testbubbles = testbubbles.TestbubblesManager(self)
        self.settings = SettingsManager(self)
        self.trusts = TrustManager(self)
        self.transfers = transfers.WorkloadmgrTransferManager(self)
        self.global_job_scheduler = GlobalJobSchedulerManager(self)
        self.config_backup = config_backup.ConfigBackupManager(self)
        self.workload_policy = WorkloadPolicyManager(self)
        self.project_quota_types = ProjectQuotaTypeManager(self)
        self.allowed_quotas = AllowedQuotaManager(self)

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

        self.client = HTTPClient(
            username,
            password,
            project_id,
            auth_url,
            domain_name=domain_name,
            os_user_domain_id=os_user_domain_id,
            os_project_domain_id=os_project_domain_id,
            insecure=insecure,
            timeout=timeout,
            tenant_id=tenant_id,
            proxy_token=proxy_token,
            proxy_tenant_id=proxy_tenant_id,
            region_name=region_name,
            endpoint_type=endpoint_type,
            service_type=service_type,
            service_name=service_name,
            retries=retries,
            http_log_debug=http_log_debug,
            cacert=cacert,
            user_domain_name=user_domain_name,
            project_domain_name=project_domain_name
        )

    def authenticate(self):
        """
        Authenticate against the server.

        Normally this is called automatically when you first access the API,
        but you can call this method to force authentication right now.

        Returns on success; raises :exc:`exceptions.Unauthorized` if the
        credentials are wrong.
        """
        self.client.authenticate()