# battle.py
#
# A set of classes and convenience functions
# for representing a D&D 4e battle
#
# future features:
#  * down combatants go into a separate list

from dice import Dice
import easyinput

# data about the battle - includes combatant list, etc
class Battle():
    def __init__(self):
        self.combatant_hash = {}
        self.groups = []
        self.wait_list = {}
        self.current = None
        self.round = None


    def __str__(self):
        ret = ''
        if self.is_started():
            ret = 'Battle underway, currently on round {}\n\n'.format(self.round)
        else:
            ret = 'Battle not yet started\n\n'

        ret = ret + self.format_combatants()

        return ret
        

    def is_started(self):
        return self.current != None


    def add_group(self, group):
        # If battle is already going, need to know
        # where in the init order the new mooks go
        if self.is_started():
            if group.is_solo_group() and group.members[0].pc:
                group.set_init(easyinput.input_int('Initiative for {}'.format(group.name)))
            else:
                group.roll_init()

            added = False
            for i in range(len(self.groups)):
                if group.init > self.groups[i].init:
                    self.groups.insert(i, group)
                    added = True
                    break
            
            if not added:
                self.groups.append(group)
        else:
            self.groups.append(group)

        for i, c in group.members.items():
            self.combatant_hash[i] = c
        

    def get_current_group(self):
        if self.current != None:
            return self.groups[self.current]
        else:
            return None


    # If you're in a multi-member group, the first
    # member of the group gets returned.
    def get_current_combatant(self):
        if self.current != None:
            return self.groups[self.current].get_member_by_pos(0)
        else:
            return None


    def get_combatant(self, index):
        if index in self.combatant_hash:
            return self.combatant_hash[index]
        else:
            return None


    def choose_combatant(self):
        print self.format_combatants()
        index = easyinput.input_int('choose combatant')
        if index not in self.combatant_hash:
            print 'Error: {} is not a valid index'.format(index)
            return self.choose_combatant()
        return self.combatant_hash[index]


    def begin(self):
        if self.is_started():
            print "Error: battle is already running"

        for g in self.groups:
            if g.is_solo_group() and g.get_member_by_pos(0).pc:
                g.set_init(easyinput.input_int('Initiative for {}'.format(g.name)))
            else:
                g.roll_init()

        self.groups.sort(reverse=True, key=lambda group: group.init)
        self.current = 0

        print '\nInitiative Roster:\n'
        for g in self.groups:
            print '{} ({})'.format(g.name, g.init)
        print ''

        self.next_round()
        self.get_current_group().begin_turn()


    # Returns a formatted string with all of the combatants
    def format_combatants(self):
        ret = 'Combatants\n==========\n'

        for g in self.groups:
            if g.is_solo_group():
                ret = ret + '{}\n'.format(g.get_member_by_pos(0))
            else:
                ret = ret + '{}:\n'.format(g.name)
                for c in g.members.values():
                    ret = ret + '  {}\n'.format(c)
        
        if self.wait_list:
            ret = ret + '\nWait List\n=========\n'
            for c in self.wait_list.values():
                ret = ret + '{}\n'.format(c)

        return ret.rstrip()


    # Returns a formatted string with just the current group
    def format_current_group(self):
        if self.validate_started():
            return self.validate_started()

        g = self.groups[self.current]
        if g.is_solo_group():
            return '{}'.format(g.members[0].format_full_info())
        else:
            ret = '{}\n'.format(g.name)
            for c in g.members.values():
                ret = ret + '  {}\n'.format(c)
            return ret.rstrip()


    def next_combatant(self, same_index = False, from_unwait = False):
        if self.validate_started():
            print self.validate_started()
            return

        g = self.get_current_group()

        # If we get here from wait(), we're okay because calling this on the next
        # CombatGroup will fail silently.
        # In the case of unwait(), though, we don't want to end the newly-unwaited
        # group's term prematurely
        if not from_unwait:
            g.end_turn()

        # same_index gets set when we're coming from wait() or unwait()
        if not same_index:
            self.current += 1

        if self.current >= len(self.groups):
            self.current = 0
            self.next_round()

        g = self.get_current_group()

        # We don't have to worry about calling this twice, since
        # there's a sentinel value in CombatGroup
        g.begin_turn()


    def next_round(self):
        if self.round == None:
            self.round = 1
        else:
            self.round += 1

        # Decrement all timed conditions
        for c in self.combatant_hash.values():
            c.tick_conditions()

        print 'Beginning round {}.'.format(self.round)


    def validate_started(self):
        if not self.is_started():
            return 'Error: you can only run this command after starting the battle.'
        return None


    def wait(self, index):
        v = self.validate_started()
        if v:
            print v
            return

        if index in self.wait_list:
            print '{} is already waiting.'.format(self.wait_list[index])
        else:
            c = None
            i = 0
            for group in self.groups:
                c = group.remove_member(index)
                if c:
                    if len(group.members) == 0:
                        del self.groups[i]
                    break
                i += 1

            if c:
                self.wait_list[index] = c
                print '{} is now in the wait list.'.format(c)
                self.next_combatant(same_index = True)
            else:
                print 'Error: Failed to find combatant {}.'.format(index)


    def unwait(self, index):
        v = self.validate_started()
        if v:
            print v
            return

        if index in self.wait_list:
            c = self.wait_list[index]
            del self.wait_list[index]

            # This code is weirdly complicated because we're basically
            # 'hacking' an already-begun turn back into the initiative list
            g = CombatGroup(c.name, {c.index: c}, 0)
            g.turn_began = True
            self.groups.insert(self.current, g)

            print '{} is no longer waiting.'.format(c)
            self.next_combatant(same_index = True, from_unwait = True)

        else:
            if index in self.combatant_hash:
                print '{} is not waiting'.format(self.combatant_hash[index])
            else:
                print "Error: Failed to find combatant {}".format(index)



