import libtcodpy as libtcod

 import maps
 import debug
 
 class Level(object):
 	levels = {}

 	color_dark_wall = libtcod.Color(60, 60, 60)
 	color_light_wall = libtcod.Color(127,127,127)
 	color_dark_ground = libtcod.Color(150,150,150)
 	color_light_ground = libtcod.Color(200,200,200)
 
 

 
 	def register(self, num):
 		self.levels[num] = self
 		self.number = num
 		return self
 
 	def __init__(self, width, height, con, item_types=None, monster_types=None):
 		self.objects = []
 		self.map = maps.Map(width, height, con, self)

 		self.fov_map = libtcod.map_new(self.map.width, self.map.height)
 		self.con = con
 		self.player = None

 
 		if item_types is None: item_types = {}
 		self.item_types = item_types
 
 		if monster_types is None: item_types = {}
 		self.monster_types = monster_types
 
 	def setup(self, max_rooms, min_size, max_size, max_num_monsters, max_num_items):
 		self.map.populate_map(
 			max_rooms, min_size, max_size,
 			self.monster_types, max_num_monsters,
 			self.item_types, max_num_items,
 		)
 

 	def iter_objects(self):
 		return iter(self.objects)
 
 	def add_object(self, obj):
 		self.objects.append(
 			obj.enter_level(self)
 		)
 		return obj
 
 	def claim_object(self, obj):
 		self.objects.remove(obj)
 		return obj
 

 	def enter(self, player):

 		#self.map.enter(player)
 		if self.player is not None and self.player.level is not None:
 			self.player.level.leave(self.player)

 		self.player = player

 		self.player.pos = self.map.map_entrance

 		self.objects.append(player)
 		return self
 

 	def leave(self, player):
 		#self.map.leave(player)
 		self.objects.remove(player)
 		self.player = None
 

 
 	def send_to_back(self, obj):
 		self.objects.remove(obj)
 		self.objects.insert(0,obj)
 

 	fov_algo = libtcod.FOV_DIAMOND
 	fov_light_walls = True
 	def recompute_fov(self, clear_all=False):
 		x,y = self.map.map_entrance
 		if self.player is not None:
 			x,y = self.player.pos
 
 		libtcod.map_compute_fov(
 			self.fov_map, x,y,
 				player.Player.torch_radius, self.fov_light_walls, self.fov_algo
 		)
 
 		for x,y, cell in self.map.iter_cells_with_coords():
 			visible = libtcod.map_is_in_fov(self.fov_map, x,y)
 			if visible and not cell.explored:
 				cell.explored = True
 
 			color = libtcod.black
 			#if True:
 			if cell.explored:
 				wall = cell.block_sight
 				walkable = not cell.blocked
 
 				if wall or walkable:
 					color = {
 						True: {True: self.color_light_wall, False: self.color_light_ground},
 						False: {True: self.color_dark_wall, False: self.color_dark_ground}
 					}[visible][wall]
 				elif not walkable:
 					color = libtcod.Color(100,100,200)
 
 			if cell.explored or clear_all:
 				libtcod.console_set_char_background(self.con, x, y, color, libtcod.BKGND_SET)
 
 	def init_fov(self):
 		libtcod.map_clear(self.fov_map)
 		#self.fov_map = libtcod.map_new(self.map.width, self.map.height)
 		for x,y,cell in self.map.iter_cells_with_coords():
 			libtcod.map_set_properties(self.fov_map, x,y,
 				not cell.block_sight,
 				not cell.blocked
 			)
 
 	def is_visible(self, x,y):
 		if x < 0 or y < 0:
 			raise ValueError(' (%s,%s) not in map ' % (x,y))
 		elif x >= self.map.width or y >= self.map.height:
 			raise ValueError(' (%s,%s) not in map ' % (x,y))
 		return libtcod.map_is_in_fov(self.fov_map, x,y)
 
 	def is_blocked(self, x,y):
 		return self.map.is_blocked(x,y)
 

 import game
 import player