# Copyright (c) 2013 Edward Langley
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 # 
 # Redistributions of source code must retain the above copyright notice,
 # this list of conditions and the following disclaimer.
 # 
 # Redistributions in binary form must reproduce the above copyright
 # notice, this list of conditions and the following disclaimer in the
 # documentation and/or other materials provided with the distribution.
 # 
 # Neither the name of the project's author nor the names of its
 # contributors may be used to endorse or promote products derived from
 # this software without specific prior written permission.
 # 
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 # TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 

 from __future__ import division
 import colorsys
 import ctypes
 import libtcodpy as libtcod
 import random
 import time

 import yaml

 
 inst = lambda a:a()
 @inst
 class Settings:

 	def __init__(self):

 		with file('data/settings.yaml') as f:
 			self.settings = yaml.safe_load(f)
 	def __getattr__(self, attr):
 		return self.settings[attr]

 
 	SCREEN_WIDTH = 75

 	SCREEN_HEIGHT = 20

 	DISPLAY_HEIGHT = property(lambda self: self.SCREEN_HEIGHT+2)

 	LIMIT_FPS = 20
 	BASE = 8
 	LEVELS = 3
 
 libtcod.console_init_root(Settings.SCREEN_WIDTH, Settings.DISPLAY_HEIGHT, 'Mapping', False)

 libtcod.console_set_custom_font("terminal.png",libtcod.FONT_LAYOUT_ASCII_INROW|libtcod.FONT_TYPE_GREYSCALE)

 #libtcod.console_set_fullscreen(True)
 con = libtcod.console_new(Settings.SCREEN_WIDTH, Settings.SCREEN_HEIGHT)
 blank = libtcod.console_new(Settings.SCREEN_WIDTH, Settings.SCREEN_HEIGHT)
 #for x in range(Settings.SCREEN_WIDTH):
 	#for y in range(Settings.SCREEN_HEIGHT):
 
 
 message_con = libtcod.console_new(Settings.SCREEN_WIDTH, 2)

 libtcod.console_set_default_background(message_con,libtcod.red)

 #libtcod.console_set_default_background(blank,libtcod.red)
 
 
 libtcod.sys_set_fps(Settings.LIMIT_FPS)
 
 import map
 level = 1
 mp = map.Map.rand_new(Settings.LEVELS, Settings.BASE) ## warning: exponential BASE ** LEVELS
 mapping = {}
 
 colors = {
 	':': colorsys.rgb_to_hsv(0.0,0.0,1.0),

 	chr(5): colorsys.rgb_to_hsv(0.0,0.5,0.0),

 	'*': colorsys.rgb_to_hsv(1.0,1.0,0.0),
 }
 
 df = 1/40.0
 for x in range(-20,20):

 	char = random.choice(['.','.','.','*','*',';',':','"',"'",chr(5),'`'])

 	if char in colors:
 		h,s,v = colors[char]
 		print s,v
 		color = colorsys.hsv_to_rgb(h,s/1.75,v/2)
 		bgcolor = colorsys.hsv_to_rgb(h,s/4,v/4)
 	else:
 		hue = x+21 * df
 		color = colorsys.hsv_to_rgb(1/hue,0.5,0.5)
 		bgcolor = colorsys.hsv_to_rgb(1/hue,0.25,0.25)
 
 	color = [int(h*255) for h in color]
 	bgcolor = [int(h*255) for h in bgcolor]
 	mapping[x] = (libtcod.Color(*color), char, libtcod.Color(*bgcolor))
 
 names = {
 	'.': ('open',True,False),
 	'*': ('meadow',True,False),
 	';': ('marsh',1-0.05,False), ## Note: 1-0.05 means a 5% chance of being opaque
 	':': ('pond',True,True),
 	'"': ('heath',True,False),
 	"'": ('marsh',1-0.15,False),

 	chr(5): ('forest',False,True),

 	'`': ('copse',1-0.5,False),
 }
 
 class LevelMap(object):
 	def __init__(self, map):
 		self.map = map
 		self.fovmaps = [None]
 
 	def get_tile_type(self, level,x,y):

 		lvl = self.map.get_level(level)
 		tile_val = mapping.get(lvl[y][x],(None,' '))[1]

 		return names.get(tile_val,('',True,True))
 
 	def get_fovmap(self,level):
 		if level >= len(self.fovmaps):

 			levelmap = mp.get_level(level)

 			self.fovmaps.append(libtcod.map_new(len(levelmap), len(levelmap[0])))
 			libtcod.map_clear(self.fovmaps[-1])
 		return self.fovmaps[level]
 
 	def has_level(self, level):
 		return 1 <= level < len(self.fovmaps)
 
 	def adj_map(self, level, x,y):
 		fovmap = self.get_fovmap(level)
 		__, trans,block = self.get_tile_type(level,x,y)
 		trans = random.random() < trans
 		libtcod.map_set_properties(fovmap, x,y, trans, not block)
 
 	def comp_fov(self, level, player_x, player_y, light_radius=10):
 		fovmap = self.get_fovmap(level)
 		libtcod.map_compute_fov(fovmap, player_x, player_y, light_radius, False)
 
 	def get_color(self, level,x,y, color):
 		fovmap = self.get_fovmap(level)

 		if libtcod.map_is_in_fov(fovmap, x,y) and libtcod.map_is_walkable(fovmap,x,y):

 			#print 'cell in fov', level,x,y, libtcod.map_get_width(fovmap), libtcod.map_get_height(fovmap)
 			color = [x/255 for x in color]
 			h,s,v = colorsys.rgb_to_hsv(*color)
 			r,g,b = [int(x*255) for x in colorsys.hsv_to_rgb(h,s, v+0.15)]
 			color = libtcod.Color(r,g,b)
 		return color
 
 	def get_walkable(self, level, x,y):
 		fovmap = self.get_fovmap(level)
 		return libtcod.map_is_walkable(fovmap,x,y)
 
 	def calculate_level(self, level):
 		if not self.has_level(level):
 			print 'calculate_level'

 			lvl = mp.get_level(level)
 			for y,row in enumerate(lvl):

 				for x,__ in enumerate(row):
 					lm.adj_map(level, x,y)
 

 lm = LevelMap(mp)
 lm.calculate_level(level)
 
 libtcod.console_set_default_foreground(message_con, libtcod.white)
 for c in [con,message_con]:
 	libtcod.console_set_default_foreground(c, libtcod.white)

 	libtcod.console_clear(c)

 
 offset_x, offset_y = 0,0

 levelmap = mp.get_level(level)
 MAP_Y,MAP_X = len(levelmap), len(levelmap[0])

 player_x, player_y = random.randrange(0,MAP_X),random.randrange(0,MAP_Y)
 if not lm.get_walkable(level,player_x,player_y):
 	player_x,player_y = [(x,y) for x in range(player_x-2,player_x+3) for y in range(player_y-2,player_y+3) if lm.get_walkable(level,x,y)][-1]
 import time
 ak=0
 while not libtcod.console_is_window_closed():
 	t0 = time.time()
 

 	if player_x - offset_x >= Settings.SCREEN_WIDTH-5: offset_x += 5
 	elif player_x - offset_x < 5: offset_x -= 5

 	if player_y - offset_y >= Settings.SCREEN_HEIGHT-5: offset_y += 5
 	elif player_y - offset_y < 5: offset_y -= 5

 
 	offset_y = min(offset_y,MAP_Y-Settings.SCREEN_HEIGHT)
 	offset_y = max(offset_y,0)
 
 	offset_x = min(offset_x,MAP_X-Settings.SCREEN_WIDTH)
 	offset_x = max(offset_x,0)
 
 	t1 = time.time()
 	lm.comp_fov(level, player_x, player_y,10)

 	player_screen_pos = player_x-offset_x,player_y-offset_y

 	for y,row in enumerate(levelmap[offset_y:offset_y+Settings.SCREEN_HEIGHT]):

 		for x,cell in enumerate(row[offset_x:offset_x+Settings.SCREEN_WIDTH]):
 			color,char,bgcolor = mapping.get(cell, (libtcod.Color(0,0,0),' ',libtcod.Color(0,0,0)))
 
 			color = lm.get_color(level, x+offset_x, y+offset_y, color)
 			bgcolor = lm.get_color(level, x+offset_x, y+offset_y, bgcolor)
 

 			if (x,y) == player_screen_pos:

 				color = libtcod.Color(128,128,100)

 				char = '\x01'
 
 

 			libtcod.console_set_char_foreground(con, x,y, color)
 			libtcod.console_set_char_background(con, x,y, bgcolor)
 			libtcod.console_set_char(con,x,y,char)
 
 	print 'draw loop:', time.time()-t1
 
 	libtcod.console_print(message_con, 0,1,lm.get_tile_type(level, player_x,player_y)[0])
 	libtcod.console_blit(message_con, 0,0, Settings.SCREEN_WIDTH,2, 0, 0,Settings.DISPLAY_HEIGHT-2)
 
 	blit_x,blit_y = 0,0
 	blit_w,blit_h = Settings.SCREEN_WIDTH, Settings.SCREEN_HEIGHT
 	if blit_x + MAP_X < Settings.SCREEN_WIDTH:
 		blit_x = (Settings.SCREEN_WIDTH - (blit_x + MAP_X))/2
 		blit_x = int(blit_x)
 		blit_w = MAP_X
 	if blit_y + MAP_Y < Settings.SCREEN_HEIGHT:
 		blit_y = (Settings.SCREEN_HEIGHT - (blit_y + MAP_Y))/2
 		blit_y = int(blit_y)
 		blit_h = MAP_Y
 	libtcod.console_blit(con, 0,0, blit_w,blit_h , 0,blit_x,blit_y)
 	libtcod.console_flush()
 	libtcod.console_clear(message_con)
 
 	bk = (time.time()-t0)*1000
 	print 'time to keypress:', bk
 	print 'loop time:', ak+bk
 	key = libtcod.Key()
 	mouse = libtcod.Mouse()
 	libtcod.sys_wait_for_event(libtcod.EVENT_KEY_PRESS, key, mouse, False)
 	t0 = time.time()
 
 	olevel = level
 	diff = 1
 	if key.shift:
 		diff *= 10
 
 	alt = key.lalt | key.ralt
 	ox,oy = player_x,player_y
 	dest_x,dest_y = player_x,player_y
 	if key.vk == libtcod.KEY_DOWN and player_y < MAP_Y:
 		dest_y += diff
 		if alt:
 			dest_x -= diff
 	elif key.vk == libtcod.KEY_UP and dest_y > 0:
 		dest_y -= diff
 		if alt:
 			dest_x += diff
 	elif key.vk == libtcod.KEY_RIGHT and dest_x < MAP_X:
 		dest_x += diff
 		if alt:
 			dest_y += diff
 	elif key.vk == libtcod.KEY_LEFT and dest_x > 0:
 		dest_x -= diff
 		if alt:
 			dest_y -= diff

 	elif key.vk == libtcod.KEY_ESCAPE and any([key.lctrl,key.rctrl]): break

 	elif key.c == ord('>') and level < mp.depth: level += 1
 	elif key.c == ord('<') and level > 1: level -= 1
 
 	dest_x = min(dest_x,MAP_X-1)
 	dest_y = min(dest_y,MAP_Y-1)
 
 	dest_x = max(dest_x,0)
 	dest_y = max(dest_y,0)
 
 	if olevel == level:
 		libtcod.line_init(player_x,player_y, dest_x,dest_y)
 		nx,ny = libtcod.line_step()
 		while None not in {nx,ny}:
 			if not lm.get_walkable(level,nx,ny):

 				libtcod.console_print(message_con, 0,0,'You cannot walk through a %s' % lm.get_tile_type(level, nx,ny)[0])

 				break
 			print nx,ny
 			player_x,player_y = nx,ny
 			nx,ny = libtcod.line_step()
 
 	else:
 		player_prop = player_x/MAP_X, player_y/MAP_Y
 		offset_prop = offset_x/MAP_X, offset_y/MAP_Y

 		levelmap = mp.get_level(level)
 		MAP_Y,MAP_X = len(levelmap), len(levelmap[0])

 		libtcod.console_clear(0)
 		libtcod.console_clear(con)
 
 		print 'before:',offset_x, player_x, offset_x+Settings.SCREEN_WIDTH
 		player_x = int(MAP_X * player_prop[0])
 		player_y = int(MAP_Y * player_prop[1])
 
 		offset_x = int(player_x - Settings.SCREEN_WIDTH / 2)
 		if offset_x + Settings.SCREEN_WIDTH > MAP_X:
 			offset_x -= (offset_x+Settings.SCREEN_WIDTH) - MAP_X
 		offset_y = int(player_y - Settings.SCREEN_HEIGHT / 2)
 		if offset_y + Settings.SCREEN_HEIGHT > MAP_Y:
 			offset_y -= (offset_x+Settings.SCREEN_HEIGHT) - MAP_Y
 
 		lm.calculate_level(level)
 
 		if not lm.get_walkable(level,player_x,player_y):
 			player_x,player_y = [(x,y) for x in range(player_x-2,player_x+3) for y in range(player_y-2,player_y+3) if lm.get_walkable(level,x,y)][-1]
 
 
 
 	print 'time after keypress:', (time.time()-t0)*1000