class CombatGroup():
    # What we're mostly getting here is a definition of the *members*
    # of the group... then we build them all and stick them in
    # the group
    @classmethod
    def from_input(cls):
        name = easyinput.input_str("name")
        hp = easyinput.input_int('hp')
        init_mod = easyinput.input_int('init mod', 0)
        ap = easyinput.input_int('action points', 0)
        surges = easyinput.input_int('healing surges', 0)

        recharges = []
        while True:
            data = []
            data = easyinput.input_str("recharge", default='').split(',')
            if len(data) == 2:
                recharge = {}
                recharge['name'] = data[0]
                recharge['value'] = int(data[1])
                recharge['used'] = False
                recharges.append(recharge)
            else:
                break

        count = easyinput.input_int('count', 1)

        # Now make the combatants...
        members = {}
        for i in range(count):
            c = Combatant(name, hp, pc=False, surges=surges, ap=ap, sw=0, recharges=recharges)
            members[c.index] = c

        if count > 1:
            name = name + 's'

        return CombatGroup(name, members, init_mod)


    def __init__(self, name, members, init_mod=0):
        self.name = name
        self.members = members
        self.init_mod = init_mod
        self.init = 0
        self.turn_began = False


    def roll_init(self):
        d = Dice.from_str('1d20+{}'.format(self.init_mod))
        self.set_init(d.roll()['total'])


    def set_init(self, init):
        self.init = init


    def add_member(self, c):
        self.members[c.index] = c


    # Removes the member from the group and returns her
    def remove_member(self, index):
        if index not in self.members:
            return None

        c = self.members[index]
        del self.members[index]
        return c


    def get_member(self, index):
        if index in self.members:
            return self.members[index]
        else:
            return None


    def get_member_by_pos(self, pos):
        if pos >= len(self.members):
            return None
        else:
            return self.members.values()[pos]


    def is_solo_group(self):
        return len(self.members) == 1


    def begin_turn(self):
        if self.turn_began:
            return

        print '{} {} initiative.'.format(self.name, ['has', 'have'][len(self.members) != 1])

        for c in self.members.values():
            c.begin_turn()

        self.turn_began = True


    def end_turn(self):
        if not self.turn_began:
            return
        
        for c in self.members.values():
            c.end_turn()
        self.turn_began = False




