# Copyright 2012 OpenStack Foundation
# 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.

import logging
import os

from keystoneauth1 import adapter
from keystoneauth1.identity import v3
from keystoneauth1 import session as ks_session
from oslo_utils import importutils
import requests

from adjutantclient._i18n import _
from adjutantclient import exc

LOG = logging.getLogger(__name__)
USER_AGENT = 'python-adjutantclient'
CHUNKSIZE = 1024 * 64  # 64kB
SENSITIVE_HEADERS = ('X-Auth-Token',)
osprofiler_web = importutils.try_import("osprofiler.web")


def get_response_body(resp):
    body = resp.content
    if 'application/json' in resp.headers.get('content-type', ''):
        try:
            body = resp.json()
        except ValueError:
            LOG.error('Could not decode response body as JSON')
    else:
        body = None
    return body


def get_system_ca_file():
    """Return path to system default CA file."""
    # Standard CA file locations for Debian/Ubuntu, RedHat/Fedora,
    # Suse, FreeBSD/OpenBSD, MacOSX, and the bundled ca
    ca_path = ['/etc/ssl/certs/ca-certificates.crt',
               '/etc/pki/tls/certs/ca-bundle.crt',
               '/etc/ssl/ca-bundle.pem',
               '/etc/ssl/cert.pem',
               '/System/Library/OpenSSL/certs/cacert.pem',
               requests.certs.where()]
    for ca in ca_path:
        LOG.debug("Looking for ca file %s", ca)
        if os.path.exists(ca):
            LOG.debug("Using ca file %s", ca)
            return ca
    LOG.warning("System ca file could not be found.")


class SessionClient(adapter.LegacyJsonAdapter):
    """HTTP client based on Keystone client session."""

    def request(self, url, method, **kwargs):
        redirect = kwargs.get('redirect')
        kwargs.setdefault('user_agent', USER_AGENT)

        if 'data' in kwargs:
            kwargs['json'] = kwargs.pop('data')

        resp, body = super(SessionClient, self).request(
            url, method,
            raise_exc=False,
            **kwargs)

        if 400 <= resp.status_code < 600:
            raise exc.from_response(resp)
        elif resp.status_code in (301, 302, 305):
            if redirect:
                location = resp.headers.get('location')
                path = self.strip_endpoint(location)
                resp = self.request(path, method, **kwargs)
        elif resp.status_code == 300:
            raise exc.from_response(resp)

        return resp

    def credentials_headers(self):
        return {}

    def strip_endpoint(self, location):
        if location is None:
            message = _("Location not returned with 302")
            raise exc.InvalidEndpoint(message=message)
        if (self.endpoint_override is not None and
                location.lower().startswith(self.endpoint_override.lower())):
            return location[len(self.endpoint_override):]
        else:
            return location


def _construct_http_client(endpoint=None, username=None, password=None,
                           include_pass=None, endpoint_type=None,
                           auth_url=None, **kwargs):
    session = kwargs.pop('session', None)
    auth = kwargs.pop('auth', None)

    if not session:
        if not auth and password:
            auth = v3.Password(auth_url=auth_url,
                               username=username,
                               password=password,
                               **kwargs)
            kwargs.pop('project_id', None)
            kwargs.pop('project_name', None)
            kwargs.pop('domain_id', None)
            kwargs.pop('domain_name', None)
            kwargs.pop('project_domain_id', None)
            kwargs.pop('project_domain_name', None)
            kwargs.pop('user_domain_id', None)
            kwargs.pop('user_domain_name', None)

        ca_path = kwargs.get('ca_file') or get_system_ca_file()
        session = ks_session.Session(auth=auth,
                                     verify=ca_path)

    if 'endpoint_override' not in kwargs and endpoint:
        kwargs['endpoint_override'] = endpoint

    if 'service_type' not in kwargs:
        kwargs['service_type'] = 'admin-logic'

    if 'interface' not in kwargs and endpoint_type:
        kwargs['interface'] = endpoint_type

    return SessionClient(session, auth=auth, **kwargs)