# Copyright 2016 gRPC authors.
#
# 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.
"""Translates gRPC's client-side API into gRPC's client-side Beta API."""

import grpc
from grpc import _common
from grpc.beta import _metadata
from grpc.beta import interfaces
from grpc.framework.common import cardinality
from grpc.framework.foundation import future
from grpc.framework.interfaces.face import face

# pylint: disable=too-many-arguments,too-many-locals,unused-argument

_STATUS_CODE_TO_ABORTION_KIND_AND_ABORTION_ERROR_CLASS = {
    grpc.StatusCode.CANCELLED: (
        face.Abortion.Kind.CANCELLED,
        face.CancellationError,
    ),
    grpc.StatusCode.UNKNOWN: (
        face.Abortion.Kind.REMOTE_FAILURE,
        face.RemoteError,
    ),
    grpc.StatusCode.DEADLINE_EXCEEDED: (
        face.Abortion.Kind.EXPIRED,
        face.ExpirationError,
    ),
    grpc.StatusCode.UNIMPLEMENTED: (
        face.Abortion.Kind.LOCAL_FAILURE,
        face.LocalError,
    ),
}


def _effective_metadata(metadata, metadata_transformer):
    non_none_metadata = () if metadata is None else metadata
    if metadata_transformer is None:
        return non_none_metadata
    else:
        return metadata_transformer(non_none_metadata)


def _credentials(grpc_call_options):
    return None if grpc_call_options is None else grpc_call_options.credentials


def _abortion(rpc_error_call):
    code = rpc_error_call.code()
    pair = _STATUS_CODE_TO_ABORTION_KIND_AND_ABORTION_ERROR_CLASS.get(code)
    error_kind = face.Abortion.Kind.LOCAL_FAILURE if pair is None else pair[0]
    return face.Abortion(
        error_kind,
        rpc_error_call.initial_metadata(),
        rpc_error_call.trailing_metadata(),
        code,
        rpc_error_call.details(),
    )


def _abortion_error(rpc_error_call):
    code = rpc_error_call.code()
    pair = _STATUS_CODE_TO_ABORTION_KIND_AND_ABORTION_ERROR_CLASS.get(code)
    exception_class = face.AbortionError if pair is None else pair[1]
    return exception_class(
        rpc_error_call.initial_metadata(),
        rpc_error_call.trailing_metadata(),
        code,
        rpc_error_call.details(),
    )


class _InvocationProtocolContext(interfaces.GRPCInvocationContext):
    def disable_next_request_compression(self):
        pass  # TODO(https://github.com/grpc/grpc/issues/4078): design, implement.


class _Rendezvous(future.Future, face.Call):
    def __init__(self, response_future, response_iterator, call):
        self._future = response_future
        self._iterator = response_iterator
        self._call = call

    def cancel(self):
        return self._call.cancel()

    def cancelled(self):
        return self._future.cancelled()

    def running(self):
        return self._future.running()

    def done(self):
        return self._future.done()

    def result(self, timeout=None):
        try:
            return self._future.result(timeout=timeout)
        except grpc.RpcError as rpc_error_call:
            raise _abortion_error(rpc_error_call)
        except grpc.FutureTimeoutError:
            raise future.TimeoutError()
        except grpc.FutureCancelledError:
            raise future.CancelledError()

    def exception(self, timeout=None):
        try:
            rpc_error_call = self._future.exception(timeout=timeout)
            if rpc_error_call is None:
                return None
            else:
                return _abortion_error(rpc_error_call)
        except grpc.FutureTimeoutError:
            raise future.TimeoutError()
        except grpc.FutureCancelledError:
            raise future.CancelledError()

    def traceback(self, timeout=None):
        try:
            return self._future.traceback(timeout=timeout)
        except grpc.FutureTimeoutError:
            raise future.TimeoutError()
        except grpc.FutureCancelledError:
            raise future.CancelledError()

    def add_done_callback(self, fn):
        self._future.add_done_callback(lambda ignored_callback: fn(self))

    def __iter__(self):
        return self

    def _next(self):
        try:
            return next(self._iterator)
        except grpc.RpcError as rpc_error_call:
            raise _abortion_error(rpc_error_call)

    def __next__(self):
        return self._next()

    def next(self):
        return self._next()

    def is_active(self):
        return self._call.is_active()

    def time_remaining(self):
        return self._call.time_remaining()

    def add_abortion_callback(self, abortion_callback):
        def done_callback():
            if self.code() is not grpc.StatusCode.OK:
                abortion_callback(_abortion(self._call))

        registered = self._call.add_callback(done_callback)
        return None if registered else done_callback()

    def protocol_context(self):
        return _InvocationProtocolContext()

    def initial_metadata(self):
        return _metadata.beta(self._call.initial_metadata())

    def terminal_metadata(self):
        return _metadata.beta(self._call.terminal_metadata())

    def code(self):
        return self._call.code()

    def details(self):
        return self._call.details()