class Combatant():
    next_index = 0

    def __init__(self, name, hp, pc=False, init_mod=0, surges=0, ap=0, sw=0, recharges=[]):
        self.name = name
        self.max_hp = hp
        self.hp = self.max_hp
        self.temp_hp = 0
        self.pc = pc
        self.surges = surges
        self.ap = ap
        self.sw = sw
        self.conditions = {}
        self.index = Combatant.next_index
        self.next_condition_index = 0
        Combatant.next_index += 1

        self.recharges = {}
        recharge_index = 0
        for r in recharges:
            r['index'] = recharge_index
            r['just_used'] = False
            self.recharges[recharge_index] = r
            recharge_index += 1


    def __str__(self):
        return "{}: {} ({})".format(self.index, self.name, self.format_health_summary())


    # cond_type can be 's' or 't', for 'save' or 'timed'. If it is 't', condition expires at the end of the players turn
    # 'duration' rounds from now
    def add_condition(self, name, cond_type, duration=None, end_type='e'):
        condition = {}
        condition['name'] = name
        condition['cond_type'] = cond_type
        condition['duration'] = duration
        condition['end_type'] = end_type
        condition['index'] = self.next_condition_index
        if cond_type == 'timed' and duration == None:
            print 'Error: specified a timed condition with no duration.'
            return
        self.conditions[self.next_condition_index] = condition
        self.next_condition_index += 1

        
    # Removes a condition, prints a message about it, and returns a copy of the condition
    def remove_condition(self, index):
        if index not in self.conditions:
            print "Error: invalid condition index."
            return None

        c = self.conditions.pop(index)
        print '{} is no longer affected by {}.'.format(self, c['name'])

        return c


    def choose_condition(self):
        if not len(self.conditions):
            print '{} has no conditions.'.format(self)
            return None

        print self.format_condition_summary()
        index = easyinput.input_int('choice')

        if index not in self.conditions:
            print 'Error: {} is not a valid index'.format(index)
            return self.choose_condition()

        return self.conditions[index]


    def tick_conditions(self):
        for c in self.conditions.values():
            if c['cond_type'] == 't':
                c['duration'] -= 1


    def begin_turn(self):
        for c in self.conditions.values():
            if c['cond_type'] == 't' and c['end_type'] == 's':
                if c['duration'] <= 0:
                    self.remove_condition(c['index'])
                else:
                    print '{} is still affected by {} ({} round{} left).'.format(self, c['name'], c['duration'], 's'[c['duration']==1:])


    def end_turn(self):
        for c in self.conditions.values():
            if c['cond_type'] == 's':
                r = None
                if self.pc:
                    print '{}: save against {}.'.format(self, c['name'])
                    r = easyinput.input_int('saving throw')
                else:
                    save_die = Dice.from_str('1d20')
                    r = save_die.roll()['total']

                if r >= 10:
                    self.remove_condition(c['index'])
                    print '{} successfully saved against {}.'.format(self, c['name'])
                else:
                    print '{} failed a save against {}.'.format(self, c['name'])

            elif c['cond_type'] == 't' and c['end_type'] == 'e':
                if c['duration'] <= 0:
                    self.remove_condition(c['index'])
                else:
                    print '{} is still affected by {} ({} round{} left).'.format(self, c['name'], c['duration'], 's'[c['duration']==1:])

        for r in self.recharges.values():
            if r['used']:
                if r['just_used']:
                    r['just_used'] = False
                    continue

                # Roll to recharge
                d = Dice.from_str('1d6')
                n = d.roll()['total']
                if n >= r['value']:
                    r['used'] = False
                    print '{} can use {} again!'.format(self, r['name'])


    def damage(self, amount):
        was_bloodied = self.is_bloodied()

        if self.temp_hp > 0:
            self.temp_hp -= amount
            if self.temp_hp < 0:
                amount = abs(self.temp_hp)
                self.temp_hp = 0

        self.hp -= amount

        print '{} took {} points of damage.'.format(self, amount)

        if self.is_down():
            print '{} is down!'.format(self)
        elif self.is_bloodied() and not was_bloodied:
            print '{} is bloodied!'.format(self)


    def heal(self, amount):
        was_down = self.is_down()
        was_bloodied = self.is_bloodied()

        if self.hp < 0:
            self.hp = 0

        amount_healed = amount
        if self.hp + amount_healed > self.max_hp:
            amount_healed = self.max_hp - self.hp

        self.hp += amount_healed

        if was_down:
            print '{} regains consciousness.'.format(self)

        print '{} regained {} hit points.'.format(self, amount_healed)

        if was_bloodied and not self.is_bloodied():
            print '{} is no longer bloodied.'.format(self)
        elif was_bloodied and self.is_bloodied():
            print '{} is still bloodied.'.format(self)


    def add_temp_hp(self, amount):
        self.temp_hp += amount

        print '{} gained {} temporary hit points.'.format(self, amount)


    def use_surge(self, heal=True):
        if self.surges <= 0:
            print '{} has no healing surges.'.format(self)
            return
        
        self.surges -= 1
        noheal = ''
        if not heal:
            noheal = " (but didn't regain hit points)"
        print '{} spent a healing surge{}.'.format(self, noheal)

        if heal:
            self.heal(self.max_hp / 4)


    def use_second_wind(self):
        if self.sw <= 0:
            print "{} doesn't have a second wind.".format(self)
            return
        
        self.surges -= 1

        print '{} got their second wind!'.format(self)

        # Now the actual effects of the SW
        self.use_surge()
        self.add_condition('Second Wind (+2 all def)', 't', 1)


    def use_recharge_power(self, index):
        if index not in self.recharges:
            print "Error: Invalid recharge index"
            return

        self.recharges[index]['used'] = True
        self.recharges[index]['just_used'] = True


    def choose_recharge_power(self):
        if not len(self.recharges):
            print '{} has no rechargable powers.'.format(self)
            return None

        print self.format_recharge_summary()
        index = easyinput.input_int('choice')

        if index not in self.recharges:
            print 'Error: {} is not a valid index'.format(index)
            return self.choose_recharge_power()

        return self.recharges[index]


    def is_bloodied(self):
        return self.hp <= self.max_hp / 2


    def is_down(self):
        return self.hp <= 0


    def format_full_info(self):
        return """{name}
{separator}
index:      {index}
hp:         {hp}/{max_hp}
temp hp:    {temp_hp}
surges:     {surge}
ap:         {ap}
sw:         {sw}
conditions:
{conditions}
recharge powers:
{recharge}""".format(index=self.index, name=self.name, hp=self.hp, max_hp=self.max_hp, temp_hp=self.temp_hp, surge=self.surges, ap=self.ap, sw=self.sw, conditions=self.format_condition_summary('  '), recharge=self.format_recharge_summary('  '), separator='='*len(self.name))


    def format_health_summary(self):
        bloodied = ''
        temp_info = ''
        if self.is_bloodied():
            bloodied = ', bloodied'
        if len(self.conditions):
            bloodied = bloodied + ', '

        if self.temp_hp > 0:
            temp_info = ', {} temp hp'.format(self.temp_hp)

        return '{} hp{}{}{}'.format(self.hp, temp_info, bloodied, ', '.join([x['name'] for x in self.conditions.values()]))


    def format_condition_summary(self, initial=''):
        summary = ''
        for (index, c) in self.conditions.items():
            type_string = ''
            if c['cond_type'] == 's':
                type_string = 'Save Ends'
            elif c['cond_type'] == 't':
                type_string = '{} Round{}'.format(c['duration'], 's'[ c['duration']==1: ] )
            summary = summary + '{}{}: {} ({})\n'.format(initial, index, c['name'], type_string)

        return summary.rstrip()

    def format_recharge_summary(self, initial):
        summary = ''
        for (index, r) in self.recharges.items():
            summary = summary + '{}{}: {} (Recharge: {}, Available: {})\n'.format(initial, index, r['name'], r['value'], ['Yes', 'No'][ r['used'] ])
        return summary.rstrip()




