#   This file is part of PARPG.
#
#   PARPG is free software: you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation, either version 3 of the License, or
#   (at your option) any later version.
#
#   PARPG is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>.
"""
Provides classes used to implement dialogue logic and allow dialogues to have
external effects on the game state.
"""
import logging

logger = logging.getLogger('dialogueaction')

class DialogueAction(object):
    """
    Abstract base class for subclasses that represent dialogue actions embedded
    within a DialogueSection or DialogueResponse.
    
    Subclasses must define the keyword class variable and implement both the
    __init__ and __call__ methods.
    
    @cvar keyword: keyword used by the L{DialogueParser} to recognize the
        L{DialogueAction} in serialized L{Dialogues<Dialogues>}.
    @type keyword: basestring
    """
    logger = logging.getLogger('dialogueaction.DialogueAction')
    registered_actions = {}
    
    @classmethod
    def registerAction(cls, dialogue_action_type):
        """
        Register a L{DialogueAction} subclass for easy reference.
        
        @param dialogue_action_type: dialogue action to register.
        @type dialogue_action_type: L{DialogueAction} subclass
        """
        cls.registered_actions[dialogue_action_type.keyword] = \
            dialogue_action_type
    
    def __init__(self, *args, **kwargs):
        """
        Initialize a new L{DialogueAction} instance.
        
        @param args: positional arguments passed by the L{DialogueParser} after
            reading a serialized L{Dialogue}.
        @type args: list of objects
        @param kwargs: keyword arguments passed by the L{DialogueParser} after
            reading a serialized L{Dialogue}.
        @type kwargs: dict of objects
        """
        if (not hasattr(type(self), 'keyword')):
            raise AttributeError('DialogueAction subclasses must define the '
                                 'keyword class variable.')
        self.arguments = (args, kwargs)
    
    def __call__(self, game_state):
        """
        Execute the L{DialogueAction}.
        
        @param game_state: variables and functions that make up the current
            game state.
        @type game_state: dict of objects
        """
        raise NotImplementedError('subclasses of DialogueAction must '
                                  'override __call__')


class MeetAction(DialogueAction):
    """
    L{DialogueAction} that adds an NPC to the list of NPCs known by the player.
    """
    keyword = 'meet'
    
    def __init__(self, *args, **kwargs):
        """
        Initialize a new L{MeetAction} instance.
        
        @param args: positional arguments.
        @type args: list of objects
        @param npc_id: identifier of the NPC that the player has met.
        @type npc_id: basestring
        @param kwargs: keyword arguments (not used).
        @type kwargs: dict of objects
        """
        DialogueAction.__init__(self, *args, **kwargs)
        self.npc_id = args[0]
    
    def __call__(self, game_state):
        """
        Add an NPC to the list of NPCs known by the player.
        
        @param game_state: variables and functions that make up the current
            game state.
        @type game_state: dict of objects
        """
        npc_id = self.npc_id
        # NOTE Technomage 2010-11-13: This print statement seems overly
        #     verbose, so I'm logging it as an INFO message instead.
#        print("You've met {0}!".format(npc_id))
        self.logger.info("You've met {0}!".format(npc_id))
        game_state['pc'].meet(npc_id)
DialogueAction.registerAction(MeetAction)


class InventoryAction(DialogueAction):
    """
    Abstract base class for L{DialogueActions<DialogueAction>} used to
    manipulate the NPC's and the player's inventory.
    """
    def __init__(self, *args, **kwargs):
        """
        Initialize a new L{InventoryAction} instance.
        
        @param args: positional arguments.
        @type args: list of objects
        @param item_types: item types that should be manipulated.
        @type item_types: list of basestrings
        @param kwargs: keyword arguments.
        @type kwargs: dict of objects
        """
        DialogueAction.__init__(self, *args, **kwargs)
        self.item_types = args


class TakeStuffAction(InventoryAction):
    """
    L{InventoryAction} used to move items from the NPC's inventory to the
    player's inventory.
    """
    keyword = 'take_stuff'
    
    def __call__(self, game_state):
        """
        Move items from the NPC's inventory to the player's inventory.
        
        @param game_state: variables and functions that make up the current
            game state.
        @type game_state: dict of objects
        """
        item_types = self.item_types
        for item_type in item_types:
            item = game_state['npc'].inventory.findItem(item_type=item_type)
            if (item):
                game_state['npc'].give(item, game_state['pc'])
                print("{0} gave you the {1}".format(game_state['npc'].name,
                                                    item_type))
            else:
                print("{0} doesn't have the {1}".format(game_state['npc'].name,
                                                        item_type))
DialogueAction.registerAction(TakeStuffAction)


class GiveStuffAction(InventoryAction):
    """
    L{InventoryAction} used to move items from the player's inventory to the
    NPC's inventory.
    """
    keyword = 'give_stuff'
    
    def __call__(self, game_state):
        """
        Move items from the player's inventory to the NPC's inventory.
        
        @param game_state: variables and functions that make up the current
            game state.
        @type game_state: dict of objects
        """
        item_types = self.item_types
        for item_type in item_types:
            item = game_state['npc'].inventory.findItem(item_type = item_type)
            if (item):
                game_state['pc'].give(item, game_state['npc'])
                print("You give the {0} to {1}".format(item_type,
                                                       game_state['npc'].name))
            else:
                print("You don't have the {0}".format(item_type))
DialogueAction.registerAction(GiveStuffAction)


