# Copyright 2017 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.

import threading

import grpc_testing
from grpc_testing import _common
from grpc_testing._server import _handler
from grpc_testing._server import _rpc
from grpc_testing._server import _server_rpc
from grpc_testing._server import _service
from grpc_testing._server import _servicer_context


def _implementation(descriptors_to_servicers, method_descriptor):
    servicer = descriptors_to_servicers[method_descriptor.containing_service]
    return getattr(servicer, method_descriptor.name)


def _unary_unary_service(request):
    def service(implementation, rpc, servicer_context):
        _service.unary_unary(implementation, rpc, request, servicer_context)

    return service


def _unary_stream_service(request):
    def service(implementation, rpc, servicer_context):
        _service.unary_stream(implementation, rpc, request, servicer_context)

    return service


def _stream_unary_service(handler):
    def service(implementation, rpc, servicer_context):
        _service.stream_unary(implementation, rpc, handler, servicer_context)

    return service


def _stream_stream_service(handler):
    def service(implementation, rpc, servicer_context):
        _service.stream_stream(implementation, rpc, handler, servicer_context)

    return service


class _Serverish(_common.Serverish):
    def __init__(self, descriptors_to_servicers, time):
        self._descriptors_to_servicers = descriptors_to_servicers
        self._time = time

    def _invoke(
        self,
        service_behavior,
        method_descriptor,
        handler,
        invocation_metadata,
        deadline,
    ):
        implementation = _implementation(
            self._descriptors_to_servicers, method_descriptor
        )
        rpc = _rpc.Rpc(handler, invocation_metadata)
        if handler.add_termination_callback(rpc.extrinsic_abort):
            servicer_context = _servicer_context.ServicerContext(
                rpc, self._time, deadline
            )
            service_thread = threading.Thread(
                target=service_behavior,
                args=(
                    implementation,
                    rpc,
                    servicer_context,
                ),
            )
            service_thread.start()

    def invoke_unary_unary(
        self, method_descriptor, handler, invocation_metadata, request, deadline
    ):
        self._invoke(
            _unary_unary_service(request),
            method_descriptor,
            handler,
            invocation_metadata,
            deadline,
        )

    def invoke_unary_stream(
        self, method_descriptor, handler, invocation_metadata, request, deadline
    ):
        self._invoke(
            _unary_stream_service(request),
            method_descriptor,
            handler,
            invocation_metadata,
            deadline,
        )

    def invoke_stream_unary(
        self, method_descriptor, handler, invocation_metadata, deadline
    ):
        self._invoke(
            _stream_unary_service(handler),
            method_descriptor,
            handler,
            invocation_metadata,
            deadline,
        )

    def invoke_stream_stream(
        self, method_descriptor, handler, invocation_metadata, deadline
    ):
        self._invoke(
            _stream_stream_service(handler),
            method_descriptor,
            handler,
            invocation_metadata,
            deadline,
        )


def _deadline_and_handler(requests_closed, time, timeout):
    if timeout is None:
        return None, _handler.handler_without_deadline(requests_closed)
    else:
        deadline = time.time() + timeout
        handler = _handler.handler_with_deadline(
            requests_closed, time, deadline
        )
        return deadline, handler


class _Server(grpc_testing.Server):
    def __init__(self, serverish, time):
        self._serverish = serverish
        self._time = time

    def invoke_unary_unary(
        self, method_descriptor, invocation_metadata, request, timeout
    ):
        deadline, handler = _deadline_and_handler(True, self._time, timeout)
        self._serverish.invoke_unary_unary(
            method_descriptor, handler, invocation_metadata, request, deadline
        )
        return _server_rpc.UnaryUnaryServerRpc(handler)

    def invoke_unary_stream(
        self, method_descriptor, invocation_metadata, request, timeout
    ):
        deadline, handler = _deadline_and_handler(True, self._time, timeout)
        self._serverish.invoke_unary_stream(
            method_descriptor, handler, invocation_metadata, request, deadline
        )
        return _server_rpc.UnaryStreamServerRpc(handler)

    def invoke_stream_unary(
        self, method_descriptor, invocation_metadata, timeout
    ):
        deadline, handler = _deadline_and_handler(False, self._time, timeout)
        self._serverish.invoke_stream_unary(
            method_descriptor, handler, invocation_metadata, deadline
        )
        return _server_rpc.StreamUnaryServerRpc(handler)

    def invoke_stream_stream(
        self, method_descriptor, invocation_metadata, timeout
    ):
        deadline, handler = _deadline_and_handler(False, self._time, timeout)
        self._serverish.invoke_stream_stream(
            method_descriptor, handler, invocation_metadata, deadline
        )
        return _server_rpc.StreamStreamServerRpc(handler)


def server_from_descriptor_to_servicers(descriptors_to_servicers, time):
    return _Server(_Serverish(descriptors_to_servicers, time), time)