def _blocking_unary_unary(
    channel,
    group,
    method,
    timeout,
    with_call,
    protocol_options,
    metadata,
    metadata_transformer,
    request,
    request_serializer,
    response_deserializer,
):
    try:
        multi_callable = channel.unary_unary(
            _common.fully_qualified_method(group, method),
            request_serializer=request_serializer,
            response_deserializer=response_deserializer,
        )
        effective_metadata = _effective_metadata(metadata, metadata_transformer)
        if with_call:
            response, call = multi_callable.with_call(
                request,
                timeout=timeout,
                metadata=_metadata.unbeta(effective_metadata),
                credentials=_credentials(protocol_options),
            )
            return response, _Rendezvous(None, None, call)
        else:
            return multi_callable(
                request,
                timeout=timeout,
                metadata=_metadata.unbeta(effective_metadata),
                credentials=_credentials(protocol_options),
            )
    except grpc.RpcError as rpc_error_call:
        raise _abortion_error(rpc_error_call)


def _future_unary_unary(
    channel,
    group,
    method,
    timeout,
    protocol_options,
    metadata,
    metadata_transformer,
    request,
    request_serializer,
    response_deserializer,
):
    multi_callable = channel.unary_unary(
        _common.fully_qualified_method(group, method),
        request_serializer=request_serializer,
        response_deserializer=response_deserializer,
    )
    effective_metadata = _effective_metadata(metadata, metadata_transformer)
    response_future = multi_callable.future(
        request,
        timeout=timeout,
        metadata=_metadata.unbeta(effective_metadata),
        credentials=_credentials(protocol_options),
    )
    return _Rendezvous(response_future, None, response_future)


def _unary_stream(
    channel,
    group,
    method,
    timeout,
    protocol_options,
    metadata,
    metadata_transformer,
    request,
    request_serializer,
    response_deserializer,
):
    multi_callable = channel.unary_stream(
        _common.fully_qualified_method(group, method),
        request_serializer=request_serializer,
        response_deserializer=response_deserializer,
    )
    effective_metadata = _effective_metadata(metadata, metadata_transformer)
    response_iterator = multi_callable(
        request,
        timeout=timeout,
        metadata=_metadata.unbeta(effective_metadata),
        credentials=_credentials(protocol_options),
    )
    return _Rendezvous(None, response_iterator, response_iterator)


def _blocking_stream_unary(
    channel,
    group,
    method,
    timeout,
    with_call,
    protocol_options,
    metadata,
    metadata_transformer,
    request_iterator,
    request_serializer,
    response_deserializer,
):
    try:
        multi_callable = channel.stream_unary(
            _common.fully_qualified_method(group, method),
            request_serializer=request_serializer,
            response_deserializer=response_deserializer,
        )
        effective_metadata = _effective_metadata(metadata, metadata_transformer)
        if with_call:
            response, call = multi_callable.with_call(
                request_iterator,
                timeout=timeout,
                metadata=_metadata.unbeta(effective_metadata),
                credentials=_credentials(protocol_options),
            )
            return response, _Rendezvous(None, None, call)
        else:
            return multi_callable(
                request_iterator,
                timeout=timeout,
                metadata=_metadata.unbeta(effective_metadata),
                credentials=_credentials(protocol_options),
            )
    except grpc.RpcError as rpc_error_call:
        raise _abortion_error(rpc_error_call)


