from pyscrabble.constants import *
from string import split


class CommandCreator:
    '''
    CommandCreator is a utility class to create commands
    '''
    
    def __init__(self):
        '''
        Initializet the command parser
        '''
        
        self.parser = CommandParser()
    
    def createLoginCommand(self, username, password, version):
        '''
        
        @param username:
        @param password:
        @param version:
        @return: LoginCommand
        '''
        
        return self.parser.parseLoginCommand( [username, password, LOGIN_INIT, version] )
    
    def createNewUserCommand(self, username, password, isAdmin):
        '''
        
        @param username:
        @param password:
        @param isAdmin:
        @return LoginCommand
        '''
        
        return self.parser.parseLoginCommand( [username, password, NEW_USER, isAdmin] )
    
    def createChangePasswordCommand(self, newpassword, oldpassword):
        '''
        
        @param newpassword:
        @param oldpassword:
        @return LoginCommand
        '''
        
        return self.parser.parseLoginCommand( ['', newpassword, CHANGE_PASSWORD, oldpassword] )
        
    def createGoodbyeCommand(self):
        '''
        
        @return: LoginCommand
        '''
        
        return self.parser.parseLoginCommand( ['','',LOGOUT,''] )
    
    def createJoinChatCommand(self, username):
        '''
        
        @param username:
        @return: ChatCommand
        '''
        
        return self.parser.parseChatCommand( [username, CHAT_JOIN, ''] )
    
    def createLeaveChatCommand(self):
        '''
        @return: ChatCommand
        '''
        
        return self.parser.parseChatCommand( ['', CHAT_LEAVE, ''] )
    
    def createPostChatMessageCommand(self, msg, username='' ):
        '''
        
        @param msg:
        @param username:
        @return: ChatCommand
        '''
        
        return self.parser.parseChatCommand( [username, CHAT_MESSAGE, msg] )
    
    def createGetMessagesCommand(self, data=''):
        '''
        
        @param data: Data
        @return: ChatCommand
        '''
        
        return self.parser.parseChatCommand( ['', GET_MESSAGES, data] )
    
    def createCheckMessagesCommand(self, data=''):
        '''
        
        @param data: Data
        @return: ChatCommand
        '''
        
        return self.parser.parseChatCommand( ['', CHECK_MESSAGES, data] )
    
    def createDeleteMessageCommand(self, data=''):
        '''
        
        @param data: Data
        @return: ChatCommand
        '''
        
        return self.parser.parseChatCommand( ['', DELETE_MESSAGE, data] )
    
    def createGetChatUsersCommand(self, users=''):
        '''
        
        @param users: List of users
        @return: ChatCommand
        '''
        
        return self.parser.parseChatCommand( ['', CHAT_USERS, users] )
    
    def createGetLettersCommand(self, gameId, numLetters):
        '''
        
        @param gameId:
        @param numLetters:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_GET_LETTERS, gameId, numLetters] )
    
    def createGetGameListCommand(self, data=''):
        '''
        
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_LIST, '', data] )
    
    def createGameJoinCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_JOIN, gameId, data] )
    
    def createGameUserListCommand(self, gameId, data):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_USER_LIST, gameId, data] )
    
    def createGameStartCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_START, gameId, data] )
    
    def createGameLeaveCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_LEAVE, gameId, data] )
    
    def createGameTurnCurrentCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_TURN_CURRENT, gameId, data] )
    
    def createGameTurnOtherCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_TURN_OTHER, gameId, data] )
    
    def createGameErrorCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_ERROR, gameId, data] )
    
    def createGameSendMoveCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_SEND_MOVE, gameId, data] )
    
    def createGameAcceptMoveCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_ACCEPT_MOVE, gameId, data] )
    
    def createCreateGameCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_CREATE, gameId, data] )
    
    def createGamePassMoveCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_PASS, gameId, data] )
    
    def createGameInfoCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_INFO, gameId, data] )
    
    def createGamePauseCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_PAUSE, gameId, data] )
    
    def createGameUnpauseCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_UNPAUSE, gameId, data] )
    
    def createGameTradeLettersCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data: List of Letters
        @return: GameCommand
        '''
        
        return self.parser.parseGameCommand( [GAME_TRADE_LETTERS, gameId, data] )
    
    def createGameChatMessageCommand(self, gameId, data=''):
        '''
        Send a game chat message to the server
        
        @param gameId: Game ID
        @param data: Chat message
        '''
        
        return self.parser.parseGameCommand( [GAME_CHAT_MESSAGE, gameId, data] )
    
    def createBootedCommand(self, data=''):
        '''
        Command for the server to boot a user off the server
        
        @param data: Reason
        '''
        
        return self.parser.parseLoginCommand(['','', BOOTED, data])
    
    def createErrorCommand(self, data=''):
        '''
        Show an error message
        
        @param data: Error message
        '''
        return self.parser.parseChatCommand( ['', ERROR, data] )
    
    def createInfoCommand(self, data=''):
        '''
        Show an Info message
        
        @param data: Info message
        '''
        return self.parser.parseChatCommand( ['', INFO, data] )
    
    def createPrivateMessageCommand(self, sender, recipient, data):
        '''
        Send a private message
        
        @param sender:
        @param recipient:
        @param data:
        '''
        
        return self.parser.parsePrivateMessageCommand( [PRIVATE_MESSAGE_SEND, sender, recipient, data] )
    
    def createGameSpectatorJoinCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        return self.parser.parseGameCommand( [GAME_SPECTATOR_JOIN, gameId, data] )
    
    def createGameSpectatorLeaveCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        return self.parser.parseGameCommand( [GAME_SPECTATOR_LEAVE, gameId, data] )
    
    def createGameSpectatorChatCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        return self.parser.parseGameCommand( [GAME_SPECTATOR_CHAT_SET, gameId, data] )
    
    def createGameStatsCommand(self, gameId, data=''):
        '''
        Send game stats
        
        @param gameId: Game ID
        @param data: Stat data
        '''
        return self.parser.parseGameCommand( [GAME_SEND_STATS, gameId, data] )
    
    def createGameBagEmptyCommand(self, gameId, data=''):
        '''
        Game bag is empty 
        
        @param gameId: Game ID
        @param data:
        '''
        return self.parser.parseGameCommand( [GAME_BAG_EMPTY, gameId, data] )
    
    def createGameSendSpectatorsCommand(self, gameId, data=''):
        '''
        Send list of spectators
        
        @param gameId: Game ID
        @param data:
        '''
        return self.parser.parseGameCommand ( [GAME_SEND_SPECTATORS, gameId, data] )
    
    
    def createUserInfoCommand(self, username, data=''):
        '''
        User info
        
        @param username:
        @return: ChatCommand
        '''
        return self.parser.parseChatCommand( [username, USER_INFO, data] )
    
    def createServerStatsCommand(self, data=''):
        '''
        Server stats
        
        @return: ChatCommand
        '''
        return self.parser.parseChatCommand( ['', SERVER_STATS, data] )
    
    def createGetNumServerUsersCommand(self, data=''):
        '''
        Get the number of users on a server
        
        @return: LoginCommand
        '''
        
        return self.parser.parseLoginCommand( ['', '', SERVER_NUM_USERS, data] )
    
    def createGameSendOptionsCommand(self, gameId, data=''):
        '''
        Send game options
        
        @param gameId: Game ID
        @param data:
        '''
        return self.parser.parseGameCommand ( [GAME_SEND_OPTIONS, gameId, data] )
    
    def createGameOverCommand(self, gameId, data=''):
        '''
        Game Over
        
        @param gameId: Game ID
        @param data:
        '''
        return self.parser.parseGameCommand ( [GAME_OVER, gameId, data] )
    
    def createGameTimeExpireCommand(self, gameId, data=''):
        '''
        Game Time has expired for a player
        
        @param gameId: Game ID
        @param data:
        '''
        return self.parser.parseGameCommand ( [GAME_TIME_EXPIRE, gameId, data] )
    
    def createMoveTimeExpireCommand(self, gameId, data=''):
        '''
        Move Time has expired for a player
        
        @param gameId: Game ID
        @param data:
        '''
        return self.parser.parseGameCommand ( [GAME_MOVE_TIME_EXPIRE, gameId, data] )
    
    def createGameSpectatorSetCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        return self.parser.parseGameCommand( [GAME_SPECTATOR_SET, gameId, data] )
    
    def createGameBootCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        return self.parser.parseGameCommand( [GAME_BOOT, gameId, data] )
    
    def createGameDistributionCommand(self, gameId, data=''):
        '''
        
        @param gameId:
        @param data:
        @return: GameCommand
        '''
        return self.parser.parseGameCommand( [GAME_DISTRIBUTION, gameId, data] )
        
        
        
        
        
    
        

class CommandParser:
    '''
    Command Parser.
    
    A command is structured as followed:
    HEADER | COMMAND | data1 | data2 | ... |
    '''
    
    def parseCommand(self, data):
        '''
        Parse the command string into a Command
        
        @param data: String containing command data
        @return: Command
        '''
        
        e = split(data, SEPARATOR)
        header = e.pop(0)
        
        elements = []
        for s in e:
            if elements and elements[-1].endswith("\\"):
                elements[-1] = "%s|%s"%(elements[-1][:-1], s)
            else:
                elements.append(s)
        
        if ( header == LOGIN_HEADER ):
            return self.parseLoginCommand(elements)
        if ( header == CHAT_HEADER ):
            return self.parseChatCommand(elements)
        if ( header == GAME_HEADER ):
            return self.parseGameCommand(elements)
        if ( header == PRIVATE_MESSAGE_HEADER ):
            return self.parsePrivateMessageCommand(elements)
    
    def parseLoginCommand(self, elements):
        '''
        Parse a LoginCommand
        
        @param elements: List of command elements
        @return: LoginCommand
        '''
        
        return LoginCommand( elements.pop(0), elements.pop(0), elements.pop(0), elements.pop(0) )
    
    def parseChatCommand(self, elements):
        '''
        Parse a ChatCommand
        
        @param elements: List of command elements
        @return: ChatCommand
        '''
        
        return ChatCommand( elements.pop(0), elements.pop(0), elements.pop(0) )
    
    def parseGameCommand(self, elements):
        '''
        Parse a GameCommand
        
        @param elements: List of command elements
        @return: GameCommand
        '''
        
        return GameCommand( elements.pop(0), elements.pop(0), elements.pop(0) )
    
    def parsePrivateMessageCommand(self, elements):
        '''
        Parse a PrivateMessageCommand
        
        @param elements: List of command elements
        '''
        
        return PrivateMessageCommand( elements.pop(0), elements.pop(0), elements.pop(0), elements.pop(0) )
        
            

# Commands

class Command:
    '''
    Base Command class
    '''
    
    def getCommand(self):
        '''
        Retrieve the command information
        
        @see: L{constants}
        @return: Command information
        '''
        
        return self.command
    
    def setCommand(self, command):
        '''
        Set command information
        
        @param command: Command information
        @see: L{constants}
        '''
        
        self.command = command
    
    def getData(self):
        '''
        
        @return: Command data
        '''
        
        return self.data
    
    def setData(self, data):
        '''
        Set command data
        
        @param data: Command data
        '''
        
        self.data = data
    
    def getUsername(self):
        '''
        
        @return: Username of user executing command
        '''
        
        return self.username
    
    def setUsername(self, username):
        '''
        Set username for command
        
        @param username: Username
        '''
        
        self.username = username
    
    def __repr__(self, list):
        '''
        Format the command as a string in the form::
            HEADER | COMMAND | data1 | data2 | ... |
        
        @param list: List of command elements
        @return: Formatted Command string
        '''
        
        buf = ''
        for item in list:
            buf += str(item).replace('|', '\|')
            buf += SEPARATOR
    
        return buf


class ChatCommand(Command):
    '''
    Chat Command class.  Used for chat functions
    '''
    
    def __init__(self, username, command, data):
        '''
        Initialize the ChatCommand
        
        @param username: Username
        @param command: Command
        @param data:
        @see: L{constants}
        '''
        
        self.command = command
        self.data = data
        self.username = username
    
    def __repr__(self):
        '''
        Format Chat Command
        
        @see: L{Command.__repr__}
        @return: Formatted Command string
        '''
        
        return Command.__repr__(self, [CHAT_HEADER, self.username, self.command, self.data] )


class LoginCommand(Command):
    '''
    LoginCommand class.  Used for logging in/out of the system and changing password.
    '''
    
    def __init__(self, username, password, command, data):
        '''
        Initialize a new LoginCommand
        
        @param username:
        @param password:
        @param command:
        @param data:
        @see: L{constants}
        '''
        
        self.username = username
        self.password = password
        self.command = command
        self.data = data
    
    def getPassword(self):
        '''
        
        @return: Password
        '''
        
        return self.password
    
    def setPassword(self, password):
        '''
        Set password
        
        @param password:
        '''
        
        self.password = password
    
    def __repr__(self):
        '''
        Format Login Command
        
        @see: L{Command.__repr__}
        @return: Formatted Command string
        '''
        
        return Command.__repr__(self, [LOGIN_HEADER, self.username, self.password, self.command, self.data] )


class GameCommand(Command):
    '''
    GameCommand class for all Game functions
    '''
    
    def __init__(self, command, gameId,  data):
        '''
        Initialize a new GameCommand
        
        @param command:
        @param gameId:
        @param data:
        @see: L{constants}
        '''
        
        self.command = command
        self.gameId = gameId
        self.data = data
    
    def getGameId(self):
        '''
        
        @return: Game ID
        '''
        
        return self.gameId
    
    def setGameId(self, gameId):
        '''
        Set Game ID
        
        @param gameId:
        '''
        
        self.gameId = gameId
    
    def __repr__(self):
        '''
        Format GameCommand 
        
        @see: L{Command.__repr__}
        @return: Formatted Command string
        '''
        
        return Command.__repr__(self, [GAME_HEADER, self.command, self.gameId, self.data])


class PrivateMessageCommand(Command):
    
    def __init__(self, command, sender, recipient, data):
        '''
        Private message command
        
        @param command:
        @param sender:
        @param recipient:
        @param data:
        '''
        
        self.command = command
        self.sender = sender
        self.recipient = recipient
        self.data = data
    
    def getSender(self):
        '''
        Get sender
        
        @return: Sender
        '''
        
        return self.sender
    
    def setSender(self, sender):
        '''
        Set sender
        
        @param sender:
        '''
        
        self.sender = sender
    
    def getRecipient(self):
        '''
        Get Recipient
        
        @return: Recipient
        '''
        
        return self.recipient
    
    def setRecipient(self, recipient):
        '''
        Set recipient
        
        @param recipient: Recipient
        '''
        
        self.recipient = recipient
    
    def __repr__(self):
        '''
        Format PrivateMessageCommand 
        
        @see: L{Command.__repr__}
        @return: Formatted Command string
        '''
        
        return Command.__repr__(self, [PRIVATE_MESSAGE_HEADER, self.command, self.sender, self.recipient, self.data])