import traceback

from SocketServer import TCPServer
from SimpleXMLRPCServer import SimpleXMLRPCDispatcher
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler

from connection import Connection
from utils import eval_card, eval_list, eval_dict, eval_const

class XMLRPCServer(TCPServer, SimpleXMLRPCDispatcher):
    allow_reuse_address = True
    def __init__(self, addr, valid_servers,
        requestHandler = SimpleXMLRPCRequestHandler, logRequests = 1):
        
        self.logRequests = logRequests
        self.valid_servers = valid_servers

        SimpleXMLRPCDispatcher.__init__(self)
        TCPServer.__init__(self, addr, requestHandler)

        self.connections = {}

    def _dispatch_handle_none(self, function, args):
        print "Call to %s with args %s" % (repr(function.__name__), repr(args)),

        try:
            result = function(*args)
        except:
            traceback.print_exc()
            raise
        
        print "returned %s" % repr(result)

        if result is not None:
            return result
        else:
            return 0

    def _dispatch(self, method, params):
        try:
            func = getattr(self, 'rpc_' + method)
        except AttributeError:
            pass
        else:
            return self._dispatch_handle_none(func, params)
    
        try:
            func = getattr(self.connections[params[0]], 'rpc_' + method)
        except AttributeError:
            pass
        else:
            return self._dispatch_handle_none(func, params[1:])
        
        raise Exception, "method is not supported"

    def rpc_connect(self, host, port):
        '''Create a new connection.'''
        if (host, port) not in self.valid_servers:
            raise Exception, "Invalid server"
        conn = Connection((host, port), self)
        return hash(conn)

    def rpc_eval_card(self, data):
        '''Evaluate data to a card instance, returned via RPC as a tuple.'''
        return eval_card(data)

    def rpc_eval_list(self, data):
        '''Evaluate data to a list of card instances'''
        return eval_list(data)

    def rpc_eval_dict(self, data):
        '''Evaluate data to a table-style dictionary of card instances and
        builtin types.
        '''
        return eval_dict(data)

    def rpc_eval_const(self, data):
        '''Evaluate data to a python builtin type.'''
        return eval_const(data)