from src import events

 import abc

 import collections

 from . import combat

 
 class Overlay(object):

 	__metaclass__ = abc.ABCMeta

 
 	char = abc.abstractproperty()
 	color = (0,0,0)
 	blocks = False
 
 	@property
 	def pos(self):
 		return self.x, self.y
 	def __init__(self, x,y, map):

 		super(Overlay, self).__init__()

 		print self.handled_events

 		self.events = collections.OrderedDict()

 		self.x = x
 		self.y = y
 		self.map = map

 		for key, value in self.handled_events.viewitems():
 			self.events.setdefault(key, []).extend(value)
 

 	def draw(self):
 		self.map.add(self)

 	def register_event(self, event, cb):
 		'''register a callback for an event
 
 		if the callback returns a false value besides None, execution will end after that event'''
 		self.events.setdefault(event, []).append(cb)
 
 	def trigger_event(self, event, *args, **kw):

 		for cb in self.events.get(event, []):

 			result = cb(self, *args, **kw)
 			result = result is None or result # if the event returns a false value besides None, break
 			if result == False: break
 

 	@staticmethod
 	def add_event(event,  cb_name):
 		def _inner(cls):
 			if not hasattr(cls,  'handled_events'):
 				cls.handled_events = {}
 				for base in cls.bases:
 					if hasattr(base,  'handled_events'):
 						cls.handled_events.update(base.handled_events)
 			cls.handled_events.setdefault(event,  []).append(getattr(cls,  cb_name))
 			return cls

 		return _inner
 

 	def tick(self):
 		pass

 @Overlay.add_event('attacked',  'attacked_by')
 @Overlay.add_event('bumped',  'bumped_by')

 class Actor(Overlay):
 	char = ord('@')
 	color = (255,0,0)
 	blocks = True
 

 	handled_events = collections.OrderedDict()

 	@property
 	def pos(self):
 		return self.x, self.y
 
 	def __init__(self, x,y, map, adventurer=None):

 		super(Actor, self).__init__(x,y, map)
 		self.inventory = []

 		if adventurer is None:
 			adventurer = combat.Adventurer.randomize()
 		self.adventurer = adventurer

 		self.repeated_actions = {}

 	def add_repeated_action(self, time, action, *args, **kw):
 		print 'adding action', action, args, kw
 		self.repeated_actions.setdefault(time, []).append( (action, args, kw) )
 
 	def update_pos(self, dx,dy):

 		self.x += dx
 		self.y += dy
 

 	def move(self, dx, dy):
 		print 'moving'
 		self.map.move(self, dx,dy, self.update_pos)
 

 	def tick(self):

 		result = True
 		if self.adventurer.state >= 2:
 			result = False
 			self.char = ord('%')
 			self.blocks = False

 		else:

 			self.act()

 			ractions = {}
 			for nleft, actions in self.repeated_actions.items():
 				for (action,args,kwargs) in actions:
 					print action,args,kwargs
 					action(*args, **kwargs)
 					if nleft > 1:
 						ractions.setdefault(nleft-1, []).append( (action,args,kwargs) )

 				print ractions

 			self.repeated_actions = ractions

 		return result

 	def act(self): pass
 

 	def ishostile(self, other):

 		return self.adventurer.state < 2 #TODO: implement factions

 	def bump(self, other):
 		print '%s bumped %s' % (type(self).__name__, type(other).__name__)

 		if isinstance(other, Actor) and other.ishostile(self):
 			self.adventurer.attack(other.adventurer)

 			other.trigger_event('attacked', self)

 
 	def interact(self, other):
 		result = False
 		if isinstance(other, Object):
 			result = True

 			self.pickup(other)
 			other.trigger_event('picked_up', self)

 		other.trigger_event('bumped', self)

 		return result
 
 	def pickup(self, other):
 		self.inventory.append(other)

 	def attacked_by(self, other):

 		if self.adventurer.skills.check('agility'):

 			self.adventurer.attack(other.adventurer)
 

 	def bumped_by(self, other):
 		print '%s was bumped by %s' % (type(self).__name__, type(other).__name__)
 

 import random
 class AIActor(Actor):
 	def act(self):
 		print 'wiggly %s' % self.adventurer.name
 		self.move(random.choice([-1,0,1]), random.choice([-1,0,1]))
 

 @Overlay.add_event('picked_up',  'picked_up_by')
 @Overlay.add_event('bumped',  'bumped_by')

 class Object(Overlay):

 	item = None

 	handled_events = collections.OrderedDict()

 	def picked_up_by(self, other):

 		events.EventHandler().trigger_event('msg', 'picked up a %s' % self)

 		self.map.remove(self)

 	def bumped_by(self, other): pass

 class Weapon(Object):
 	item = None

 
 class Potion(Object):
 	char = ord('!')

 	def __str__(self): return 'potion'

 class Scroll(Object):
 	char = ord('!')

 
 class Equipment(Object):
 	pass