class QuestAction(DialogueAction):
    """
    Abstract base class for quest-related L{DialogueActions<DialogueAction>}.
    """
    def __init__(self, *args, **kwargs):
        """
        Initialize a new L{QuestAction} instance.
        
        @param args: positional arguments.
        @type args: list of objects
        @param quest_id: ID of the quest to manipulate.
        @type quest_id: basestring
        @param kwargs: keyword arguments (not used).
        @type kwargs: dict of objects
        """
        DialogueAction.__init__(self, *args, **kwargs)
        self.quest_id = kwargs['quest'] if 'quest' in kwargs else args[0]


class StartQuestAction(QuestAction):
    """L{QuestAction} used to activate a quest."""
    keyword = 'start_quest'
    
    def __call__(self, game_state):
        """
        Activate a quest.
        
        @param game_state: variables and functions that make up the current
            game state.
        @type game_state: dict of objects
        """
        quest_id = self.quest_id
        print("You've picked up the \"{0}\" quest!".format(quest_id))
        game_state['quest'].activateQuest(quest_id)
DialogueAction.registerAction(StartQuestAction)


class CompleteQuestAction(QuestAction):
    """
    L{QuestAction} used to mark a quest as successfully finished/completed.
    """
    keyword = 'complete_quest'
    
    def __call__(self, game_state):
        """
        Successfully complete a quest.
        
        @param game_state: variables and functions that make up the current
            game state.
        @type game_state: dict of objects
        """
        quest_id = self.quest_id
        print("You've finished the \"{0}\" quest".format(quest_id))
        game_state['quest'].finishQuest(quest_id)
DialogueAction.registerAction(CompleteQuestAction)


class FailQuestAction(QuestAction):
    """L{QuestAction} used to fail an active quest."""
    keyword = 'fail_quest'
    
    def __call__(self, game_state):
        """
        Fail an active quest.
        
        @param game_state: variables and functions that make up the current
            game state.
        @type game_state: dict of objects
        """
        quest_id = self.quest_id
        print("You've failed the \"{0}\" quest".format(quest_id))
        game_state['quest'].failQuest(quest_id)
DialogueAction.registerAction(FailQuestAction)


class RestartQuestAction(QuestAction):
    """L{QuestAction} used to restart an active quest."""
    keyword = 'restart_quest'
    
    def __call__(self, game_state):
        """
        Restart an active quest.
        
        @param game_state: variables and functions that make up the current
            game state.
        @type game_state: dict of objects
        """
        quest_id = self.quest_id
        print("You've restarted the \"{0}\" quest".format(quest_id))
        game_state['quest'].restartQuest(quest_id)
DialogueAction.registerAction(RestartQuestAction)


class QuestVariableAction(QuestAction):
    """
    Base class for L{QuestActions<QuestAction>} that modify quest
    variables.
    """
    def __init__(self, *args, **kwargs):
        """
        Initialize a new L{QuestVariableAction} instance.
        
        @param args: positional arguments (not used).
        @type args: list of objects
        @param kwargs: keyword arguments.
        @type kwargs: dict of objects
        @keyword quest: ID of the quest whose variable should be modified.
        @type quest: basestring
        @keyword variable: name of the quest variable to modify.
        @type variable: basestring
        @keyword value: new value that should be used to modify the quest
            variable.
        @type value: object
        """
        QuestAction.__init__(self, *args, **kwargs)
        self.variable_name = kwargs['variable']
        self.value = kwargs['value']


class IncreaseQuestVariableAction(QuestVariableAction):
    """
    L{QuestVariableAction} used to increase the value of a quest variable by a
    set amount.
    """
    keyword = 'increase_quest_variable'
    
    def __call__(self, game_state):
        """
        Increase a quest variable by a set amount.
        
        @param game_state: variables and functions that make up the current
            game state.
        @type game_state: dict of objects
        """
        quest_id = self.quest_id
        variable_name = self.variable_name
        value = self.value
        print('Increased {0} by {1}'.format(variable_name, value))
        game_state['quest'][quest_id].increaseValue(variable_name, value)
DialogueAction.registerAction(IncreaseQuestVariableAction)


class DecreaseQuestVariableAction(QuestVariableAction):
    """
    L{QuestVariableAction} used to decrease the value of a quest variable by a
    set amount.
    """
    keyword = 'decrease_quest_variable'
    
    def __call__(self, game_state):
        """
        Decrease a quest variable by a set amount.
        
        @param game_state: variables and functions that make up the current
            game state.
        @type game_state: dict of objects
        """
        quest_id = self.quest_id
        variable_name = self.variable_name
        value = self.value
        print('Decreased {0} by {1}'.format(variable_name, value))
        game_state['quest'][quest_id].decreaseValue(variable_name, value)
DialogueAction.registerAction(DecreaseQuestVariableAction)


class SetQuestVariableAction(QuestVariableAction):
    """
    L{QuestVariableAction} used to set the value of a quest variable.
    """
    keyword = 'set_quest_variable'
    
    def __call__(self, game_state):
        """
        Set the value of a quest variable.
        
        @param game_state: variables and functions that make up the current
            game state.
        @type game_state: dict of objects
        """
        quest_id = self.quest_id
        variable_name = self.variable_name
        value = self.value
        print('Set {0} to {1}'.format(variable_name, value))
        game_state['quest'][quest_id].setValue(variable_name, value)
DialogueAction.registerAction(SetQuestVariableAction)