from OFS.SimpleItem import SimpleItem
import xmlrpclib
import httplib
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
import os.path
from Globals import package_home
import re

class XMLRpcServerProxy(SimpleItem):
    """makes servery proxy available for zope"""
    
    meta_type="XMLRpcServerProxy"
    
    rpc_no_arg_expr='[^A-z0-9]'
    
    manage_options= (
        {'label':'Main Config','action':'mainConfigHTML'},
        )+ SimpleItem.manage_options

    def __init__(self,id,serverUrl,use_xmlrpc=True):
        """init server proxy"""
        self.id=id
        self.serverUrl=serverUrl
        self.use_xmlrpc = use_xmlrpc
        
        
    def ServerProxy(self,serverUrl=None):
        """get the proxy"""
        if not serverUrl:
            serverUrl=self.serverUrl
      
        if self.use_xmlrpc:
            pr = xmlrpclib.ServerProxy(serverUrl)
        else:
            pr = httplib.HTTPConnection(serverUrl)
       
        return pr
    
    
    def eval(self,method,argument,outputUnicode=True):
        """do proxy request"""
        server=self.ServerProxy()
        
        if self.use_xmlrpc:
            # for XML-RPC methods only letters are allowed
            method=re.sub('[^A-z0-9_]','',method)
            # clean argument
            argument=re.sub(self.rpc_no_arg_expr,'',argument)
            
            cmd="""server.%s('%s')"""%(method,argument)
           
            return eval(cmd)
        else:
            # HTTP
            # TODO: check arguments
            uri = method
            if argument:
                uri += '?' + argument
            
            #print "GET: ", uri
            server.request("GET", uri)
            resp = server.getresponse()
            data = resp.read()
            #print "GOT: ", resp.status, ", ", resp.reason, " = ", data
            if outputUnicode:
                return data.decode('UTF-8')
            else:
                return data
        
    def eval2(self,method,argument1,argument2,outputUnicode=True):
        """do proxy request"""
        server=self.ServerProxy()
        
        if self.use_xmlrpc:
            # for XML-RPC methods only letters are allowed
            method=re.sub('[^A-z0-9_]','',method)
            # clean argument
            argument1=re.sub(self.rpc_no_arg_expr,'',argument1)
            argument2=re.sub(self.rpc_no_arg_expr,'',argument2)
            
            cmd="""server.%s('%s','%s')"""%(method,argument1,argument2)
           
            return eval(cmd)
        else:
            # HTTP
            # TODO: check arguments
            uri = method
            if argument1:
                uri += '?' + argument1 + argument2
            
            #print "GET: ", uri
            server.request("GET", uri)
            resp = server.getresponse()
            data = resp.read()
            #print "GOT: ", resp.status, ", ", resp.reason, " = ", data
            
            if outputUnicode:
                return data.decode('UTF-8')
            else:
                return data
        
    
    def mainConfigHTML(self):
        """main config form"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','manageXMLRpcServerProxy.zpt')).__of__(self)
        return pt()
    
    def mainConfig(self,serverUrl,use_xmlrpc=True,rpc_no_arg_expr=None,RESPONSE=None):
        """main config"""
        
        self.serverUrl=serverUrl
        
        if use_xmlrpc and use_xmlrpc != "no":
            use_xmlrpc = True
        else:
            use_xmlrpc = False
        
        self.use_xmlrpc=use_xmlrpc
        
        if rpc_no_arg_expr is not None:
            self.rpc_no_arg_expr = rpc_no_arg_expr
        
        if RESPONSE:
            RESPONSE.redirect("manage_main")
            

def manage_addXMLRpcServerProxyForm(self):
    """add the XMLRpcServerProxy"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addXMLRpcServerProxy.zpt')).__of__(self)
    return pt()

def manage_addXMLRpcServerProxy(self,id,serverUrl,use_xmlrpc=True,rpc_no_arg_expr=None,RESPONSE=None):
    """add the XMLRpcServerProxy"""
    if use_xmlrpc is not None and use_xmlrpc != "no":
        use_xmlrpc = True
    else:
        use_xmlrpc = False
        
    ob=XMLRpcServerProxy(id,serverUrl,use_xmlrpc)
    
    if rpc_no_arg_expr is not None:
        ob.rpc_no_arg_expr = rpc_no_arg_expr
        
    self._setObject(id, ob)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')