def _future_stream_unary(
    channel,
    group,
    method,
    timeout,
    protocol_options,
    metadata,
    metadata_transformer,
    request_iterator,
    request_serializer,
    response_deserializer,
):
    multi_callable = channel.stream_unary(
        _common.fully_qualified_method(group, method),
        request_serializer=request_serializer,
        response_deserializer=response_deserializer,
    )
    effective_metadata = _effective_metadata(metadata, metadata_transformer)
    response_future = multi_callable.future(
        request_iterator,
        timeout=timeout,
        metadata=_metadata.unbeta(effective_metadata),
        credentials=_credentials(protocol_options),
    )
    return _Rendezvous(response_future, None, response_future)


def _stream_stream(
    channel,
    group,
    method,
    timeout,
    protocol_options,
    metadata,
    metadata_transformer,
    request_iterator,
    request_serializer,
    response_deserializer,
):
    multi_callable = channel.stream_stream(
        _common.fully_qualified_method(group, method),
        request_serializer=request_serializer,
        response_deserializer=response_deserializer,
    )
    effective_metadata = _effective_metadata(metadata, metadata_transformer)
    response_iterator = multi_callable(
        request_iterator,
        timeout=timeout,
        metadata=_metadata.unbeta(effective_metadata),
        credentials=_credentials(protocol_options),
    )
    return _Rendezvous(None, response_iterator, response_iterator)


class _UnaryUnaryMultiCallable(face.UnaryUnaryMultiCallable):
    def __init__(
        self,
        channel,
        group,
        method,
        metadata_transformer,
        request_serializer,
        response_deserializer,
    ):
        self._channel = channel
        self._group = group
        self._method = method
        self._metadata_transformer = metadata_transformer
        self._request_serializer = request_serializer
        self._response_deserializer = response_deserializer

    def __call__(
        self,
        request,
        timeout,
        metadata=None,
        with_call=False,
        protocol_options=None,
    ):
        return _blocking_unary_unary(
            self._channel,
            self._group,
            self._method,
            timeout,
            with_call,
            protocol_options,
            metadata,
            self._metadata_transformer,
            request,
            self._request_serializer,
            self._response_deserializer,
        )

    def future(self, request, timeout, metadata=None, protocol_options=None):
        return _future_unary_unary(
            self._channel,
            self._group,
            self._method,
            timeout,
            protocol_options,
            metadata,
            self._metadata_transformer,
            request,
            self._request_serializer,
            self._response_deserializer,
        )

    def event(
        self,
        request,
        receiver,
        abortion_callback,
        timeout,
        metadata=None,
        protocol_options=None,
    ):
        raise NotImplementedError()


class _UnaryStreamMultiCallable(face.UnaryStreamMultiCallable):
    def __init__(
        self,
        channel,
        group,
        method,
        metadata_transformer,
        request_serializer,
        response_deserializer,
    ):
        self._channel = channel
        self._group = group
        self._method = method
        self._metadata_transformer = metadata_transformer
        self._request_serializer = request_serializer
        self._response_deserializer = response_deserializer

    def __call__(self, request, timeout, metadata=None, protocol_options=None):
        return _unary_stream(
            self._channel,
            self._group,
            self._method,
            timeout,
            protocol_options,
            metadata,
            self._metadata_transformer,
            request,
            self._request_serializer,
            self._response_deserializer,
        )

    def event(
        self,
        request,
        receiver,
        abortion_callback,
        timeout,
        metadata=None,
        protocol_options=None,
    ):
        raise NotImplementedError()


class _StreamUnaryMultiCallable(face.StreamUnaryMultiCallable):
    def __init__(
        self,
        channel,
        group,
        method,
        metadata_transformer,
        request_serializer,
        response_deserializer,
    ):
        self._channel = channel
        self._group = group
        self._method = method
        self._metadata_transformer = metadata_transformer
        self._request_serializer = request_serializer
        self._response_deserializer = response_deserializer

    def __call__(
        self,
        request_iterator,
        timeout,
        metadata=None,
        with_call=False,
        protocol_options=None,
    ):
        return _blocking_stream_unary(
            self._channel,
            self._group,
            self._method,
            timeout,
            with_call,
            protocol_options,
            metadata,
            self._metadata_transformer,
            request_iterator,
            self._request_serializer,
            self._response_deserializer,
        )

    def future(
        self, request_iterator, timeout, metadata=None, protocol_options=None
    ):
        return _future_stream_unary(
            self._channel,
            self._group,
            self._method,
            timeout,
            protocol_options,
            metadata,
            self._metadata_transformer,
            request_iterator,
            self._request_serializer,
            self._response_deserializer,
        )

    def event(
        self,
        receiver,
        abortion_callback,
        timeout,
        metadata=None,
        protocol_options=None,
    ):
        raise NotImplementedError()


