from __future__ import division

 import collections

 import os.path
 import glob
 import yaml

 import libtcodpy as libtcod
 import game
 import objects
 import utilities
 import monsters
 import random

 from main import Game

 
 
 class Item(object):

 	stack_limit = 5

 	potency = None
 	item_class = None
 	distance = None
 	probability = 1
 

 	def __init__(self, stackable=False):

 		self.mods = collections.defaultdict(set)

 	def __new__(*args):
 		res = object.__new__(*args)
 		return res

 	def bind_game(self, game):
 		self.game = game
 	def bind_user(self, user):
 		self.user = user
 		return self.owner
 	def free_user(self):
 		self.user = None
 		return self.owner
 

 	def modify(self, mod):
 		undo = mod.modify(self)
 		self.mods[mod.name].add(mod)
 		self.owner.name = self.name
 
 	def unmodify(self, mod):
 		if hasattr(mod, 'upper'):
 			mods = self.mods[mod]
 		else:
 			mods = self.mods[mod.name]
 		if mods != set():
 			mod = mods.pop()
 			mod.revert(self)
 			self.owner.name = self.name
 			if mods == set():
 				self.mods.pop(mod.name)
 			print 'self.mods', self.mods
 

 class ItemLoader(object):
 	def __init__(self, dir):
 		self.dir = dir
 
 	def load_items(self):
 		for fn in glob.glob(os.path.join(self.dir,'*.yml')):
 			print 'fn', fn
 			for doc in yaml.safe_load_all(file(fn)):
 				self.load_item(doc)
 
 	def load_item(self, doc):

 		if doc is None: return
 

 		_color = doc.get('color', None)
 		if _color is None:
 			_color = libtcod.green
 		elif hasattr(_color, 'upper'):
 			_color = getattr(libtcod, _color)
 		else:
 			_color = libtcod.Color(*_color)
 
 		item_class = doc['item_class']
 		module, clas = item_class.rsplit('.',1)
 		module = __import__(module)
 		item_class = getattr(module, clas)
 		print 'item class:', item_class
 
 		print 'loading', doc
 		@Game.register_item_type(doc['spawn_chance'])
 		class LoadedItem(item_class):
 			name = doc.get('item_description')
 			char = doc.get('char', '!')
 			color = _color

 			stack_limit = doc.get('stack_limit', Item.stack_limit)

 			potency = doc.get('potency')
 			distance = doc.get('distance')

 @Game.register_item_type(10)

 class HealingPotion(Item):
 	name = 'Healing potion'
 	char = '\x03'
 	color = libtcod.violet

 	potency = 15

 	item_class = 'healing'

 	def use(self):
 		fighter = self.user.fighter
 
 		result = True
 		if fighter.hp == fighter.max_hp:

 			self.game.message('Full health, can\'t heal', libtcod.red)

 			result = False
 		else:

 			self.game.message('Healing...')

 			fighter.heal(self.potency)

 
 		return result
 

 @Game.register_item_type(7)

 class SuperHealingPotion(Item):
 	name = 'Super healing potion'
 	char = '\x03'
 	color = libtcod.yellow

 	probability = .5
 	potency = 10
 	item_class = 'healing'

 	def use(self):
 		fighter = self.user.fighter

 		if random.random() < self.probability:
 			fighter.max_hp += self.potency
 		fighter.heal(self.potency)

 		return True
 
 @Game.register_item_type(1)
 class Confusion(Item):
 	name = 'Confusion'
 	char = 'c'
 	color=libtcod.dark_chartreuse

 	item_class = 'monster defense'

 	def use(self):
 		monster = monsters.get_closest_monster(self.user)
 
 		result = False
 		if monster is not None:

 			self.game.message('%s becomes confused' % monster.name)

 			monsters.ConfusedMonster(random.randrange(10,18)).attach(
 				monster
 			)
 			result = True
 
 		return result
 
 @Game.register_item_type(4)
 class Strengthen(Item):
 	name = 'Strengthen'
 	char = 's'
 	color = libtcod.chartreuse

 	item_class = 'attack'
 	potency = 20

 	def use(self):
 		if self.user.fighter:

 			self.game.message('%s feels a surge of strength' % self.user.name)

 			self.user.fighter.stat_adjust(self.potency, self.adj)

 		return True
 
 	def adj(self, owner):
 		return (

 			lambda _: self.game.message('The surge of strength has subsided'),

 			owner.fighter.defense,
 			owner.fighter.power+3
 		)
 
 @Game.register_item_type(4)
 class Protect(Item):
 	name = 'Protect'
 	char = 'p'
 	color = libtcod.chartreuse

 	item_class = 'defense'
 	potency = 15

 	def use(self):
 		if self.user.fighter:

 			self.game.message('%s is surrounded by a protecting aura' % self.user.name)

 			self.user.fighter.stat_adjust(self.potency, self.adj)

 		return True
 
 	def adj(self, owner):
 		return (

 			lambda _: self.game.message('The protecting aura dissipates'),

 			owner.fighter.defense+6,
 			owner.fighter.power
 		)
 
 @Game.register_item_type(2)
 class LightningBolt(Item):
 	name = 'Lightning Bolt'
 	char = 'z'
 	color = libtcod.darkest_red

 	item_class = 'attack'
 	potency = 13

 	def use(self):
 		monster = monsters.get_closest_monster(self.user)
 		result = False
 		if monster and self.user.can_see(monster.x, monster.y):

 			self.game.message('Monster %s has been struck by lightning' % monster.name)

 			monster.fighter.take_damage(self.potency)

 			result = True
 		else:

 			self.game.message('No target')

 		return result
 

 @Game.register_item_type(5)
 class Jump(Item):
 	name = 'Jump'
 	char = 'j'
 	color= libtcod.dark_green

 	distance = 3
 	item_class = 'movement'

 	def use(self):

 		self.game.select(self.jump)

 		return True
 	def jump(self, x,y):
 		dist = self.user.distance(x,y)
 

 		if dist <= self.distance:

 			self.user.x, self.user.y = x,y

 			self.game.message('you are transported to a new place')

 		elif random.random() < self.distance/dist:

 			self.user.x, self.user.y = x,y

 			self.game.message('you strain all your power to move %d squares' % int(dist))

 		else:

 			self.game.message('you didn\'t make it')

 			self.user.fighter.take_damage( int(round(2 * dist/self.distance)) )

 
 @Game.register_item_type(3)
 class Acquire(Item):
 	name = 'Acquire'
 	char = 'a'
 	color= libtcod.dark_green
 	effect_distance = 5

 	item_class = 'pickup'

 	def use(self):

 		self.game.message('what do you want?')
 		self.game.select(self.get)

 		return True
 	def get(self, x,y):
 		if self.user.distance(x,y) < self.effect_distance:
 			self.user.pick_up(self.user.object_at(x,y))
 

 
 @Game.register_item_type(1)
 class Smite(Item):
 	name = 'Smite'
 	char = '\x0f'
 	color = libtcod.red

 	item_class = 'attack'
 	potency = 10

 	def use(self):

 		self.game.select(self.smite)

 		return True
 
 	def smite(self, x,y):
 		monster = monsters.monster_at(x,y)
 		if monster:

 			monster.fighter.take_damage(self.potency)

 			if monster.fighter:

 				self.game.message('%s is smitten, he only retains %s hp' % (monster.name, monster.fighter.hp))

 			else:

 				self.game.message('%s thought it better to go elsewhere' % monster.name)

 @Game.register_item_type(2)

 class Fireball(Item):
 	name = 'Fireball'
 	char = '*'
 	color = libtcod.darker_red

 	effect_radius = 5

 	potency = (20,6)
 	item_class = 'splash attack'

 
 	def use(self):

 		self.game.select(self.smite)

 		return True
 
 	def smite(self, x,y):

 		if random.random() < .1:

 			self.game.message('the fireball is amazingly effective', libtcod.green)

 			self.effect_radius *= 2
 

 		direct_damage, splash_damage = self.potency

 		strikes = []
 		for obj in self.owner.level.objects:
 			if obj.fighter and obj is not self.user:
 				if (obj.x, obj.y) == (x,y):

 					self.game.message('%s takes a direct hit from the fireball' % obj.name)

 					obj.fighter.take_damage(direct_damage)

 				elif obj.distance(x,y) < self.effect_radius:

 					obj.fighter.take_damage(splash_damage)

 					if obj.fighter:
 						strikes.append('%s %s' % (obj.name, obj.fighter.hp))
 					else:
 						strikes.append('%s dead' % obj.name)

 		self.game.message('The names of those who were to close for comfort: %s' % ', '.join(strikes))