#
 #  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 warnings

 from jsonrpc.utilities import public
 import jsonrpc.jsonutil
 
 @public
 class RPCError(Exception):
 	'''Base Exception for JSON-RPC Errors, if this or a subclass of this is raised by a JSON-RPC method,
 	The server will convert it into an appropriate error object
 	'''
 
 	#: Error code
 	code = 0
 	#: Error message
 	msg = ""
 
 	@classmethod
 	def from_dict(cls, err):
 		self = cls()
 		self.code = err['code']
 		self.msg = err['message']
 		return self
 
 	def json_equivalent(self):
 		'''return a dictionary which matches an JSON-RPC Response'''
 		return dict(code=self.code, message=self.msg)
 
 	def __str__(self):
 		return jsonrpc.jsonutil.encode(self)
 
 @public
 class InvalidRequest(RPCError):
 	'''Raise this when the Request object does not match the schema'''
 	code = -32600
 	msg = "Invalid Request."
 
 @public
 class MethodNotFound(RPCError):
 	'''Raise this when the desired method is not found'''
 	code = -32601
 	msg = "Procedure not found."
 
 @public
 class ParseError(RPCError):
 	'''Raise this when the request contains invalid JSON'''
 	code = -32700
 	msg = "Parse error."
 
 codemap = {0: RPCError}
 codemap.update( (e.code, e) for e in RPCError.__subclasses__() )
 
 class JsonInstantiate:

 	@classmethod
 	def from_json(cls, json):
 		data = json
 		if hasattr(json, 'upper'):
 			data = jsonrpc.jsonutil.decode(json)
 		if isinstance(data, list):
 			result = cls.from_list(data)
 		else:
 			result = cls.from_dict(data)
 		return result

 	@classmethod
 	def from_list(cls, responses):
 		return [cls.from_dict(r) for r in responses]

 
 
 class Request(object, JsonInstantiate):
 	def __init__(self, id, method, args=None, kwargs=None, extra=None, version='2.0'):
 		self.version = version
 		self.id = id
 		self.method = method
 		self.args = args
 		self.kwargs = kwargs
 		self.extra = extra or {}
 
 	@classmethod
 	def from_dict(cls, content):
 		version = content.pop('jsonrpc', None)
 		id = content.pop('id', None)
 
 		method = content.pop('method', None)
 
 		kwargs = content.pop('params', {})
 		args = ()
 		if not isinstance(kwargs, dict):
 			args = tuple(kwargs)
 			kwargs = {}
 		else:
 			args = kwargs.pop('__args', args)
 
 		args = args
 		kwargs = dict( (str(k), v) for k,v in kwargs.items() )
 		extra = content
 		return cls(id, method, args, kwargs, extra, version)
 
 
 	def check(self):
 		if self.version != '2.0': raise InvalidRequest
 		if not isinstance(self.method, (str, unicode)): raise InvalidRequest

 		if not isinstance(self.id, (str, unicode, int, type(None))):
 			self.id = None
 			raise InvalidRequest

 
 
 	def json_equivalent(self):

 		if self.kwargs and self.kwargs.has_key('__args'):

 			raise ValueError, 'invalid argument name: __args'
 
 		params = self.args
 		if self.args and self.kwargs:
 			self.kwargs['__args'] = self.args
 		if self.kwargs:

 			params = self.kwargs

 
 		return dict(
 			jsonrpc = self.version,
 			id = self.id,
 			method = self.method,
 			params = params
 		)
 
 
 
 class Response(object, JsonInstantiate):
 	def __init__(self, id=None, result=None, error=None, version='2.0'):
 		self.version = version
 		self.id = id
 		self.result = result
 		self.error = error
 
 
 	@classmethod
 	def from_dict(cls, response):
 		version = response.get('jsonrpc', None)
 		id = response['id']
 		result = response.get('result', None)
 		error = response.get('error', None)
 
 		return cls(id, result, error, version)
 
 	def json_equivalent(self):
 		res = dict(jsonrpc=self.version, id=self.id)
 		if self.error is None:
 			res['result'] = self.result
 		else:
 			res['error'] = self.error
 		return res
 
 	def get_result(self):
 		'''get result and raise any errors'''
 		if self.error:
 			code = self.error['code']
 			raise codemap.get(code, RPCError).from_dict(self.error)
 		return self.result
 
 	def get_output(self):
 		'''get tuple (result, error)'''
 		return self.result, self.error