# Copyright (c) 2014 Baidu.com, Inc. 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 provides a client class for peer connection.
"""

import copy
import json
import logging
import uuid

from baidubce import utils
from baidubce import bce_base_client
from baidubce.auth import bce_v1_signer
from baidubce.http import bce_http_client
from baidubce.http import handler
from baidubce.http import http_methods
from baidubce.services.vpc import peerconn_model
from baidubce.utils import required

_logger = logging.getLogger(__name__)


default_billing_to_purchase_created = peerconn_model.Billing('Postpaid')
default_billing_to_purchase_reserved = peerconn_model.Billing()


class PeerConnClient(bce_base_client.BceBaseClient):
    """
    Peer connection sdk client
    """
    version = b'/v1'
    prefix = b'/peerconn'

    def __init__(self, config=None):
        bce_base_client.BceBaseClient.__init__(self, config)

    def _merge_config(self, config=None):
        """
        :param config:
        :type config: baidubce.BceClientConfiguration
        :return:
        """
        if config is None:
            return self.config
        else:
            new_config = copy.copy(self.config)
            new_config.merge_non_none_values(config)
            return new_config

    def _send_request(self, http_method, path,
                      body=None, headers=None, params=None,
                      config=None, body_parser=None):
        config = self._merge_config(config)
        if body_parser is None:
            body_parser = handler.parse_json
        if headers is None:
            headers = {b'Accept': b'*/*',
                       b'Content-Type': b'application/json;charset=utf-8'}
        return bce_http_client.send_request(
            config, bce_v1_signer.sign, [handler.parse_error, body_parser],
            http_method, path, body, headers, params)

    @required(bandwidth_in_mbps=int,
              local_vpc_id=(bytes, str),
              peer_vpc_id=(bytes, str),
              peer_region=(bytes, str))
    def create_peerconn(self, bandwidth_in_mbps, local_vpc_id,
                        peer_vpc_id, peer_region, description=None,
                        local_if_name=None, peer_account_id=None,
                        peer_if_name=None, client_token=None,
                        billing=None, config=None, tags=None,
                        resourceGroupId=None, deleteProtect=False):
        """
        Create Peer connection.
        For peer connections within the same region, only postpaid is
        supported.
        For peer connections between different accounts, the peer connections
        are available only after the remote account accepts the connections.
        For peer connections within the same account, peer connection will be
        accepted automatically.
        There can be only one peer connection between any two VPCs.
        Peer connection endpoints cannot be the same VPC.
        If both local VPC and remote VPC are transit VPCs, peer connection
        cannot be established.

        :param client_token:
            An ASCII string whose length is less than 64.
            The request will be idempotent if client token is provided.
        :type client_token: string

        :param bandwidth_in_mbps:
            Network bandwidth (in unit of Mbps) of peer connection.
        :type bandwidth_in_mbps: int

        :param description:
            Description of peer connection.
        :type description: string

        :param local_if_name:
            Name of local interface of peer connection.
        :type local_if_name: string

        :param local_vpc_id:
            Local side VPC id of peer connection.
        :type local_vpc_id: string

        :param peer_account_id:
            Remote account id of peer connection.
            Used only when the peer connection connects two different accounts.
        :type peer_account_id: string

        :param peer_vpc_id:
            Remote side VPC id of peer connection.
        :type peer_vpc_id: string

        :param peer_region:
            Remote side region of peer connection.
        :type peer_region: string

        :param peer_if_name:
            Name of remote interface of peer connection.
        :type peer_if_name: string

        :param billing:
            Billing information.
        :type billing: nat_model.Billing

        :param config:
        :type config: baidubce.BceClientConfiguration

        :param tags:
            Tags of peer connection.
        :type tags: list[TagModel]

        :param resourceGroupId:
            Resource group ID of peer connection.
        :type resourceGroupId: string

        :param deleteProtect:
            Whether or not enable delete protection on this resource.
            Default false.
        :type deleteProtect: bool

        :return:
        :rtype baidubce.bce_response.BceResponse
        """
        path = self._get_path()
        if client_token is None:
            client_token = generate_client_token()
        params = {
            b'clientToken': client_token
        }
        if billing is None:
            billing = default_billing_to_purchase_created
        body = {
            'bandwidthInMbps': bandwidth_in_mbps,
            'localVpcId': local_vpc_id,
            'peerVpcId': peer_vpc_id,
            'peerRegion': peer_region,
            'billing': billing.__dict__,
            'deleteProtect': deleteProtect
        }
        if description is not None:
            body['description'] = description
        if local_if_name is not None:
            body['localIfName'] = local_if_name
        if peer_account_id is not None:
            body['peerAccountId'] = peer_account_id
        if peer_if_name is not None:
            body['peerIfName'] = peer_if_name
        if tags is not None:
            tag_list = [tag.__dict__ for tag in tags]
            body['tags'] = tag_list
        if resourceGroupId is not None:
            body['resourceGroupId'] = resourceGroupId
        return self._send_request(http_methods.POST,
                                  path, body=json.dumps(body),
                                  params=params, config=config)

    @required(vpc_id=(bytes, str))
    def list_peerconns(self, vpc_id, marker=None,
                       max_keys=None, config=None):
        """
        Return a list of peer connections.

        :param vpc_id:
            VPC id that peer connections connect to.
        :type vpc_id: string

        :param marker:
            The optional parameter marker specified in the original
            request to specify where in the results to begin listing.
            Together with the marker, specifies the list result which
            listing should begin. If the marker is not specified,
            the list result will listing from the first one.
        :type marker: string

        :param max_keys:
            The optional parameter to specifies the max number of
            list result to return.
            The default value is 1000.
        :type max_keys: int

        :param config:
        :type config: baidubce.BceClientConfiguration

        :return:
        :rtype baidubce.bce_response.BceResponse
        """
        path = self._get_path()
        params = {
            b'vpcId': vpc_id
        }
        if marker is not None:
            params[b'marker'] = marker
        if max_keys is not None:
            params[b'maxKeys'] = max_keys
        return self._send_request(http_methods.GET,
                                  path, params=params, config=config)

    @required(peer_conn_id=(bytes, str))
    def get_peerconn(self, peer_conn_id, role=None, config=None):
        """
        Get the detail information of specified peer connection.

        :param peer_conn_id:
            The id of specified peer connection.
        :type peer_conn_id: string

        :param role:
            The role of peer connection to query.
            'initiator': for VPC where peer connection is initiated.
            'acceptor': for VPC where peer connection is accepted.
        :type role: string

        :param config:
        :type config: baidubce.BceClientConfiguration

        :return:
        :rtype baidubce.bce_response.BceResponse
        """
        path = utils.append_uri(self._get_path(), peer_conn_id)
        params = None
        if role is not None:
            params = {b'role': role}
        return self._send_request(http_methods.GET, path, params=params, config=config)

    @required(peer_conn_id=(bytes, str), local_if_id=(bytes, str))
    def update_peerconn(self, peer_conn_id, local_if_id, description=None,
                        local_if_name=None, client_token=None, config=None):
        """
        Update the interface name or description of specified peer connection.

        :param peer_conn_id:
            The id of specified peer connection.
        :type peer_conn_id: string

        :param local_if_id:
            Local interface id of peer connection
        :type local_if_id: string

        :param description:
            Description of peer connection.
        :type description: string

        :param local_if_name:
            Name of local interface of peer connection.
        :type local_if_name: string

        :param client_token:
            An ASCII string whose length is less than 64.
            The request will be idempotent if clientToken is provided.
            If the clientToken is not specified by user,
            a random String generated by default algorithm will be used.
        :type client_token: string

        :param config:
        :type config: baidubce.BceClientConfiguration

        :return:
        :rtype baidubce.bce_response.BceResponse
        """
        path = utils.append_uri(self._get_path(), peer_conn_id)
        if client_token is None:
            client_token = generate_client_token()
        params = {
            b'clientToken': client_token
        }
        body = {
            'localIfId': local_if_id
        }
        if description is not None:
            body['description'] = description
        if local_if_name is not None:
            body['localIfName'] = local_if_name
        return self._send_request(http_methods.PUT,
                                  path, body=json.dumps(body),
                                  params=params, config=config)

    @required(peer_conn_id=(bytes, str), action=(bytes, str))
    def handle_peerconn(self, peer_conn_id, action, client_token=None,
                        config=None):
        """
        Accept or reject peer connection request.
        Timeout period of connection request is 7 days.
        When timeout or the remote side rejects the connection,
        the status of peer connection on initiator side is consulting failed.

        :param peer_conn_id:
            The id of specified peer connection.
        :type peer_conn_id: string

        :param action:
            'accept': when accepting the peer connection.
            'reject': when rejecting the peer connection.
        :type action: string

        :param client_token:
            An ASCII string whose length is less than 64.
            The request will be idempotent if clientToken is provided.
            If the clientToken is not specified by user,
            a random String generated by default algorithm will be used.
        :type client_token: string

        :param config:
        :type config: baidubce.BceClientConfiguration

        :return:
        :rtype baidubce.bce_response.BceResponse
        """
        path = utils.append_uri(self._get_path(), peer_conn_id)
        if client_token is None:
            client_token = generate_client_token()
        params = {
            b'clientToken': client_token
        }
        params[action] = None
        return self._send_request(http_methods.PUT,
                                  path, params=params, config=config)

    @required(peer_conn_id=(bytes, str))
    def delete_peerconn(self, peer_conn_id, client_token=None,
                        config=None):
        """
        Delete peer connection.
        For peer connections between different accounts,
        only initiator can perform this operation.
        One cannot delete prepaid peer connections that are not expired.
        Consulting failed prepaid peer connections can be deleted.

        :param peer_conn_id:
            The id of specified peer connection.
        :type peer_conn_id: string

        :param client_token:
            An ASCII string whose length is less than 64.
            The request will be idempotent if clientToken is provided.
            If the clientToken is not specified by user,
            a random String generated by default algorithm will be used.
        :type client_token: string

        :param config:
        :type config: baidubce.BceClientConfiguration

        :return:
        :rtype baidubce.bce_response.BceResponse
        """
        path = utils.append_uri(self._get_path(), peer_conn_id)
        if client_token is None:
            client_token = generate_client_token()
        params = {
            b'clientToken': client_token
        }
        return self._send_request(http_methods.DELETE,
                                  path, params=params, config=config)

    @required(peer_conn_id=(bytes, str), new_bandwidth_in_mbps=int)
    def resize_peerconn(self, peer_conn_id, new_bandwidth_in_mbps,
                        client_token=None, config=None):
        """
        Scale down/up the bandwidth of specified peer connection.
        For peer connections between different accounts,
        only initiator can perform this operation.
        Prepaid peer connection can only scale up.
        Postpaid peer connection can scale up or down.

        :param peer_conn_id:
            The id of specified peer connection.
        :type peer_conn_id: string

        :param client_token:
            An ASCII string whose length is less than 64.
            The request will be idempotent if clientToken is provided.
            If the clientToken is not specified by user,
            a random String generated by default algorithm will be used.
        :type client_token: string

        :param new_bandwidth_in_mbps:
            The new bandwidth of the peer connection.
        :type new_bandwidth_in_mbps: int

        :param config:
        :type config: baidubce.BceClientConfiguration

        :return:
        :rtype baidubce.bce_response.BceResponse
        """
        path = utils.append_uri(self._get_path(), peer_conn_id)
        if client_token is None:
            client_token = generate_client_token()
        params = {
            b'resize': None,
            b'clientToken': client_token
        }
        body = {
            'newBandwidthInMbps': new_bandwidth_in_mbps
        }
        return self._send_request(http_methods.PUT,
                                  path, body=json.dumps(body),
                                  params=params, config=config)

    @required(peer_conn_id=(bytes, str))
    def purchase_reserved_peerconn(self, peer_conn_id, client_token=None,
                                   billing=None, config=None):
        """
        Renew specified peer connection.
        Postpaid peer connection cannot be renewed.
        For peer connections between different accounts, only the initiator can
        perform this operation.

        :param peer_conn_id:
            The id of specified peer connection.
        :type peer_conn_id: string

        :param client_token:
            An ASCII string whose length is less than 64.
            The request will be idempotent if clientToken is provided.
            If the clientToken is not specified by user,
            a random String generated by default algorithm will be used.
        :type client_token: string

        :param billing:
            Billing information.
        :type billing: peerconn_model.Billing

        :param config:
        :type config: baidubce.BceClientConfiguration

        :return:
        :rtype baidubce.bce_response.BceResponse
        """
        path = utils.append_uri(self._get_path(), peer_conn_id)
        if client_token is None:
            client_token = generate_client_token()
        params = {
            b'purchaseReserved': None,
            b'clientToken': client_token
        }
        if billing is None:
            billing = default_billing_to_purchase_reserved
        body = {
            'billing': billing.__dict__
        }
        return self._send_request(http_methods.PUT,
                                  path, body=json.dumps(body),
                                  params=params, config=config)

    @required(peer_conn_id=(bytes, str), role=(bytes, str))
    def open_peerconn_dns_sync(self, peer_conn_id, role,
                               client_token=None, config=None):
        """
        Open DNS sync between VPCs connected by peer connection.
        DNS sync can be opened only when the status of
        peer connection is available.
        DNS sync cannot be opened when the DNS status of
        peer connection is syncing or closing.

        :param peer_conn_id:
            The id of specified peer connection.
        :type peer_conn_id: string

        :param role:
            'initiator': for VPC where peer connection is initiated.
            'acceptor': for VPC where peer connection is accepted.
        :type role: string

        :param client_token:
            An ASCII string whose length is less than 64.
            The request will be idempotent if clientToken is provided.
            If the clientToken is not specified by user,
            a random String generated by default algorithm will be used.
        :type client_token: string

        :param config:
        :type config: baidubce.BceClientConfiguration

        :return:
        :rtype baidubce.bce_response.BceResponse
        """
        path = utils.append_uri(self._get_path(), peer_conn_id)
        if client_token is None:
            client_token = generate_client_token()
        params = {
            b'open': None,
            b'role': role,
            b'clientToken': client_token
        }
        return self._send_request(http_methods.PUT,
                                  path, params=params, config=config)

    @required(peer_conn_id=(bytes, str), role=(bytes, str))
    def close_peerconn_dns_sync(self, peer_conn_id, role,
                                client_token=None, config=None):
        """
        Close DNS sync between VPCs connected by peer connection.
        DNS sync can be closed only when the status of peer connection
        is available. DNS sync cannot be closed when the DNS status
        of peer connection is syncing or closing.

        :param peer_conn_id:
            The id of specified peer connection.
        :type peer_conn_id: string

        :param role:
            'initiator': for VPC where peer connection is initiated.
            'acceptor': for VPC where peer connection is accepted.
        :type role: string

        :param client_token:
            An ASCII string whose length is less than 64.
            The request will be idempotent if clientToken is provided.
            If the clientToken is not specified by user,
            a random String generated by default algorithm will be used.
        :type client_token: string

        :param config:
        :type config: baidubce.BceClientConfiguration

        :return:
        :rtype baidubce.bce_response.BceResponse
        """
        path = utils.append_uri(self._get_path(), peer_conn_id)
        if client_token is None:
            client_token = generate_client_token()
        params = {
            b'close': None,
            b'role': role,
            b'clientToken': client_token
        }
        return self._send_request(http_methods.PUT,
                                  path, params=params, config=config)

    @required(peer_conn_id=(bytes, str), delete_protect=(bool,))
    def update_peerconn_delete_protect(self, peer_conn_id, delete_protect,
                                       client_token=None, config=None):
        """
        Update the delete protect of peer connection.

        :param peer_conn_id:
            The id of specified peer connection.
        :type peer_conn_id: string

        :param delete_protect:
            Whether enable the delete protect of peer connection.
        :type delete_protect: boolean

        :param client_token:
            An ASCII string whose length is less than 64.
            The request will be idempotent if clientToken is provided.
            If the clientToken is not specified by user,
            a random String generated by default algorithm will be used.
        :type client_token: string

        :param config:
        :type config: baidubce.BceClientConfiguration

        :return:
        :rtype baidubce.bce_response.BceResponse
        """
        path = utils.append_uri(self._get_path(), peer_conn_id, b'deleteProtect')
        if client_token is None:
            client_token = generate_client_token()
        params = {
            b'clientToken': client_token
        }
        body = {
            'deleteProtect': delete_protect,
        }
        return self._send_request(http_methods.PUT,
                                  path, body=json.dumps(body), params=params, config=config)

    @required(peer_conn_id=(bytes, str))
    def refund_peerconn(self, peer_conn_id, client_token=None, config=None):
        """
        Refund prepaid peer connection (unsubscribe).
        Only prepaid peer connections can be refunded.
        For peer connections between different accounts,
        only the initiator can perform this operation.

        :param peer_conn_id:
            The id of specified peer connection.
        :type peer_conn_id: string

        :param client_token:
            An ASCII string whose length is less than 64.
            The request will be idempotent if clientToken is provided.
            If the clientToken is not specified by user,
            a random String generated by default algorithm will be used.
        :type client_token: string

        :param config:
        :type config: baidubce.BceClientConfiguration

        :return:
        :rtype baidubce.bce_response.BceResponse
        """
        path = utils.append_uri(self._get_path(), peer_conn_id)
        if client_token is None:
            client_token = generate_client_token()
        params = {
            b'refund': None,
            b'clientToken': client_token
        }
        return self._send_request(http_methods.PUT,
                                  path, params=params, config=config)

    @staticmethod
    def _get_path(prefix=None):
        """
        :type prefix: string
        :param prefix: path prefix
        """
        if prefix is None:
            prefix = PeerConnClient.prefix
        return utils.append_uri(PeerConnClient.version, prefix)


def generate_client_token_by_uuid():
    """
    The default method to generate the random string for client_token
    if the optional parameter client_token is not specified by the user.

    :return:
    :rtype string
    """
    return str(uuid.uuid4())


generate_client_token = generate_client_token_by_uuid