class _StreamStreamMultiCallable(face.StreamStreamMultiCallable):
    def __init__(
        self,
        channel,
        group,
        method,
        metadata_transformer,
        request_serializer,
        response_deserializer,
    ):
        self._channel = channel
        self._group = group
        self._method = method
        self._metadata_transformer = metadata_transformer
        self._request_serializer = request_serializer
        self._response_deserializer = response_deserializer

    def __call__(
        self, request_iterator, timeout, metadata=None, protocol_options=None
    ):
        return _stream_stream(
            self._channel,
            self._group,
            self._method,
            timeout,
            protocol_options,
            metadata,
            self._metadata_transformer,
            request_iterator,
            self._request_serializer,
            self._response_deserializer,
        )

    def event(
        self,
        receiver,
        abortion_callback,
        timeout,
        metadata=None,
        protocol_options=None,
    ):
        raise NotImplementedError()


class _GenericStub(face.GenericStub):
    def __init__(
        self,
        channel,
        metadata_transformer,
        request_serializers,
        response_deserializers,
    ):
        self._channel = channel
        self._metadata_transformer = metadata_transformer
        self._request_serializers = request_serializers or {}
        self._response_deserializers = response_deserializers or {}

    def blocking_unary_unary(
        self,
        group,
        method,
        request,
        timeout,
        metadata=None,
        with_call=None,
        protocol_options=None,
    ):
        request_serializer = self._request_serializers.get(
            (
                group,
                method,
            )
        )
        response_deserializer = self._response_deserializers.get(
            (
                group,
                method,
            )
        )
        return _blocking_unary_unary(
            self._channel,
            group,
            method,
            timeout,
            with_call,
            protocol_options,
            metadata,
            self._metadata_transformer,
            request,
            request_serializer,
            response_deserializer,
        )

    def future_unary_unary(
        self,
        group,
        method,
        request,
        timeout,
        metadata=None,
        protocol_options=None,
    ):
        request_serializer = self._request_serializers.get(
            (
                group,
                method,
            )
        )
        response_deserializer = self._response_deserializers.get(
            (
                group,
                method,
            )
        )
        return _future_unary_unary(
            self._channel,
            group,
            method,
            timeout,
            protocol_options,
            metadata,
            self._metadata_transformer,
            request,
            request_serializer,
            response_deserializer,
        )

    def inline_unary_stream(
        self,
        group,
        method,
        request,
        timeout,
        metadata=None,
        protocol_options=None,
    ):
        request_serializer = self._request_serializers.get(
            (
                group,
                method,
            )
        )
        response_deserializer = self._response_deserializers.get(
            (
                group,
                method,
            )
        )
        return _unary_stream(
            self._channel,
            group,
            method,
            timeout,
            protocol_options,
            metadata,
            self._metadata_transformer,
            request,
            request_serializer,
            response_deserializer,
        )

    def blocking_stream_unary(
        self,
        group,
        method,
        request_iterator,
        timeout,
        metadata=None,
        with_call=None,
        protocol_options=None,
    ):
        request_serializer = self._request_serializers.get(
            (
                group,
                method,
            )
        )
        response_deserializer = self._response_deserializers.get(
            (
                group,
                method,
            )
        )
        return _blocking_stream_unary(
            self._channel,
            group,
            method,
            timeout,
            with_call,
            protocol_options,
            metadata,
            self._metadata_transformer,
            request_iterator,
            request_serializer,
            response_deserializer,
        )

    def future_stream_unary(
        self,
        group,
        method,
        request_iterator,
        timeout,
        metadata=None,
        protocol_options=None,
    ):
        request_serializer = self._request_serializers.get(
            (
                group,
                method,
            )
        )
        response_deserializer = self._response_deserializers.get(
            (
                group,
                method,
            )
        )
        return _future_stream_unary(
            self._channel,
            group,
            method,
            timeout,
            protocol_options,
            metadata,
            self._metadata_transformer,
            request_iterator,
            request_serializer,
            response_deserializer,
        )

    def inline_stream_stream(
        self,
        group,
        method,
        request_iterator,
        timeout,
        metadata=None,
        protocol_options=None,
    ):
        request_serializer = self._request_serializers.get(
            (
                group,
                method,
            )
        )
        response_deserializer = self._response_deserializers.get(
            (
                group,
                method,
            )
        )
        return _stream_stream(
            self._channel,
            group,
            method,
            timeout,
            protocol_options,
            metadata,
            self._metadata_transformer,
            request_iterator,
            request_serializer,
            response_deserializer,
        )

    def event_unary_unary(
        self,
        group,
        method,
        request,
        receiver,
        abortion_callback,
        timeout,
        metadata=None,
        protocol_options=None,
    ):
        raise NotImplementedError()

    def event_unary_stream(
        self,
        group,
        method,
        request,
        receiver,
        abortion_callback,
        timeout,
        metadata=None,
        protocol_options=None,
    ):
        raise NotImplementedError()

    def event_stream_unary(
        self,
        group,
        method,
        receiver,
        abortion_callback,
        timeout,
        metadata=None,
        protocol_options=None,
    ):
        raise NotImplementedError()

    def event_stream_stream(
        self,
        group,
        method,
        receiver,
        abortion_callback,
        timeout,
        metadata=None,
        protocol_options=None,
    ):
        raise NotImplementedError()

    def unary_unary(self, group, method):
        request_serializer = self._request_serializers.get(
            (
                group,
                method,
            )
        )
        response_deserializer = self._response_deserializers.get(
            (
                group,
                method,
            )
        )
        return _UnaryUnaryMultiCallable(
            self._channel,
            group,
            method,
            self._metadata_transformer,
            request_serializer,
            response_deserializer,
        )

    def unary_stream(self, group, method):
        request_serializer = self._request_serializers.get(
            (
                group,
                method,
            )
        )
        response_deserializer = self._response_deserializers.get(
            (
                group,
                method,
            )
        )
        return _UnaryStreamMultiCallable(
            self._channel,
            group,
            method,
            self._metadata_transformer,
            request_serializer,
            response_deserializer,
        )

    def stream_unary(self, group, method):
        request_serializer = self._request_serializers.get(
            (
                group,
                method,
            )
        )
        response_deserializer = self._response_deserializers.get(
            (
                group,
                method,
            )
        )
        return _StreamUnaryMultiCallable(
            self._channel,
            group,
            method,
            self._metadata_transformer,
            request_serializer,
            response_deserializer,
        )

    def stream_stream(self, group, method):
        request_serializer = self._request_serializers.get(
            (
                group,
                method,
            )
        )
        response_deserializer = self._response_deserializers.get(
            (
                group,
                method,
            )
        )
        return _StreamStreamMultiCallable(
            self._channel,
            group,
            method,
            self._metadata_transformer,
            request_serializer,
            response_deserializer,
        )

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        return False


