#!/usr/bin/env python

##
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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
#
#     https://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.

from __future__ import absolute_import, division, print_function

import io

from zope.interface import implements

import avro.io
from avro import ipc
from twisted.internet.defer import Deferred, maybeDeferred
from twisted.internet.protocol import Protocol
from twisted.web import resource, server
from twisted.web.client import Agent
from twisted.web.http_headers import Headers
from twisted.web.iweb import IBodyProducer


class TwistedRequestor(ipc.BaseRequestor):
    """A Twisted-compatible requestor. Returns a Deferred that will fire with the
       returning value, instead of blocking until the request completes."""

    def _process_handshake(self, call_response, message_name, request_datum):
        # process the handshake and call response
        buffer_decoder = avro.io.BinaryDecoder(io.BytesIO(call_response))
        call_response_exists = self.read_handshake_response(buffer_decoder)
        if call_response_exists:
            return self.read_call_response(message_name, buffer_decoder)
        else:
            return self.request(message_name, request_datum)

    def issue_request(self, call_request, message_name, request_datum):
        d = self.transceiver.transceive(call_request)
        d.addCallback(self._process_handshake, message_name, request_datum)
        return d


class RequestStreamingProducer(object):
    """A streaming producer for issuing requests with the Twisted.web Agent."""
    implements(IBodyProducer)

    paused = False
    stopped = False
    started = False

    def __init__(self, message):
        self._message = message
        self._length = len(message)
        # We need a buffer length header for every buffer and an additional
        # zero-length buffer as the message terminator
        self._length += (self._length / ipc.BUFFER_SIZE + 2) \
            * ipc.BUFFER_HEADER_LENGTH
        self._total_bytes_sent = 0
        self._deferred = Deferred()

    # read-only properties
    message = property(lambda self: self._message)
    length = property(lambda self: self._length)
    consumer = property(lambda self: self._consumer)
    deferred = property(lambda self: self._deferred)

    def _get_total_bytes_sent(self):
        return self._total_bytes_sent

    def _set_total_bytes_sent(self, bytes_sent):
        self._total_bytes_sent = bytes_sent

    total_bytes_sent = property(_get_total_bytes_sent, _set_total_bytes_sent)

    def startProducing(self, consumer):
        if self.started:
            return

        self.started = True
        self._consumer = consumer
        # Keep writing data to the consumer until we're finished,
        # paused (pauseProducing()) or stopped (stopProducing())
        while self.length - self.total_bytes_sent > 0 and \
                not self.paused and not self.stopped:
            self.write()
        # self.write will fire this deferred once it has written
        # the entire message to the consumer
        return self.deferred

    def resumeProducing(self):
        self.paused = False
        self.write(self)

    def pauseProducing(self):
        self.paused = True

    def stopProducing(self):
        self.stopped = True

    def write(self):
        if self.length - self.total_bytes_sent > ipc.BUFFER_SIZE:
            buffer_length = ipc.BUFFER_SIZE
        else:
            buffer_length = self.length - self.total_bytes_sent
        self.write_buffer(self.message[self.total_bytes_sent:
                                       (self.total_bytes_sent + buffer_length)])
        self.total_bytes_sent += buffer_length
        # Make sure we wrote the entire message
        if self.total_bytes_sent == self.length and not self.stopped:
            self.stopProducing()
            # A message is always terminated by a zero-length buffer.
            self.write_buffer_length(0)
            self.deferred.callback(None)

    def write_buffer(self, chunk):
        buffer_length = len(chunk)
        self.write_buffer_length(buffer_length)
        self.consumer.write(chunk)

    def write_buffer_length(self, n):
        self.consumer.write(ipc.BIG_ENDIAN_INT_STRUCT.pack(n))


class AvroProtocol(Protocol):

    recvd = ''
    done = False

    def __init__(self, finished):
        self.finished = finished
        self.message = []

    def dataReceived(self, data):
        self.recvd = self.recvd + data
        while len(self.recvd) >= ipc.BUFFER_HEADER_LENGTH:
            buffer_length, = ipc.BIG_ENDIAN_INT_STRUCT.unpack(
                self.recvd[:ipc.BUFFER_HEADER_LENGTH])
            if buffer_length == 0:
                response = ''.join(self.message)
                self.done = True
                self.finished.callback(response)
                break
            if len(self.recvd) < buffer_length + ipc.BUFFER_HEADER_LENGTH:
                break
            buffer = self.recvd[ipc.BUFFER_HEADER_LENGTH:buffer_length + ipc.BUFFER_HEADER_LENGTH]
            self.recvd = self.recvd[buffer_length + ipc.BUFFER_HEADER_LENGTH:]
            self.message.append(buffer)

    def connectionLost(self, reason):
        if not self.done:
            self.finished.errback(ipc.ConnectionClosedException("Reader read 0 bytes."))


class TwistedHTTPTransceiver(object):
    """This transceiver uses the Agent class present in Twisted.web >= 9.0
       for issuing requests to the remote endpoint."""

    def __init__(self, host, port, remote_name=None, reactor=None):
        self.url = "http://%s:%d/" % (host, port)

        if remote_name is None:
            # There's no easy way to get this peer's remote address
            # in Twisted so I use a random UUID to identify ourselves
            import uuid
            self.remote_name = uuid.uuid4()

        if reactor is None:
            from twisted.internet import reactor
        self.agent = Agent(reactor)

    def read_framed_message(self, response):
        finished = Deferred()
        response.deliverBody(AvroProtocol(finished))
        return finished

    def transceive(self, request):
        req_method = 'POST'
        req_headers = {
            'Content-Type': ['avro/binary'],
            'Accept-Encoding': ['identity'],
        }

        body_producer = RequestStreamingProducer(request)
        d = self.agent.request(
            req_method,
            self.url,
            headers=Headers(req_headers),
            bodyProducer=body_producer)
        return d.addCallback(self.read_framed_message)


class AvroResponderResource(resource.Resource):
    """This Twisted.web resource can be placed anywhere in a URL hierarchy
       to provide an Avro endpoint. Different Avro protocols can be served
       by the same web server as long as they are in different resources in
       a URL hierarchy."""
    isLeaf = True

    def __init__(self, responder):
        resource.Resource.__init__(self)
        self.responder = responder

    def cb_render_POST(self, resp_body, request):
        request.setResponseCode(200)
        request.setHeader('Content-Type', 'avro/binary')
        resp_writer = ipc.FramedWriter(request)
        resp_writer.write_framed_message(resp_body)
        request.finish()

    def render_POST(self, request):
        # Unfortunately, Twisted.web doesn't support incoming
        # streamed input yet, the whole payload must be kept in-memory
        request.content.seek(0, 0)
        call_request_reader = ipc.FramedReader(request.content)
        call_request = call_request_reader.read_framed_message()
        d = maybeDeferred(self.responder.respond, call_request)
        d.addCallback(self.cb_render_POST, request)
        return server.NOT_DONE_YET
