#
#  Copyright (c) 2011 Edward Langley
#  All rights reserved.
#
#  Redistribution and use in source and binary forms, with or without
#  modification, are permitted provided that the following conditions
#  are met:
#
#  Redistributions of source code must retain the above copyright notice,
#  this list of conditions and the following disclaimer.
#
#  Redistributions in binary form must reproduce the above copyright
#  notice, this list of conditions and the following disclaimer in the
#  documentation and/or other materials provided with the distribution.
#
#  Neither the name of the project's author nor the names of its
#  contributors may be used to endorse or promote products derived from
#  this software without specific prior written permission.
#
#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
#  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
#  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
#  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
#  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
#  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
#  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
#  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
#
import traceback
import jsonrpc.jsonutil
from jsonrpc.utilities import public
import jsonrpc.common

# Twisted imports
from twisted.web import server
from twisted.internet import threads
from twisted.internet import defer
from twisted.web.resource import Resource

import abc

import copy
import UserDict, collections
collections.Mapping.register(UserDict.DictMixin)

@public
class ServerEvents(object):
	'''Subclass this and pass to :py:meth:`JSON_RPC.customize` to customize the JSON-RPC server'''

	DEBUG = False

	#: an object defining a 'get' method which contains the methods
	methods = None

	def __init__(self, server):
		#: A link to the JSON-RPC server instance
		self.server = server

	def callmethod(self, txrequest, rpcrequest, **extra):
		'''Find the method and call it with the specified args

		:returns: the result of the method'''

		extra.update(rpcrequest.kwargs)

		method, postprocess_result = self.findmethod(rpcrequest.method, rpcrequest.args, extra), False
		if hasattr('method', '__iter__'):
			method, postprocess_result = method

		if self.DEBUG:
			# Debugging: raise AssertionError if type of method is invalid
			assert method is None or callable(method), 'the returned method is not callable'

		if not callable(method): raise jsonrpc.common.MethodNotFound

		result = method(*rpcrequest.args, **extra)

		#if the result needs to be adjusted/validated, do it
		if postprocess_result:
			result = self.methods.postprocess(rpcrequest.method, result, rpcrequest.args, extra)

		return result

	def findmethod(self, method_name, args=None, kwargs=None):
		'''Return the callable associated with the method name

		:returns: a callable or None if the method is not found'''
		if self.methods is not None:
			return self.methods.get(method_name)
		else:
			raise NotImplementedError

	def processrequest(self, result, args, **kw):
		'''Override to implement custom handling of the method result and request'''
		return result

	def log(self, response, txrequest, error=False):
		'''Override to implement custom logging'''
		pass

	def processcontent(self, content, request):
		'''Given the freshly decoded content of the request, return the content that should be used

		:returns: an object which implements the :py:class:`collections.MutableMapping` interface'''
		return content

	def getresponsecode(self, result):
		'''Take the result, and return an appropriate HTTP response code, returns 200 by default

		NOTE: if an error code is returned, the client error messages will be much less helpful!

		for example

			def getresponsecode(self, result):
				code = 200
				if not isinstance(result, list):
					if result is not None and result.error is not None:
						code = result.error.code or 500
				return code


		:returns: :py:class:`int`'''
		# returns 200 so that the python client can see something useful
		return 200

	def defer(self, method, *a, **kw):
		'''Defer to thread. Override this method if you are using a different ThreadPool, or if you want to return immediately.

		:returns: :py:class:`twisted.internet.defer.Deferred`'''
		return threads.deferToThread(method, *a, **kw)

	def defer_with_rpcrequest(self, method, rpcrequest, *a, **kw):
		d = self.defer(method, rpcrequest, *a, **kw)

		@d.addCallback
		def _inner(result):
			return result, rpcrequest
		@d.addErrback
		def _inner(result):
			result.rpcrequest = rpcrequest
			return result

		return d