class _DynamicStub(face.DynamicStub):
    def __init__(self, backing_generic_stub, group, cardinalities):
        self._generic_stub = backing_generic_stub
        self._group = group
        self._cardinalities = cardinalities

    def __getattr__(self, attr):
        method_cardinality = self._cardinalities.get(attr)
        if method_cardinality is cardinality.Cardinality.UNARY_UNARY:
            return self._generic_stub.unary_unary(self._group, attr)
        elif method_cardinality is cardinality.Cardinality.UNARY_STREAM:
            return self._generic_stub.unary_stream(self._group, attr)
        elif method_cardinality is cardinality.Cardinality.STREAM_UNARY:
            return self._generic_stub.stream_unary(self._group, attr)
        elif method_cardinality is cardinality.Cardinality.STREAM_STREAM:
            return self._generic_stub.stream_stream(self._group, attr)
        else:
            raise AttributeError(
                '_DynamicStub object has no attribute "%s"!' % attr
            )

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        return False


def generic_stub(
    channel,
    host,
    metadata_transformer,
    request_serializers,
    response_deserializers,
):
    return _GenericStub(
        channel,
        metadata_transformer,
        request_serializers,
        response_deserializers,
    )


def dynamic_stub(
    channel,
    service,
    cardinalities,
    host,
    metadata_transformer,
    request_serializers,
    response_deserializers,
):
    return _DynamicStub(
        _GenericStub(
            channel,
            metadata_transformer,
            request_serializers,
            response_deserializers,
        ),
        service,
        cardinalities,
    )