from . import dice

from .combat_parts import races
from .combat_parts import equipment
from .combat_parts import skills
from .combat_parts import constants as const

from src import events
eh = events.EventHandler()

import collections
import random

def get_stats(sum_):
	stats = [sum_/4]*4
	if sum(stats) != sum_:
		stats[0] += sum_ - sum(stats)

	mod = +1
	for x in range(100):
		idx = random.choice([x for x in range(len(stats)) if stats[x] > 3])
		stats[idx] += mod
		mod *= -1
	return stats

class Attributes(object):
	@classmethod
	def randomize(cls, sum_):
		chosen_stats = get_stats(sum_)
		return cls(*chosen_stats)

	def __init__(self, strength, intellect, dexterity, spirit):
		self.str = strength
		self.int = intellect
		self.dex = dexterity
		self.spt = spirit
		self.state = const.HEALTHY
	def __str__(self):
		return '%s %s %s %s %s' % (self.str, self.int, self.dex, self.spt, self.state)


@equipment.Slot.add_slot('weapon', equipment.Weapon)
@equipment.Slot.add_slot('armor', equipment.Armor)
class Adventurer(object):
	@property
	def state(self):
		return self.attributes.state
	@state.setter
	def state(self, val):
		if val < 0: val == 0
		if val > const.KNOCKOUT: val = const.KNOCKOUT
		self.attributes.state = val

	@property
	def readable_state(self):
		return ['healthy', 'wounded', 'knocked out'][self.state if self.state < 3 else 2]

	@classmethod
	def randomize(cls, stat_sum=28):
		name = '%s %s%s' % (
			random.choice(['Bill', 'Bob', 'Jerry']),
			random.choice(['Longnose', 'Short-Tail', 'Squint']),
			random.choice(['', ' the Great', ' The Cross-eyed', ' The Magnificent'])
		)
		race = races.Race.random_race()
		attr = Attributes.randomize(stat_sum)
		print attr
		return cls(name, race, attr)

	@classmethod
	def with_stats(cls, name, race, str, int, dex, spt):
		attr = Attributes(str, int, dex, spt)
		return cls(name, race, attr)

	def __init__(self, name, race, attr):
		self.name = name
		self.attributes = attr
		self.skills = skills.Skills(self.attributes)
		self.race = races.Race.registry[race](self.attributes)

	def wield(self, slot, equipment):
		turns = 1
		if self.equipment_slots[slot].filled(self):
			turns += 1
		self.equipment_slots[slot].setitem(self, equipment)
		return turns

	def attack(self, opponent, type='fighting', num_allies=0):
		dieroll = dice.DieRoll()

		ally_bonus = -1 if num_allies > 0 else 0
		# TODO: implement professions, figure out how to mod ally_bonus for thieves cleanly
		dieroll.add_adjustment(add=ally_bonus)

		pass_, damage = self.skills.check(type, dieroll)
		if pass_:
			if self.weapon is not None:
				damage += self.weapon.damage_mod
			eh.trigger_event('msg',
				'%s inflicts %d damage upon %s' % (self.name, damage, opponent.name)
			)
			opponent.take_damage(damage)

	def take_damage(self, damage):
		if self.armor is not None:
			damage += self.armor.damage_mod

		dieroll = dice.DieRoll()
		dieroll.add_adjustment(-damage)

		result, __ = self.skills.check('toughness', dieroll)

		if not result:
			if damage > 0:
				self.state += 1
				eh.trigger_event('msg',
					'%s takes %d damage and is now %s' % (self.name, damage, self.readable_state)
				)
				if self.state >= const.KNOCKOUT:
					self.die()

	def die(self): pass

if __name__ == '__main__':
	a = Adventurer.randomize(28)
	b = Adventurer.randomize(28)

	while const.KNOCKOUT not in {a.state, b.state}:
		a.attack(b)
		b.attack(a)

	print a.name, 'is', ['healthy', 'wounded', 'ko'][a.state if a.state < 3 else 2]
	print b.name, 'is', ['healthy', 'wounded', 'ko'][b.state if b.state < 3 else 2]