## Base class providing a JSON-RPC 2.0 implementation with 2 customizable hooks
@public
class JSON_RPC(Resource):
	'''This class implements a JSON-RPC 2.0 server as a Twisted Resource'''
	isLeaf = True

	### NOTE: these comments are used by Sphinx as documentation.
	#: An instance of :py:class:`ServerEvents` which supplies callbacks to
	#: customize the operation of the server.  The proper way to initialize this
	#: is either to subclass and set it manually, or, preferably, to call :py:meth:`customize`.
	eventhandler = ServerEvents

	def customize(self, eventhandler):
		'''customize the behavior of the server'''
		self.eventhandler = eventhandler(self)
		return self


	def __init__(self, *args, **kwargs):
		self.customize(self.eventhandler)
		Resource.__init__(self,*args, **kwargs)


	def render(self, request):
		result = ''
		request.content.seek(0, 0)
		try:
			try:
				content = jsonrpc.jsonutil.decode(request.content.read())
			except ValueError:
				self.eventhandler.log(None, request, True)
				raise jsonrpc.common.ParseError

			content = self.eventhandler.processcontent(content, request)

			content = jsonrpc.common.Request.from_json(content)

			try:
				if hasattr(content, 'check'):
					content.check()
				else:
					for item in content: item.check()

			except jsonrpc.common.RPCError, e:
				self._ebRender(e, request, content.id if hasattr(content, 'id') else None)

			else:
				d = self._action(request, content)
				d.addCallback(self._cbRender, request)
				d.addErrback(self._ebRender, request, content.id if hasattr(content, 'id') else None)
		except BaseException, e:
			self._ebRender(e, request, None)

		return server.NOT_DONE_YET



	def _action(self, request, contents, **kw):
		result = []

		islist = (True if isinstance(contents, list) else False)
		if not islist: contents = [contents]

		if contents == []: raise jsonrpc.common.InvalidRequest

		def callmethod(rpcrequest, request, add, **kwargs):
			add.update(kwargs)
			result = self.eventhandler.callmethod(request, rpcrequest, **add)
			return result

		deferreds = []
		for rpcrequest in contents:
			res = None
			add = copy.deepcopy(rpcrequest.extra)
			add.update(kw)
			deferreds.append(self.eventhandler.defer_with_rpcrequest(callmethod, rpcrequest, request, add))
		deferreds = defer.DeferredList(deferreds, consumeErrors=True)

		@deferreds.addCallback
		def helper(deferredresults):
			result = []
			try:
				for success, methodresult in deferredresults:
					res = None
					if success:
						methodresult, rpcrequest = methodresult
						res = jsonrpc.common.Response(id=rpcrequest.id, result=methodresult)
						res = self.eventhandler.processrequest(res, request.args, **kw)
					else:
						rpcrequest = methodresult.rpcrequest
						try:
							methodresult.raiseException()
						except Exception, e:
							res = self.render_error(e, rpcrequest.id)
							self.eventhandler.log(res, request, error=True)

					if res.id is not None:
						result.append(res)
			except Exception, e:
				traceback.print_exc()
				raise

			if result != []:
				if not islist: result = result[0]
			else: result = None
			return result

		return deferreds


	def _cbRender(self, result, request):
		@self.eventhandler.defer
		def _inner(*args, **_):
			code = self.eventhandler.getresponsecode(result)
			request.setResponseCode(code)
			self.eventhandler.log(result, request, error=False)
			if result is not None:
				request.setHeader("content-type", 'application/json')
				result_ = jsonrpc.jsonutil.encode(result).encode('utf-8')
				request.setHeader("content-length", len(result_))
				request.write(result_)
			request.finish()
		return _inner

	def _ebRender(self, result, request, id, finish=True):
		@self.eventhandler.defer
		def _inner(*args, **_):
			err = None
			if not isinstance(result, BaseException):
				try: result.raiseException()
				except BaseException, e:
					err = e
					self.eventhandler.log(err, request, error=True)
			else: err = result
			err = self.render_error(err, id)

			code = self.eventhandler.getresponsecode(result)
			request.setResponseCode(code)

			request.setHeader("content-type", 'application/json')
			result_ = jsonrpc.jsonutil.encode(err).encode('utf-8')
			request.setHeader("content-length", len(result_))
			request.write(result_)
			if finish: request.finish()
		return _inner

	def render_error(self, e, id):
		if isinstance(e, jsonrpc.common.RPCError):
			err = jsonrpc.common.Response(id=id, error=e)
		else:
			err = jsonrpc.common.Response(id=id, error=dict(code=0, message=str(e), data=e.args))

		return err