import numpy as np
 import libtcodpy as tc

 import yaml

 import libs.bresenham

 import libs.cache

 
 def squeeze(val, low, high):
 	return min(max(val, low), high)
 

 class TerrainGen(object):
 	def __init__(self, map):
 		self.width, self.height = map.dim
 		self.terrain_registry = map.terrain_registry
 
 	def generate(self):
 		w,h = self.width, self.height

 		terrains, probs = self.terrain_registry.get_terrain_types()
 		map = np.random.choice(terrains, (w,h), p=probs)

 		chars = np.zeros((w,h)).astype('int')
 		fgcolors = np.zeros((w,h,3))
 		bgcolors = np.zeros((w,h,3))
 
 		for x, row in enumerate(map):
 			for y, cell in enumerate(row):

 				char, fgcolor, bgcolor = self.terrain_registry.get_display(cell)

 				chars[x,y] = char
 				fgcolors[x,y] = fgcolor
 				bgcolors[x,y] = bgcolor
 		return map, chars, fgcolors, bgcolors
 
 

 class Map(object):

 	def __init__(self, w, h, terrain_registry):
 		self.pov = None

 		self.povcache = libs.cache.Cache()
 

 		self.width = w
 		self.height = h

 		self.terrain_registry = terrain_registry

 		self.overlays = {} # (x,y): { set( object, ... ) }
 

 		self.ids, self.map, self.fgcolors, self.bgcolors = TerrainGen(self).generate()
 
 		self.fov = FovCache(self, self.terrain_registry)
 

 	def add(self, object):
 		self.overlays.setdefault(object.pos,[]).append(object)
 

 	def check_and_execute_bump(self, object, x,y):
 		if (x,y) in self.overlays:
 			for other in self.overlays[x,y]:
 				object.bump(other)
 

 	def interact(self, a, bs):
 		print 'interacting with:', bs
 		for b in bs:
 			a.interact(b)

 	def remove(self, object):
 		pos = object.pos
 		if pos in self.overlays and object in self.overlays[pos]:
 			self.overlays[pos].remove(object)
 
 	def move(self, object, dx,dy, update_cb):
 		ox,oy = object.pos

 		if abs(dx) < 2 and abs(dy) < 2:

 			self.overlays[object.pos].remove(object)
 
 			collide_x, collide_y = None, None

 			x = squeeze(ox+dx, 0, self.width-1)
 			y = squeeze(oy+dy, 0, self.height-1)

 			if not self.is_passable((x,y)):

 				collide_x, collide_y = x,y

 				x,y = ox,oy

 			update_cb(x-ox, y-oy)
 
 			if collide_x is not None:
 				self.check_and_execute_bump(object, collide_x, collide_y)
 			if object.pos in self.overlays:
 				self.interact(object, self.overlays[object.pos])

 			self.overlays.setdefault((x,y), []).append(object)
 			self.update_overlay(ox,oy)

 		else:

 			# calculate the deltas for each step
 			line = list(libs.bresenham.line(0,0, dx,dy, 0))
 			line = [(bx-ax, by-ay) for (ax,ay), (bx,by) in zip(line,line[1:])]
 			print line
 			for x,y in line:
 				if self.move(object, x,y, update_cb) != (x,y):

 					break

 			x,y = object.pos

 		return x-ox, y-oy
 
 	def update_overlay(self, x=None, y=None):
 		if x is None or y is None: pass
 		else:
 			if (x,y) in self.overlays and self.overlays[x,y] == []:
 				self.overlays.pop((x,y))
 

 	def set_pov(self, pov):
 		self.pov = pov
 
 	def get_visible_objects(self):
 		o,r = self.pov
 		results = set()
 		for x,y in self.overlays:
 			if self.fov.is_visible(o,r, (x,y)):
 				results.update(self.overlays[x,y])
 		return results
 
 
 

 	def get_rgb(self, colors, fg=True,slices=(slice(0),slice(0))):

 		result = np.rollaxis(colors, 2)

 		return [x.transpose() for x in result]
 
 	def draw(self, con, tl=(0,0)):

 		def mv(x,y, (lx,ty)):
 			return x-lx, y-ty

 		br = tl[0]+con.width, tl[1]+con.height

 		slices = slice(tl[0], br[0]), slice(tl[1], br[1])

 
 		fgcolors = self.fgcolors.astype('int')
 		bgcolors = self.bgcolors.astype('int')
 		color_mask = np.ones( (con.width, con.height, 3) )
 		char_mask = np.ones( (con.width, con.height) ).astype('bool')

 		self.pov = None

 		if self.pov is not None:
 			origin, radius = self.pov

 			ox, oy = origin
 			if ox+radius >= br[0] or oy+radius >= br[1]:
 				xmod, ymod = 0,0
 				if ox + radius >= br[0]:
 					xmod = min(ox + radius - br[0], self.width - br[0])
 				if oy + radius >= br[1]:
 					ymod =  min(oy + radius - br[1], self.height - br[1])
 				br = br[0] + xmod, br[1] + ymod
 				tl = tl[0] + xmod, tl[1] + ymod
 				slices = slice(tl[0], br[0]), slice(tl[1], br[1])

 			def calc_mask():
 				for x in range(tl[0], br[0]):
 					for y in range(tl[1], br[1]):
 						if not self.fov.is_visible(origin, radius, (x,y)):

 							color_mask[x-tl[0], y-tl[1]] = (0.25, 0.5, 0.5)
 							char_mask[x-tl[0], y-tl[1]] = False

 				return color_mask, char_mask

 			color_mask, char_mask = self.povcache.get( (origin,radius,tl), calc_mask )
 			fgcolors = (fgcolors[slices] * color_mask).astype('int')
 			bgcolors = (bgcolors[slices] * color_mask).astype('int')
 		else:
 			fgcolors = fgcolors[slices]
 			bgcolors = bgcolors[slices]

 		tc.console_fill_foreground(con.con, *self.get_rgb(fgcolors))
 		tc.console_fill_background(con.con, *self.get_rgb(bgcolors, False))

 
 		chars = np.copy(self.map[slices])
 		for x,y in self.overlays:
 			screen_x = x-tl[0]
 			screen_y = y-tl[1]

 			if (not (tl[0] <= x < br[0])) or (not (tl[1] <= y < br[1])): continue
 			elif not char_mask[screen_x,screen_y]: continue

 			if 0 <= screen_x < con.width and 0 <= screen_y < con.height:
 				obj = self.overlays[x,y][-1]
 				chars[screen_x,screen_y] = obj.char

 				tc.console_set_char_background(con.con, screen_x,screen_y, tc.Color(*bgcolors[screen_x,screen_y]))
 				tc.console_set_char_foreground(con.con, screen_x,screen_y, tc.Color(*obj.color))
 		chars[np.logical_not(char_mask)] = ord(' ')

 		tc.console_fill_char(con.con, chars.transpose())

 
 	def coord_iter(self):
 		return ( (x,y) for x in range(self.width) for y in range(self.height) )
 
 	@property
 	def dim(self):
 		return self.width, self.height
 

 	def is_passable(self, coord):
 		if coord in self.overlays and any(x.blocks for x in self.overlays[coord]):
 			return False
 		else:
 			return self.fov.is_passable(coord)
 

 
 class FovCache(object):
 	# TODO: get allow updates to base_map
 	def __init__(self, map, terrain_registry):

 		self.width, self.height = map.dim
 

 		self.base_map = tc.map_new(*map.dim)
 
 		for x,y in map.coord_iter():
 			if (x,y) in map.overlays:
 				object = map.overlays[x,y]
 				pssble,trnsprnt = object.passable, object.transparent
 			else:
 				pssble,trnsprnt = terrain_registry.get_props(map.ids[x,y])
 			tc.map_set_properties(self.base_map, x,y, trnsprnt,pssble)
 
 		self.fovmaps = {}
 

 	def get_fovmap(self, origin, radius):

 		key = origin,radius
 
 		if key in self.fovmaps: fovmap = self.fovmaps[key]
 		else:
 			fovmap = tc.map_new(self.width, self.height)
 			tc.map_copy(self.base_map, fovmap)
 			self.fovmaps[key] = fovmap
 
 			x,y = origin

 			tc.map_compute_fov(fovmap, x,y, radius, algo=tc.FOV_DIAMOND)

 
 		return fovmap
 

 	def is_visible(self, origin, radius, coord):
 		fovmap = self.get_fovmap(origin, radius)
 		return tc.map_is_in_fov(fovmap, *coord)
 

 	def is_transparent(self, coord):
 		return tc.map_is_transparent(self.base_map, *coord)
 	def is_passable(self, coord):
 		return tc.map_is_walkable(self.base_map, *coord)
 
 
 class TerrainInfo(object):
 	passable = False
 	transparent = False
 	char = ord(' ')
 	fg = (255,255,255)
 	bg = (0,0,0)

 	prob = 1

 
 	@classmethod

 	def make_terrain(cls, name, char, passable, transparent,fg,bg, prob=1):

 		if hasattr(char, 'upper'): char = ord(char)
 		passable = bool(passable)
 		transparent = bool(transparent)

 		return type(name, (cls,), dict(char=char, passable=passable, transparent=transparent,fg=fg,bg=bg,prob=prob))

 
 class TerrainRegistry(object):
 	def __init__(self):
 		self.id = 0
 		self.registry = {}
 		self.names = {}
 
 	def get_terrain(self, id):
 		ter = self.registry[id]
 		return ter
 
 	def get_props(self, id):
 		ter = self.get_terrain(id)
 		return ter.passable, ter.transparent
 
 	def get_display(self, char):
 		ter = self.get_terrain(char)
 		return ter.char, ter.fg, ter.bg
 
 	def get_terrain_types(self):

 		types, probabilities = zip(*[(x, self.registry[x].prob) for x in self.registry])
 		probs = [float(x) / sum(probabilities) for x in probabilities]
 		return types, probs

 
 
 	def register(self, ter):
 		self.id += 1
 		self.registry[self.id] = ter
 		self.names[ter.__name__] = ter
 		return ter
 
 	def new_terrain(self, name, char,

 		passable=False, transparent=False, fg=(255,255,255), bg=(0,0,0), prob=1

 	):

 		ter = TerrainInfo.make_terrain(name, char, passable, transparent, fg,bg, prob=prob)

 		return self.register(ter)
 
 	def load_from_file(self, fn, loader=yaml.safe_load):
 		with open(fn) as f:
 			values = loader(f)
 		for name, terrain in values.viewitems():
 			self.new_terrain(name, **terrain)