import os.path
import textwrap
import math
import libtcodpy as libtcod
import glob
libtcod.console_set_keyboard_repeat(500, 50)
for file in glob.glob('./data/namegen/*.cfg'):
	libtcod.namegen_parse(file)

from game import GameBase
import levels
import objects
import utilities
if __name__ == 'main':
	class Game(GameBase):
		#actual size of the window
		SCREEN_WIDTH, SCREEN_HEIGHT = 155, 90

		MAP_WIDTH, MAP_HEIGHT = SCREEN_WIDTH, SCREEN_HEIGHT - 17

		INVENTORY_WIDTH = 50
		BAR_WIDTH = 25

		PANEL_HEIGHT = SCREEN_HEIGHT - MAP_HEIGHT - 2
		PANEL_Y = SCREEN_HEIGHT - PANEL_HEIGHT

		MSG_X = BAR_WIDTH + 2
		MSG_WIDTH, MSG_HEIGHT = SCREEN_WIDTH - BAR_WIDTH - 2, PANEL_HEIGHT - 1

		ROOM_MIN_SIZE, ROOM_MAX_SIZE = 7, 19

		MAX_ROOMS = 51

		MAX_ROOM_MONSTERS, MAX_ROOM_ITEMS = 9, 6

		CONFUSE_NUM_TURNS = 17

		LIMIT_FPS = 20	#20 frames-per-second maximum

		def __init__(self):
			GameBase.__init__(self, 'caer flinding', self.SCREEN_WIDTH, self.SCREEN_HEIGHT)

			self.select_cb = None

			self.panel = libtcod.console_new(self.SCREEN_WIDTH, self.PANEL_HEIGHT)

			self.levels = []

			self.current_level = 0
			self.levels = [levels.Level(self.MAP_WIDTH, self.MAP_HEIGHT, self.con, self.item_types, self.monster_types)]

			x,y = None,None
			self.player = objects.Player(self.level.map, self.con, x,y, '@', libtcod.white,
				fighter=objects.Fighter(hp=20, defense = 2, power = 10, death_function=self.player_death)
			)



		def player_death(self, player):
			utilities.message(self.game_msgs, self.MSG_HEIGHT, self.MSG_WIDTH, 'You died!')
			self.game_state = 'dead'
			player.char = '%'
			player.color = libtcod.dark_red

		def setup_map(self):
			print self.monster_types
			self.player.enter_level(self.level)

			self.level.setup(self.MAX_ROOMS,
				self.ROOM_MIN_SIZE, self.ROOM_MAX_SIZE,
				self.MAX_ROOM_MONSTERS, self.MAX_ROOM_ITEMS
			)
			self.set_fov()

		def set_fov(self):
			self.player.enter_level(self.level)
			self.level.init_fov()
			self.level.recompute_fov(True)

		item_types = {}
		@classmethod
		def register_item_type(cls, chance):
			def _inner(typ):
				cls.item_types[typ] = chance
				return cls
			return _inner


		monster_types = {}
		@classmethod
		def register_monster_type(cls, typ, chance):
			cls.monster_types[typ] = chance

		@property
		def level(self):
			return self.levels[self.current_level]

		@property
		def map(self):
			return self.level.map

		def change_level(self, down=True):
			change = 1 if down else -1
			self.current_level += change

			if (
					(self.current_level < 0 and not down)
						or
					(self.current_level >= len(self.levels))
			):
				print 'hello'
				new_level = levels.Level(
					self.MAP_WIDTH, self.MAP_HEIGHT,
					self.con, self.item_types, self.monster_types
				)

				if down:
					self.levels.append(new_level)
				else:
					self.levels.insert(0,new_level)
				self.current_level = self.levels.index(new_level)
				self.setup_map()
			else:
				self.set_fov()



		def main(self):
			self.message('Welcome %s! Prepare to perish in the Tombs of the Ancient Kings.' % self.player.name,
				libtcod.red
			)
			for x in GameBase.main(self):
				if x == 1:
					if (
						self.game_state in ('playing','selecting')
							and
						self.player_action != 'didnt-take-turn'
					):
						for object in self.level.objects:
							if object.ai:
								object.clear()
								object.ai.take_turn()


					for object in self.level.objects:
						object.clear()

					if self.game_state == 'selecting':
						self.cursor.clear()

				elif x == 2:
					if self.player_action == 'move':
						self.player.tick()




		def do_playing(self):
			if self.player_action != 'didnt-take-turn':
				for object in self.level.iter_objects():
					if object.ai:
						object.clear()
						object.ai.take_turn()
			self.player.clear()

			if self.player_action == 'move':
				self.player.tick()

		def do_selecting(self):
			self.cursor.clear()

		def do_dead(self):
			pass


		mvkeyhandler = utilities.MovementKeyListener()
		@mvkeyhandler.up
		def mvkeyhandler(self):
			self.player.move_or_attack(0,-1)
			return 'move'

		@mvkeyhandler.down
		def mvkeyhandler(self):
			self.player.move_or_attack(0, 1)
			return 'move'

		@mvkeyhandler.left
		def mvkeyhandler(self):
			self.player.move_or_attack(-1, 0)
			return 'move'

		@mvkeyhandler.right
		def mvkeyhandler(self):
			self.player.move_or_attack(1, 0)
			return 'move'

		@mvkeyhandler.handle('i')
		def mvkeyhandler(self):
			item = self.inventory_menu('choose item\n')
			if item is not None:
				self.player.use(item)

		@mvkeyhandler.handle('d')
		def mvkeyhandler(self):
			chosen_item = self.inventory_menu('Choose the item to drop:')
			if chosen_item is not None:
				self.player.drop(chosen_item.owner)

		@mvkeyhandler.handle('g')
		def mvkeyhandler(self):
			for obj in self.level.iter_objects():
						if obj.x == self.player.x and obj.y == self.player.y and obj.item:
							self.player.pick_up(obj)

		@mvkeyhandler.handle('<')
		def mvkeyhandler(self):
			self.change_level(down=False)

		@mvkeyhandler.handle('>')
		def mvkeyhandler(self):
			self.change_level(down=True)

		selectkeyhandler = utilities.MovementKeyListener()
		@selectkeyhandler.up
		def selectkeyhandler(self):
			self.cursor.y -= 1
		@selectkeyhandler.down
		def selectkeyhandler(self):
			self.cursor.y += 1
		@selectkeyhandler.left
		def selectkeyhandler(self):
			self.cursor.x -= 1
		@selectkeyhandler.right
		def selectkeyhandler(self):
			self.cursor.x += 1

		@selectkeyhandler.handle(libtcod.KEY_ENTER)
		def selectkeyhandler(self):
			self.select_cb(self.cursor.x, self.cursor.y)
			self.cursor.clear()
			self.game_state = 'playing'



		def render_all(self):
			for obj in self.level.iter_objects():
				if obj != self.player:
					obj.draw(self.player)
			self.player.draw()

			if self.game_state == 'selecting':
				self.cursor.draw()

			if self.player.fov_recompute:
				self.level.recompute_fov()

			libtcod.console_blit(self.con, 0,0, self.SCREEN_WIDTH,self.SCREEN_HEIGHT, 0,0, 0)

			libtcod.console_set_default_background(self.panel, libtcod.black)
			libtcod.console_clear(self.panel)

			utilities.render_bar(self.panel, 1,1, self.BAR_WIDTH, 'HP',
				self.player.fighter.hp,
				self.player.fighter.max_hp,
				libtcod.red,
				libtcod.darker_red
			)

			libtcod.console_print_ex(self.panel, self.BAR_WIDTH/2,3, libtcod.BKGND_NONE, libtcod.CENTER,
				'%s p %s d' %(self.player.fighter.power, self.player.fighter.defense)
			)

			libtcod.console_set_default_foreground(self.panel, libtcod.light_gray)
			libtcod.console_print(self.panel, 1, 0, self.get_names_under_mouse())

			y = 1
			for line, color in self.game_msgs:
				libtcod.console_set_default_foreground(self.panel, color)
				libtcod.console_print_ex(self.panel, self.MSG_X, y, libtcod.BKGND_NONE, libtcod.LEFT, line)
				y += 1


			libtcod.console_blit(self.panel, 0,0, self.SCREEN_WIDTH,self.PANEL_HEIGHT, 0,0, self.PANEL_Y)

	game_instance = Game()
	from monsters import MonsterLoader


if __name__ == '__main__':
	from main import game_instance
	from items import *
	from utilities import *
	from maps import *
	from objects import *
	from monsters import *


	from functools import partial
	render_bar = partial(render_bar, game_instance.panel)

	a = MonsterLoader(os.path.join('.','data','monsters'))
	a.load_monsters()

	game_instance.setup_map()
	game_instance.main()