# Data parsing helper function
# Modelled on the data_input functions in easyinput
def do_combatant_select(battle, data):
    c = None

    if len(data) >= 1:
        c = battle.get_combatant(int(data[0]))
        if not c:
            print 'Error: Invalid combatant index.'
    else:
        c = battle.get_current_combatant()
        if not c:
            print 'Error: Battle not started and no combatant specified.'
    
    return c


# Read combatant/groups in from a file, return a simple list of CombatGroups
def combatgroups_from_file(filename):
    ret = []

    with open(filename, 'r') as f:
        group_data = {}

        for line in f.read().split('\n'):
            line = line.strip()

            if line == '':
                if group_data == {}:
                    continue

                g = _build_group_from_file_data(group_data)
                if g is not None:
                    ret.append(g)
                else:
                    print 'Error: Failed to read a group definition from file: {}'.format(filename)
                group_data = {}

            else:
                try:
                    var, value = line.split('=')
                except ValueError:
                    print 'Error: Bad value in data file. No data from file parsed.'
                    return []

                group_data[var] = value

    return ret


def _build_group_from_file_data(data):
    if not _validate_group_data(data):
        return None

    if 'count' in data:
        if 'groupname' in data:
            gname = data['groupname']
        else:
            gname = data['name'] + 's'

        count = int(data['count'])
    else:
        count = 1
        gname = data['name']

    members = {}
    for i in range(count):
        c = Combatant(data['name'], int(data['hp']), data['pc'],
                      int(data['init']), int(data['surges']),
                      int(data['ap']), data['sw'], data['recharges'])
        members[c.index] = c

    return CombatGroup(gname, members, data['init'])


def _validate_group_data(data):
    if not 'pc' in data:
        data['pc'] = False

    if not 'ap' in data:
        data['ap'] = 0

    if not 'init' in data:
        data['init'] = 0

    if not 'surges' in data:
        data['surges'] = 0

    if not 'count' in data:
        data['count'] = 1

    if not 'recharges' in data:
        data['recharges'] = []

    if data['pc']:
        data['sw'] = 1
    else:
        data['sw'] = 0

    return 'name' in data and 'hp' in data