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

help = '''
 'i': Inventory
 'd': Drop
 'g': Get item (Pick up)
 '?': Help
 Alt+Escape: Exit

 Arrow Keys for movement / selecting
 Name of item under the mouse shown
 above the health bar
'''

from game import GameBase
import levels
import objects
import utilities
if __name__ == 'main':
	class Null: pass
	class SettingsObject(object):
		def __init__(self, setting_name, default=Null):
			self.setting_name = setting_name
			self.default = default

		def __get__(self, instance, owner):
			result = instance.settings.get(self.setting_name, self.default)
			if result is Null:
				raise KeyError('%s is not specified in the configuration' % self.setting_name)
			return result

	class Game(GameBase):
		#actual size of the window
		def load_settings(self):
			self.settings = yaml.safe_load(
				file(os.path.join('./data/main.yml'))
			)
			if self.settings == None:
				self.settings = {}

		SCREEN_WIDTH = SettingsObject('screen_width', 80)
		SCREEN_HEIGHT = SettingsObject('screen_height', 50)

		PANEL_HEIGHT = 15

		INVENTORY_WIDTH = 50

		@property
		def MAP_WIDTH(self):
			return self.SCREEN_WIDTH
		@property
		def MAP_HEIGHT(self):
			return self.SCREEN_HEIGHT - (self.PANEL_HEIGHT + 2)


		BAR_WIDTH = 25
		MSG_X = BAR_WIDTH + 2
		MSG_HEIGHT = PANEL_HEIGHT

		@property
		def PANEL_Y(self):
			return self.SCREEN_HEIGHT - self.PANEL_HEIGHT

		@property
		def MSG_WIDTH(self):
			return self.SCREEN_WIDTH - self.MSG_X

		@property
		def MSG_HEIGHT(self):
			return self.PANEL_HEIGHT - 1

		ROOM_MIN_SIZE = SettingsObject('room_min_wall_length', 4)
		ROOM_MAX_SIZE = SettingsObject('room_max_wall_length', 7)

		MAX_ROOMS = SettingsObject('max_number_rooms', 10)
		MAX_ROOM_MONSTERS = SettingsObject('max_number_room_monsters', 6)
		MAX_ROOM_ITEMS = SettingsObject('max_number_room_items', 3)

		CONFUSE_NUM_TURNS = 17

		LIMIT_FPS = 20 #frames-per-second maximum

		def __init__(self):
			self.load_settings()
			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=40, defense = 2, power = 11, death_function=self.player_death)
			)



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

		def setup_map(self):
			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 typ
			return _inner


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

		@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))
			):
				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 to use\n')
			if item is not None:
				item.bind_game(self)
				self.player.use(item)

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

		@mvkeyhandler.handle('n')
		def mvkeyhandler(self):
			chosen_item = self.inventory_menu('Choose item to unmod\n')
			if chosen_item is not None:
				data = chosen_item.mods.keys()
				index = self.menu('Choose \nmod to \nundo\n', data, self.INVENTORY_WIDTH)
				if index is not None:
					self.player.unmodify(chosen_item.name, data[index])

		@mvkeyhandler.handle('m')
		def mvkeyhandler(self):
			chosen_item = self.inventory_menu('Choose item to mod\n')
			if chosen_item is not None:
				chosen_mod = self.mod_menu('Choose mod to apply\n')
				if chosen_mod is not None:
					self.player.modify(chosen_item.name, chosen_mod.name)

		@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)

		@mvkeyhandler.handle('?')
		def mvkeyhandler(self):
			self.menu(help, [], 50)

		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)
			)
			fps = libtcod.sys_get_fps()
			libtcod.console_print_ex(self.panel, self.BAR_WIDTH/2,4, libtcod.BKGND_NONE, libtcod.CENTER,
				'%s FPS' %(libtcod.sys_get_fps())
			)

			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)

		def main_menu(self):
			message = (
				'Welcome to YinJAR: is not Just Another Roguelike (WIP)',
				'',
				'Choose an option:',
				'',
			)

			options = ['Resume', 'Play', 'Exit']
			result = self.menu('\n'.join(message), options, len(message[0]))
			if result is not None:
				return options[result]

	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)

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

	il = ItemLoader(os.path.join('.','data','items'))
	il.load_items()

	game_instance.load_settings()
	action = game_instance.main_menu()
	libtcod.sys_set_fps(Game.LIMIT_FPS)
	while action is None or action.lower() != 'exit':
		if action is not None:
			if action.lower() == 'play':
				game_instance.setup_map()
			if action.lower() in {'play', 'resume'}:
				game_instance.main()
				libtcod.console_clear(0)
		action = game_instance.main_menu()