#!/usr/bin/python
#
# battleman.py - RPG Battle Manager
#
# A table-top RPG battle flow manager
# Tuned pretty specifically to D&D 4e for now... need a templatized system
# to do anything fancier... may develop that at some point.

from dice import Dice
import sys


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 = raw_input("Name: ")
        hp = input_int('hp')
        init_mod = input_int('init mod', 0)
        ap = input_int('action points', 0)
        surges = input_int('healing surges', 0)

        recharges = []
        recharge = '-1'
        while True:
            recharge = raw_input("recharge: ").split(',')
            if recharge == ['']:
                break
            else:
                recharges.append(recharge)

        count = input_int('count', 1)

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

        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


    def roll_init(self):
        d = Dice.from_desc('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.append(c)


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



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.pc = pc
        self.surges = surges
        self.ap = ap
        self.sw = sw
        self.recharges = []
        self.conditions = []
        self.index = Combatant.next_index
        Combatant.next_index += 1


    def add_condition(self, name, cond_type, duration):
        condition = {}
        condition['name'] = name
        condition['duration'] = duration
        self.conditions.append(condition)


    def begin_turn(self):
        print("{} has initiative.".format(self))


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

        self.hp -= amount

        if self.is_bloodied() and not was_bloodied:
            print('{} ({}) is bloodied! Remaining hp: {}'.format(self.name, self.index, self.hp))
        if self.is_down():
            print('{} ({}) is down!'.format(self.name, self.index))


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


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


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

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


    def __str__(self):
        return "{} ({hp} hp)".format(self.name, hp=self.hp)


def input_int(prompt, default=-1):
    if default != -1:
        prompt = prompt + '[{}]'.format(default)
    prompt = prompt + ': '

    data = raw_input(prompt)
    if default != -1 and not data:
        return default
    else:
        return int(data)



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


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


    def add_group(self, group):
        self.groups.append(group)
        for c in group.members:
            self.combatant_hash[c.index] = c


    # fixme: still returns None after battle begins
    def get_current_group(self):
        if self.current:
            return self.groups[self.current]
        else:
            return None


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

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

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

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


    def list_combatants(self):
        for g in self.groups:
            if g.is_solo_group():
                print('{}: {}'.format(g.members[0].index, g.name))
            else:
                print('{}:'.format(g.name))
                for c in g.members:
                    print('\t{}: {} ({})'.format(c.index, c.name, c.get_health_summary()))


    def next_combatant(self):
        print('Sorry, this is still a stub function.')
        g = self.get_current_group()


    def deal_damage(self, index, amount):
        c = self.combatant_hash[index]
        c.damage(amount)


battle = Battle()

def main():
    # hard-coding test cases for now.
    # Eventually, use a state-saving text file that's easy to edit
    battle.add_group(CombatGroup("Adele", [Combatant("Adele", hp=26, pc=True, surges=8, sw=1)], 2))
    battle.add_group(CombatGroup("Aristaire", [Combatant("Aristaire", hp=20, pc=True, surges=6, sw=1)], 0))


    battle.add_group(CombatGroup("Foobolds", [Combatant("Foobold", hp=50), Combatant("Foobold", hp=50), Combatant("Foobold", hp=50), Combatant("Foobold", hp=50), Combatant("Foobold", hp=50)], 20))
    battle.add_group(CombatGroup("Barglins", [Combatant("Barglin", hp=1), Combatant("Barglin", hp=1)], 3))
    battle.add_group(CombatGroup("Orcs of Baz", [Combatant("Orc", hp=32), Combatant("Orc", hp=32)], 1))

    # ngroups = input_int('Number of enemy groups:')
    # for i in range(1, ngroups+1):
    #     print("Adding enemy group {}".format(i))
    #     battle.add_group(CombatGroup.from_input())

    while True:
        do_prompt()


def do_prompt():
    comm = raw_input('> ')

    if comm == '?':
        do_help()
    elif comm == 'a':
        print('Sorry, this is still a stub function.')
    elif comm == 'l':
        battle.list_combatants()
    elif comm == 'b':
        battle.begin()
    elif comm == 'd':
        do_damage()
    elif comm == 'h':
        print('Sorry, this is still a stub function.')
    elif comm == 's':
        print('Sorry, this is still a stub function.')
    elif comm == 'c':
        print('Sorry, this is still a stub function.')
    elif comm == 'r':
        print('Sorry, this is still a stub function.')
    elif comm == 'n':
        battle.next_combatant()
    elif comm == 'w':
        print('Sorry, this is still a stub function.')
    elif comm == 'q':
        sys.exit(0)


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

    battle.list_combatants()
    index = input_int('choose combatant', battle.get_current_group().members[0])
    amount = input_int('damage')
    battle.deal_damage(index, amount)


def do_help():
    print("""Possible commands:
? - print this help menu (yay, you already figured that one out)
a - add more combatants (works during battle)
l - list current combatants
b - begin the battle
d - deal damage to someone
h - heal someone
s - let someone use a healing surge
c - apply a condition
r - remove a condition (this can also happen automatically)
n - next (end the current combat group's turn)
w - wait (remove a combatant from the initiative order and into a separate pool)
q - quit
""")


if __name__ == '__main__':
    main()