import contextlib
import libtcodpy as libtcod
from objects import Object, Fighter
import mods

def get_pos_pair(x,y):
	if y is None:
		if hasattr(x, '__iter__'):
			x,y = x
		elif hasattr(x,'x'):
			x,y = x.x,x.y
		else:
			x,y = x.pos
	return x,y

import collections
class Slot(object):
	def __init__(self):
		self.limit = None
		self.items = []

	@property
	def display_name(self):
		if self.items != []:
			return '%s (x%s)' % (self.items[0].name, len(self.items))

	@property
	def ident(self):
		if self.items != []:
			return self.items[0].name


	def empty(self):
		return len(self.items) == 0

	def _add_item(self, item):
		self.items.append(item)
		return True

	def add_item(self, item):
		result = False
		if self.limit is None or len(self.items) <= self.limit:
			if self.items == []:
				self.limit = item.item.stack_limit
				print 'no items'
				return self._add_item(item)
			elif (len(self.items) < self.limit) and (self.ident == item.name):
				print 'add_items %d' % len(self.items)
				return self._add_item(item)
			elif self.ident != item.name:
				raise ValueError('Cannot stack %s with %s' % (self.ident, item.ident))
		return result

	def get_item(self, default=None):
		result = default
		if self.items != []:
			result = self.items[-1]
		return result

	def consume(self):
		self.items.pop()



class Inventory(object):
	def __init__(self):
		self.objects = {}

	def __iter__(self):
		for v in self.objects.itervalues():
			for i in v:
				yield i

	def __len__(self):
		return sum(len(x) for x in self.objects.values())

	def __contains__(self, it):
		return it.ident in self.objects

	def __getitem__(self, k):
		return self.objects[k][-1].get_item()

	def __setitem__(self, k,v):
		if v.ident != k: raise ValueError('Inventory key must equal the item\'s name')
		self.add_item(v)

	def keys(self):
		return self.objects.keys()

	def add_item(self, item):
		print 'add_item', item.name
		slot = self.objects.setdefault(item.name, [Slot()])
		while not slot[-1].add_item(item):
			print 'add slot'
			slot.append(Slot())

	def __delitem__(self, k):
		self.objects[k][-1].consume()
		while self.objects[k] != [] and self.objects[k][-1].empty():
			self.objects[k].pop()
		else:
			if self.objects[k] == []:
				del self.objects[k]

class Player(Object):
	def triggers_recompute(func):
		def _inner(self, *a, **kw):
			self.fov_recompute = True
			return func(self, *a, **kw)
		return _inner

	@triggers_recompute
	def __init__(self, map, con, x,y, char, color, fighter=None, level=None):
		Object.__init__(self, None, con, x,y, char,
			libtcod.namegen_generate('Celtic male'), color, True, fighter=fighter, level=level
		)

		map.player = self
		self.inventory = Inventory()
		self.mods = Inventory()

		class Item:
			stack_limit = 5
		obj = Object(None, con, None,None, 'b', 'boost', color, item=Item())
		obj.mod = mods.Boost()
		self.mods.add_item(obj)

	def draw(self, player=None):
		if player is None:
			player = self
		return Object.draw(self, player)

	def pick_up(self, obj):
		# TODO: limit number of items
		if len(self.inventory) >= 26:
			game.message('Your inventory is full, cannot pick up %s' % obj.name, libtcod.red)
		elif obj is not None:
			self.inventory.add_item(
				self.level.claim_object(obj).item.bind_user(self) # returns item.owner
			)
			game.message('you picked up a %s!' % obj.name, libtcod.green)
		return self

	def drop(self, obj):
		obj = self.inventory[obj.name]
		obj.x, obj.y = self.x, self.y
		self.level.add_object(obj)
		del self.inventory[obj.name]
		return obj

	def use(self, item):
		item.owner.enter_level(self.level)
		success = item.use()

		if success:
			del self.inventory[item.name]

	@contextlib.contextmanager
	def recategorize_item(self, item_name):
		item = self.inventory[item_name]
		yield item
		del self.inventory[item_name]
		self.inventory.add_item(item)

	def modify(self, item_name, mod_name):
		mod = self.mods[mod_name]
		with self.recategorize_item(item_name) as item:
			item.item.modify(mod.mod)
			del self.mods[mod_name]
		print list(self.mods)

	def unmodify(self, item_name, mod_name):
		with self.recategorize_item(item_name) as item:
			item.item.unmodify(mod_name)
		print list(self.mods)

	def get_mod(self, index):
		return self.mods[index].mod
	def get_mod_names(self):
		return [item.display_name for item in self.mods]
	def get_mods(self):
		return [item for item in self.mods]

	def get_item(self, index):
		return self.inventory[index].item
	def get_item_names(self):
		return [item.display_name for item in self.inventory]
	def get_items(self):
		return [item for item in self.inventory]

	def tick(self):
		if self.fighter:
			self.fighter.tick()

	def can_see(self, x,y=None):
		x,y = get_pos_pair(x,y)
		return self.level.is_visible(x,y)

	torch_radius = 19

	@property
	def pos(self):
		return self.x, self.y
	@pos.setter
	def pos(self, val):
		#print 'pos:', val
		self.x, self.y = val

	@triggers_recompute
	def move(self, dx, dy):
		result = Object.move(self, dx,dy)
		return result

	def move_or_attack(self, dx, dy):
		x = self.x + dx
		y = self.y + dy

		import monsters
		target = monsters.monster_at(x,y)

		if target is not None:
			self.fighter.attack(target)
		else:
			self.move(dx, dy)

	def enter_level(self, level):
		print '\nenter level\n'
		self.level = level
		level.enter(self)
		self.x, self.y = self.level.map.map_entrance
		return self

	def get_room(self):
		for room in self.level.map.gen.rooms:
			if self.pos in room:
				return room


import game