# Copyright 2010 Jacob Kaplan-Moss
# Copyright 2011 OpenStack Foundation
# Copyright 2011 Piston Cloud Computing, Inc.
# Copyright 2015 Mirantis Inc.
#
# 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 copy
import logging
from urllib import parse

from oslo_serialization import jsonutils
from oslo_utils import importutils
from oslo_utils import strutils
import re
import requests

from manilaclient import exceptions

try:
    from eventlet import sleep
except ImportError:
    from time import sleep  # noqa

try:
    osprofiler_web = importutils.try_import("osprofiler.web")
except Exception:
    pass


class HTTPClient(object):
    """HTTP Client class used by multiple clients.

    The imported Requests module caches and reuses objects with the same
    destination. To avoid the problem of sending duplicate requests it is
    necessary that the Requests module is only imported once during client
    execution. This class is shared by multiple client versions so that the
    client can be changed to another version during execution.
    """
    API_VERSION_HEADER = "X-Openstack-Manila-Api-Version"

    def __init__(self, endpoint_url, token, user_agent, api_version,
                 insecure=False, cacert=None, timeout=None, retries=None,
                 http_log_debug=False, cert=None):
        self.endpoint_url = endpoint_url
        self.base_url = self._get_base_url(self.endpoint_url)
        self.retries = int(retries or 0)
        self.http_log_debug = http_log_debug

        self.request_options = self._set_request_options(
            insecure, cacert, timeout, cert)

        self.default_headers = {
            'X-Auth-Token': token,
            self.API_VERSION_HEADER: api_version.get_string(),
            'User-Agent': user_agent,
            'Accept': 'application/json',
        }

        self._add_log_handlers(http_log_debug)

    def _add_log_handlers(self, http_log_debug):
        self._logger = logging.getLogger(__name__)

        # check that handler hasn't already been added
        if http_log_debug and not self._logger.handlers:
            ch = logging.StreamHandler()
            ch._name = 'http_client_handler'
            self._logger.setLevel(logging.DEBUG)
            self._logger.addHandler(ch)

            if hasattr(requests, 'logging'):
                rql = requests.logging.getLogger(requests.__name__)
                rql.addHandler(ch)

    def _get_base_url(self, url):
        """Truncates url and returns base endpoint"""
        service_endpoint = parse.urlparse(url)
        service_endpoint_base_path = re.search(
            r'(.+?)/v([0-9]+|[0-9]+\.[0-9]+)(/.*|$)', service_endpoint.path)
        base_path = (service_endpoint_base_path.group(1)
                     if service_endpoint_base_path else '')
        base_url = service_endpoint._replace(path=base_path)
        return parse.urlunparse(base_url) + '/'

    def _set_request_options(self, insecure, cacert, timeout=None, cert=None):
        options = {'verify': True}

        if insecure:
            options['verify'] = False
        elif cacert:
            options['verify'] = cacert
        if cert:
            options['cert'] = cert

        if timeout:
            options['timeout'] = timeout

        return options

    def request(self, url, method, **kwargs):
        headers = copy.deepcopy(self.default_headers)
        headers.update(kwargs.get('headers', {}))

        options = copy.deepcopy(self.request_options)

        if osprofiler_web:
            headers.update(osprofiler_web.get_trace_id_headers())

        if 'body' in kwargs:
            headers['Content-Type'] = 'application/json'
            options['data'] = jsonutils.dumps(kwargs['body'])

        self.log_request(method, url, headers, options.get('data', None))
        resp = requests.request(method, url, headers=headers, **options)
        self.log_response(resp)

        body = None

        if resp.text:
            try:
                body = jsonutils.loads(resp.text)
            except ValueError:
                pass

        if resp.status_code >= 400:
            raise exceptions.from_response(resp, method, url)

        return resp, body

    def _cs_request(self, url, method, **kwargs):
        return self._cs_request_with_retries(
            self.endpoint_url + url,
            method,
            **kwargs)

    def _cs_request_base_url(self, url, method, **kwargs):
        return self._cs_request_with_retries(
            self.base_url + url,
            method,
            **kwargs)

    def _cs_request_with_retries(self, url, method, **kwargs):
        attempts = 0
        timeout = 1
        while True:
            attempts += 1
            try:
                resp, body = self.request(url, method, **kwargs)
                return resp, body
            except (exceptions.BadRequest,
                    requests.exceptions.RequestException,
                    exceptions.ClientException) as e:
                if attempts > self.retries:
                    raise

                self._logger.debug("Request error: %s", str(e))

            self._logger.debug(
                "Failed attempt(%(current)s of %(total)s), "
                " retrying in %(sec)s seconds", {
                    'current': attempts,
                    'total': self.retries,
                    'sec': timeout
                })
            sleep(timeout)
            timeout *= 2

    def get_with_base_url(self, url, **kwargs):
        return self._cs_request_base_url(url, 'GET', **kwargs)

    def get(self, url, **kwargs):
        return self._cs_request(url, 'GET', **kwargs)

    def post(self, url, **kwargs):
        return self._cs_request(url, 'POST', **kwargs)

    def put(self, url, **kwargs):
        return self._cs_request(url, 'PUT', **kwargs)

    def delete(self, url, **kwargs):
        return self._cs_request(url, 'DELETE', **kwargs)

    def log_request(self, method, url, headers, data=None):
        if not self.http_log_debug:
            return

        string_parts = ['curl -i', ' -X %s' % method, ' %s' % url]

        for element in headers:
            header = ' -H "%s: %s"' % (element, headers[element])
            string_parts.append(header)

        if data:
            if "password" in data:
                data = strutils.mask_password(data)
            string_parts.append(" -d '%s'" % data)
        self._logger.debug("\nREQ: %s\n", "".join(string_parts))

    def log_response(self, resp):
        if not self.http_log_debug:
            return
        self._logger.debug(
            "RESP: [%(code)s] %(headers)s\nRESP BODY: %(body)s\n", {
                'code': resp.status_code,
                'headers': resp.headers,
                'body': resp.text
            })
