#  includes/comm.py
#  
#  module version: 0.0.20130426
#    for protocol versions 0.2.20130423 and later
#


from .statuscodes import statuscodes


class comm:
    
    # some settings
    aliases = dict()
    server_version = ""
    protocol_version = ""
    verbosity = 0
    
    # initializes global settings
    def init(ServerVersion, ProtocolVersion, Verbosity, Aliases):
        """
        makes settings aviable in this class
        """
        global aliases, server_version, protocol_version, verbosity
        aliases = Aliases
        server_version = ServerVersion
        protocol_version = ProtocolVersion
        verbosity = Verbosity
    
    # builds an header
    def header(CodeList, AdditionalHeaderLines = ""):
        """
        returns the header with one ore mode given status codes
        and optional additional header lines
        """
        ret =\
            "{BEGIN}\n"\
            "asrcp" + protocol_version + "\n"
        for i in range(0, len(CodeList)):
            ret += CodeList[int(i)] + " " +\
                statuscodes.description['s' + CodeList[int(i)]] + "\n"
        ret += "ServerVersion: " + server_version + "\n" +\
            AdditionalHeaderLines + "\n\n"
        return ret
    
    # formats a massage
    def encode_message(text):
        """
        formats a massage, replaces some things
        """
        return text.replace('{', '\{').replace('}', '\}')
    
    # "deformats" a message
    def decode_message(text):
        """
        removes replacements in a message
        """
        return text.replace('\{', '{').replace('\}', '}')
    
    # returns the motd
    def motd(motd):
        """
        builds and returns a motd package
        """
        return comm.header(['202', '003']) + comm.encode_message(motd)
    
    # handles the content
    def command(client_address, data):
        """
        processes a command
        """
        ret = ""
        
        # Look if the received message is an
        # valid alias or a predefined command
        
        # if it's 'version', return the server and protocol version
        if data == "version":
            
            if verbosity >= 2: print("Got valid service command from"
                + str(client_address) + ": ", data)
            
            ret = ret +\
                "202 Valid Service Command\n"\
                "002 Version\n"\
                "ServerVersion:" + server_version + "\n"\
                "ProtocolVersion:" + protocol_version + "\n"
        
        # if it's 'help', give a little help
        elif data == 'help':
            
            if verbosity >= 2: print("Got valid command from"
                + str(client_address) + ": ", data)
            
            # send status code
            ret = ret + "202 Valid Service Command\n\n"
            
            # send the list of aliases
            ret = ret + "Aviable aliases:\n"
            for i in aliases.keys():
                ret = ret + str(i) + "\n"
        
        # if it's a valid userdefined command
        elif data in aliases:
            
            # send status code
            ret = ret + "201 Valid Command\n\n"
            
            # ohmagawd! a debug message!!1!
            if verbosity >= 2: print("Got valid command from"
                + str(client_address) + ": ", data)
            
            # execute the aliased command
            g_dict, l_dict = {}, {}
            exec(str(aliases[data]), g_dict, l_dict)
            
            # send may contain data to send to the client
            if l_dict["send"]:
                    content = str(l_dict["send"]).replace('{', '\{')
                    content = content.replace('}', '\}')
                    
                    ret = ret + content + "\n"
        
        # ALL IS LOST!!1! this has to be invalid!
        else:
            
            # send status code
            ret = ret + "203 Invalid Command\n"
            
            if verbosity >= 2: print("Got invalid command from",
                str(client_address), ": ", data)
        
        ret = ret + "{END}\n"
        
        return ret