# This file is part of NIT (http://www.nitlanguage.org).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# A game of memory using shapes and colors
#
# # Features and TODO
#
# * [X] Various shapes, colors and sounds
# * [X] 3 difficulty modes
# * [X] Saved high scores
# * [ ] Level selection
#
# The remaining issues are
#
# * Crappy event system
# * Crappy UI element placement
module memory is
	app_name("Memorize Shapes and Colors")
	app_namespace "org.nitlanguage.memory"
	app_version(0, 1, git_revision)
end

import mnit
import app::audio
import mnit::opengles1
import app::data_store

import drawing

# A figure to click on
class Button
	# The place, starting from 0.
	# Will be used to derive the display place.
	var place: Int

	# The color of the figure
	var color: Color

	# The shape of the figure
	var shape: Image

	# The sound of the figure
	var sound: Sound

	# x-coordinate on the display
	var x: Float = 0.0
	# y-coordinate on the display
	var y: Float = 0.0
	# width on the display
	var w: Float = 0.0
	# height the display
	var h: Float = 0.0

	# Event time to live (from 1.0 downto 0.0)
	var ttl: Float = 0.0

	# Is there a big error on the button?
	var error = false

	# The initial position (according to shuffle)
	var from: Pos is noinit

	# The current path if shuffling
	var path: nullable BPath = null

	# The second path if hard shuffling
	var path2: nullable BPath = null

	# Is there an hard shuffling?
	var hard = false

	# The optional text on the button (in the menu)
	var text: nullable Image = null

	# The color of the text
	var text_color: nullable Color = null

	# The high score on the menu button
	var text_max: Int = 0

	# Draw on the display
	fun blit_on(display: Display)
	do
		if ttl > 0.0 then
			ttl -= 0.1
			if ttl <= 0.0 then
				ttl = 0.0
				path = path2
				path2 = null
				if path != null then ttl = path.duration
				error = false
			end
		end

		var x = self.x
		var y = self.y
		var p = 0.0
		if ttl > 0.0 then
			if path != null then
				var pos = to_pos
				path.update(pos, ttl)
				x = pos.x
				y = pos.y
				if hard then
					p = ttl/5.0
					if path2 != null then
						p = 1.0 - p
					end
				end
			else if error then
				# nothing
			else
				y -= ttl * h / 10.0
			end
		end

		if not app.player then
			p = 0.2.lerp(p, 1.0)
		end

		color.set(display, p)
		display.blit_centered(shape, x, y)
		var text = self.text
		if text != null then
			text.scale = shape.scale
			text_color.set(display, p)
			display.blit_centered(text, x, y - h/8.0)
			if text_max > 0 then
				app.blit_number(text_max, app.scale, x, y + h/8.0)
			end
		end
		if display isa Opengles1Display then
			display.reset_color
		end
		if error then
			app.drawing.error.scale = app.scale
			display.blit_centered(app.drawing.error, x, y)
		end
	end

	redef fun to_s do
		return "{place},{color},{shape},{sound}"
	end

	# Check collision
	fun has(x,y: Float): Bool
	do
		return (self.x - x).abs*2.0 <= w and (self.y - y).abs*2.0 <= h
	end

	# Return a new pos centered on the button
	fun to_pos: Pos do return new Pos(x, y)
end

# A rbg color
class Color
	# red (from 0.0 to 1.0)
	var r: Float
	# green (from 0.0 to 1.0)
	var g: Float
	# blue (from 0.0 to 1.0)
	var b: Float

	# Globally change the color of the display.
	# The color will be used for the next blit operations.
	# The color of the display has to be reseted manually (see `Opengles1Display::reset_color`).
	fun set(display: Display, p: Float)
	do
		if display isa Opengles1Display then
			display.color(p.lerp(r,1.0),p.lerp(g,1.0),p.lerp(b,1.0),p.lerp(1.0,0.0))
		end
	end
end

# A point in the display coordinates
class Pos
	# x coordinate
	var x: Float
	# y coordinate
	var y: Float
	redef fun to_s do return "({x},{y})"
end

# A cubic Bézier path between two points with two handles.
class BPath
	# The origin point
	var from: Pos
	# The handle of the origin point
	var from_handle: Pos
	# The handle of the destination point
	var to_handle: Pos
	# The destination point
	var to: Pos
	# The duration on the path
	var duration: Float

	# Update the coordinates of `cursor` for an absolute time to destination `ttd`
	fun update(cursor: Pos, ttd: Float)
	do
		var p = 1.0 - ttd / duration
		if p <= 0.0 then
			cursor.x = from.x
			cursor.y = from.y
			return
		end
		if p >= 1.1 then
			cursor.x = to.x
			cursor.y = to.y
		end
		var bx = p.cerp(from.x, from_handle.x, to_handle.x, to.x)
		var by = p.cerp(from.y, from_handle.y, to_handle.y, to.y)
		cursor.x = bx
		cursor.y = by
	end
end

redef class App

	# # Assets and resources

	# All the images assets
	var drawing = new DrawingImages

	# Array of all available colors for the figures
	var colors = new Array[Color]

	# Array of all available shapes for the figures
	var shapes = new Array[Image]

	# Array of all available sounds for the figures
	var sounds = new Array[Sound]

	# The sound to play on error (error)
	var snd_penalty: Sound is noautoinit

	# The sound of other ui element
	var snd_click: Sound is noautoinit

	redef fun on_create
	do
		colors.clear
		colors.add new Color(0.9, 0.6, 0.0)
		colors.add new Color(0.6, 0.0, 0.9)
		colors.add new Color(0.6, 0.5, 0.4)
		colors.add new Color(1.0, 0.0, 0.0)
		colors.add new Color(1.0, 1.0, 0.0)
		colors.add new Color(1.0, 0.0, 1.0)
		colors.add new Color(0.0, 1.0, 0.0)
		colors.add new Color(0.0, 1.0, 1.0)
		colors.add new Color(0.0, 0.0, 1.0)

		drawing.load_all(self)
		shapes.clear
		shapes.add drawing.circle
		shapes.add drawing.rect
		shapes.add drawing.cross
		shapes.add drawing.penta
		shapes.add drawing.star
		shapes.add drawing.triangle
		shapes.add drawing.heart
		shapes.add drawing.diamond
		shapes.add drawing.moon
		shapes.add drawing.spiral

		number_images = new NumberImages(drawing.n)

		sounds.clear
		sounds.add new Sound("bing.wav")
		sounds.add new Sound("boing.wav")
		sounds.add new Sound("cymbal.wav")
		sounds.add new Sound("dart.wav")
		sounds.add new Sound("duh.wav")
		sounds.add new Sound("grunt.wav")
		sounds.add new Sound("honkhonk.wav")
		sounds.add new Sound("line_end.wav")
		sounds.add new Sound("squishy-hit.wav")
		sounds.add new Sound("woodthunk.wav")
		sounds.add new Sound("whip.wav")

		snd_penalty = new Sound("penalty.wav")
		snd_click = new Sound("click.wav")

		# Force load the sounds. Required because bug #1728
		for s in sounds do s.load
		snd_penalty.load

		is_menu = data_store["game"] != true
		mode = data_int("mode") or else 0
		current_level = data_int("level") or else 0

		max_levels[0] = data_int("max_0") or else 0
		max_levels[1] = data_int("max_1") or else 0
		max_levels[2] = data_int("max_2") or else 0

		print "max_levels: {max_levels}"

		reload = new Button(-1, new Color(1.0,1.0,1.0), drawing.reload, snd_click)

		if is_menu then
			new_menu
		else
			new_game
		end
	end

	# Get a positive numeric value from the store
	fun data_int(name: String): nullable Int
	do
		var x = data_store[name]
		if x isa Int then return x else return null
	end

	# # Level information

	# Number of buttons for the next game
	var size = 5

	# Length of the memory sequence for the next game
	var length = 5

	# Do a hard deal?
	var hard_deal = false

	# No shuffle (0), easy shuffle (1), or hard shuffle (2)?
	var shuffling = 0

	# Is a new deal make on replay?
	# If true, a new set of figures and a new sequence is produced
	# If false, the same is reused.
	var deal_on_replay = true

	# Current buttons in the game
	var buttons = new Array[Button]

	# The sequence of the buttons to memorize
	var level = new Array[Button]

	# The number of errors (crosses) in the current level. (in [0..3])
	var error = 0

	# Is the player playing?
	# If false it means that the game is showing the sequence to memorize
	var player = false

	# Next button on the level (to show or guess according to `player`)
	var cpt = 0

	# Time to live before the next event
	var ttl = 0.0

	# Are we in the menu?
	var is_menu = true

	# In the end of game, is this a win of a lose?
	var is_win = false

	# Reset everything and create a menu
	fun new_menu
	do
		is_menu = true
		size = 3
		length = 0
		shuffling = 0

		data_store["game"] = false

		colors.shuffle
		shapes.shuffle
		sounds.shuffle

		buttons.clear
		for i in [0..size[ do
			var b = new Button(i, colors[i], shapes[i], sounds[i])
			buttons.add b
			b.text = drawing.hard[i]
			b.text_color = colors[3+i]
			b.text_max = max_levels[i]
		end

		# Start the scene
		start_scene
	end

	# The current mode: easy (0), medium (1), hard (2)
	var mode = 0

	# The current level (from 0)
	var current_level = 0

	# Hight scores of each mode
	var max_levels: Array[Int] = [0, 0, 0]

	# Reset everything and create a new game using `mode` and `level`
	fun new_game
	do
		print "Next game: mode={mode} level={current_level}"
		data_store["game"] = true
		data_store["mode"] = mode
		data_store["level"] = current_level
		if max_levels[mode] < current_level then
			max_levels[mode] = current_level
			data_store["max_{mode}"] = current_level
		end

		if mode == 0 then
			hard_deal = false
			shuffling = 0
			deal_on_replay = false
			size = 2
			length = 1
		else if mode == 1 then
			hard_deal = false
			shuffling = 1
			deal_on_replay = true
			size = 3
			length = 3
		else
			hard_deal = true
			shuffling = 2
			deal_on_replay = true
			size = 3
			length = 3
		end
		for i in [0..current_level[ do
			length += 1
			if length > size + 2 then
				size += 1
				length -= 1
			end
			if size > 16 then size = 16
		end

		deal_game
	end

	# Reset the buttons and deal a new game using `size` and `length`
	fun deal_game
	do
		is_menu = false

		# Randomize the deal
		colors.shuffle
		shapes.shuffle
		sounds.shuffle

		# Setup the figure
		buttons.clear
		if not hard_deal then
			# With the easy deal, each button is easily distinguishable
			for i in [0..size[ do
				var b = new Button(i, colors[i%colors.length], shapes[i%shapes.length], sounds[i%sounds.length])
				buttons.add b
			end
		else
			# With the hard deal, use overlapping combinations of colors and shapes
			var sqrt = size.to_f.sqrt
			var ncol = sqrt.floor.to_i
			var nsha = sqrt.ceil.to_i
			while ncol*nsha < size do ncol += 1

			# Randomly swap the numbers of colors/shapes
			if 2.rand == 0 then
				var t = ncol
				ncol = nsha
				nsha = t
			end

			# Deal combinations (up to `size`)
			for i in [0..ncol[ do
				for j in [0..nsha[ do
					if buttons.length >= size then break
					var b = new Button(buttons.length, colors[i], shapes[j], sounds.rand)
					buttons.add b
				end
			end

			# A last shuffle to break the colors/shapes grid
			buttons.shuffle
		end

		# Deal the level (i.e. sequence to memorize)
		# To increase distribution, determinate a maximum number of repetition
		# of a single button
		var rep = (length.to_f / size.to_f).ceil.to_i
		var pool = buttons * rep
		pool.shuffle

		level.clear
		for i in [0..length[ do
			level.add pool[i]
		end

		print "newgame size={size} length={length}"

		# Start the scene
		start_scene
	end

	# Cause a replay on the same level
	# On easy mode, the same level is replayed exactly
	# On other modes, a new deal is made
	fun replay_game
	do
		if deal_on_replay then
			deal_game
		else
			start_scene
		end
	end

	# Reset the state of the scene and start with `fly_in`
	fun start_scene
	do
		player = false
		cpt = -1
		path = null
		error = 0

		# Ask for a redraw
		first_frame = true
	end

	# # Placement and moves

	# Locations used to place buttons on the screen
	private var locations: Array[Array[Float]] = [
		[0.0, 1.0],
		[0.0, 1.0, 0.5],
		[0.0, 1.0, 0.0, 1.0],
		[0.0, 1.0, 2.0, 0.5, 1.5],
		[0.0, 1.0, 2.0, 0.0, 1.0, 2.0],
		[0.5, 1.5, 0.0, 1.0, 2.0, 0.5, 1.5],
		[0.0, 1.0, 2.0, 0.0, 2.0, 0.0, 1.0, 2.0],
		[0.0, 1.0, 2.0, 0.0, 1.0, 2.0, 0.0, 1.0, 2.0],
		[0.5, 1.5, 2.5, 0.0, 1.0, 2.0, 3.0, 0.5, 1.5, 2.5],
		[0.0, 1.0, 2.0, 3.0, 0.0, 1.5, 3.0, 0.0, 1.0, 2.0, 3.0],
		[0.0, 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 3.0],
		[0.5, 1.5, 2.5, 0.0, 1.5, 3.0, 0.0, 1.0, 2.0, 3.0, 0.5, 1.5, 2.5],
		[0.5, 1.5, 2.5, 0.0, 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 3.0, 0.5, 1.5, 2.5],
		[0.5, 1.5, 2.5, 0.0, 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 3.0],
		[0.0, 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 3.0]]


	# The scale of the figures.
	# According to the screen dimensions and the number of figures
	var scale = 0.0

	# The scale of the UI
	# According to the screen dimensions
	var ui_scale = 0.0

	# Compute then location on the display for each button
	#
	# The method can be called when there is a change in the buttons (or the display).
	fun locate(display: Display)
	do
		# The locations depend of the number of buttons (from 2 to 9)
		var n = buttons.length
		var locs = locations[n-2]
		var columns = if n <= 4 then 2 else if n <= 9 then 3 else 4
		var rows = if n <= 2 then 1 else if n <= 6 then 2 else if n <= 12 then 3 else 4

		# Compute basic dimensions according to the screen
		var slotw = display.width / columns
		var sloth = display.height / rows
		var subw = slotw - slotw/5
		var subh = sloth - sloth/5

		# Compute the figure scale
		var img = drawing.circle
		var xs = subw.to_f / img.width.to_f
		var ys = subh.to_f / img.height.to_f
		scale = xs.min(ys)

		# Compute the UI scale
		xs = display.width.to_f / img.width.to_f
		ys = display.height.to_f / img.height.to_f
		ui_scale = xs.min(ys) / 4.0

		var last = -1.0
		var row = 0.0
		var cpt = 0
		for b in buttons do
			b.place = cpt
			var col = locs[cpt]
			if col <= last then
				row += 1.0
			end
			last = col

			b.x = (col + 0.5) * slotw.to_f
			b.y = (row + 0.5) * sloth.to_f
			img = b.shape
			img.scale = scale
			b.w = (img.width.to_f * scale)
			b.h = (img.height.to_f * scale)

			cpt += 1
		end

		left.x = -150.0 * scale
		left.y = (display.height / 2).to_f
		right.x = display.width.to_f + 150.0 * scale
		right.y = left.y

		# Other UI elements

		if not is_menu then
			var reload = self.reload
			drawing.reload.scale = ui_scale
			reload.x = display.width.to_f - (drawing.reload.width.to_f / 2.0 * 1.2 ) * ui_scale
			reload.y = drawing.reload.height.to_f / 2.0 * 1.2 * ui_scale
			reload.w = drawing.reload.width.to_f * ui_scale
			reload.h = drawing.reload.height.to_f * ui_scale
		end
	end

	# The origin point of the cursor on the left
	var left = new Pos(0.0, 0.0)

	# The destination point of the cursor on the right
	var right = new Pos(0.0, 0.0)

	# The current cursor position
	var cursor = new Pos(0.0, 0.0)

	# The current cursor path
	var path: nullable BPath = null

	# The reload button
	var reload: Button is noautoinit

	# Safe point for a cursor on the i-th button of the level
	fun path_pos(i: Int): Pos
	do
		if i < 0 then return left
		if i >= level.length then return right
		return level[i].to_pos
	end

	# A random point outside of the screen
	fun far_away(display: Display): Pos
	do
		var a = (2.0*pi).rand
		var w = display.width.to_f / 2.0
		var h = display.height.to_f / 2.0
		var x = w + a.cos * w * 1.8
		var y = h + a.sin * h * 1.8
		return new Pos(x, y)
	end

	# Create a BPath between two point with some nice handle values
	fun new_path(from, to: Pos, ttl: Float): BPath
	do
		var a = atan2(to.y-from.y, to.x-from.x)
		a += pi * (2.0.rand - 1.0)
		var radius = 300.0 * scale
		var fh = new Pos(from.x + a.cos*radius, from.y + a.sin*radius)
		#var th = new Pos(to.x - a.cos*radius, to.y - a.sin*radius)
		var path = new BPath(from, fh, to, to, ttl)
		return path
	end

	# Initial placement of buttons
	fun fly_in(display: Display)
	do
		for b in buttons do
			var from = far_away(display)
			var to = b.to_pos
			var path = new_path(from, to, 5.0)
			b.path = path
			b.ttl = 5.0
		end
		ttl = 6.0
	end

	# Final leaving of buttons
	fun fly_out(display: Display)
	do
		for b in buttons do
			var from = b.to_pos
			var to = far_away(display)
			b.x = to.x
			b.y = to.y
			var path = new_path(from, to, 5.0)
			b.path = path
			b.ttl = 5.0
			b.hard = false
		end
		ttl = 6.0
	end

	# Randomly permute the content of `buttons` such that no element appears in its original position.
	fun derangement
	do
		# The simplest algorithm is to shuffle until no buttons is at the same place
		# This is also quite efficient and converges extremely quickly
		var redo = true
		while redo do
			redo = false
			buttons.shuffle
			for i in [0..size[ do
				if i == buttons[i].place then
					redo = true
					break
				end
			end
		end
	end

	# Shuffling the place of each button on the screen
	fun shuffle(display: Display)
	do
		for b in buttons do
			b.from = b.to_pos
		end

		derangement

		locate(display)
		for b in buttons do
			var from = b.from
			var to = b.to_pos
			#print "shuffle move {b.place}: {from} -> {to}"
			b.path = new_path(from, to, 5.0)
			b.ttl = 5.0
		end
		ttl = 5.0
	end

	# Shuffle the place of each button in a hard way
	fun hard_shuffle(display: Display)
	do
		for b in buttons do
			b.from = b.to_pos
			b.hard = true
		end

		derangement

		locate(display)
		for b in buttons do
			var from = b.from
			var to = b.to_pos
			var midx = display.width.to_f / 2.0
			var midy = display.height.to_f / 2.0
			var mid = new Pos(midx, midy)
			#print "shuffle move {b.place}: {from} -> {to}"
			b.path = new_path(from, mid, 5.0)
			b.path2 = new_path(mid, to, 5.0)
			b.ttl = 5.0
		end
		ttl = 5.0
	end

	# Setup the next cursor path
	fun setpath
	do
		if is_menu then return
		var from = path_pos(cpt-1)
		var to = path_pos(cpt)
		#print "cursor {cpt-1}->{cpt}: {from} -> {to}"
		path = new_path(from, to, 4.0)
		cursor.x = from.x
		cursor.y = from.y
		ttl = 5.0
	end

	# Main loop, drawing and inputs

	# Flag used to ask for a (re-)computation of the display layout
	private var first_frame = true

	redef fun frame_core(display)
	do
		if first_frame then
			locate(display)
			if cpt == -1 then
				fly_in(display)
			end
			first_frame = false
		end

		# Clear the screen
		display.clear(1.0, 1.0, 1.0)

		# Manage events
		# This is a crappy ad hoc organic implementation
		if not player then
			ttl -= 0.1
			if path != null then path.update(cursor, ttl)
			if ttl <= 0.0 then
				ttl = 0.0
				if is_menu then
					# Menu animation is over
					player = true
				else if cpt < 0 then
					# Level place animation is over
					cpt += 1
					setpath
				else if cpt < level.length then
					# The cursor is playing
					var b = level[cpt]
					b.ttl = 1.0
					b.sound.play
					cpt += 1
					setpath
				else if cpt == level.length then
					# The cursor is out, run the shuffle
					path = null
					if shuffling == 1 then
						shuffle(display)
					else if shuffling > 1 then
						hard_shuffle(display)
					end
					cpt += 1
				else
					# The shuffling is over, start playing
					player = true
					cpt = 0
				end
			end
		else if ttl > 0.0 then
			ttl -= 0.1
			if ttl <= 0.0 then
				ttl = 0.0
				if cpt == level.length then
					fly_out(display)
					cpt += 1
				else
					if is_menu then
						new_game
					else if is_win then
						current_level += 1
						new_game
					else
						replay_game
					end
				end
			end
		end

		# Display each button
		for b in buttons do
			b.blit_on(display)
		end

		# Display the cursor
		if path != null then
			drawing.cursor.scale = scale
			display.blit(drawing.cursor, cursor.x, cursor.y)
		end

		if not is_menu then
			blit_number(current_level, ui_scale, 10.0 * scale, 10.0 * scale)
			reload.blit_on(display)
		end
	end

	# Blit a number somewhere
	fun blit_number(number: Int, scale: Float, x, y: Float)
	do
		for img in number_images.imgs do img.scale = scale
		display.blit_number(number_images, number, x.to_i, y.to_i)
	end

	# Images with the numbers
	private var number_images: NumberImages is noautoinit

	# A player click on a button
	fun action(b: Button)
	do
		if is_menu then
			b.sound.play
			mode = b.place
			current_level = 0
			ttl = 0.1
			cpt = level.length
			is_win = true
			return
		end
		if cpt >= level.length then return
		if b == level[cpt] then
			b.sound.play
			b.ttl = 1.0

			cpt += 1
			if cpt >= level.length then
				is_win = true
				print "Won!"
				ttl = 2.0
			end
		else
			error += 1
			print "Err {error}"
			b.error = true
			b.ttl = 3.0
			snd_penalty.play
			if error > 2 then
				is_win = false
				print "Lose!"
				for b2 in buttons do
					b2.error = true
					b2.ttl = 3.0
				end
				ttl = 3.0
				cpt = level.length
			end
		end
	end

	redef fun input(ie)
	do
		# Quit?
		if ie isa QuitEvent then
			quit = true
			return true
		end

		# On click (or tap)
		if ie isa PointerEvent and ie.depressed then
			if player then
				for b in buttons do
					if b.has(ie.x, ie.y) then
						action(b)
						return true
					end
				end
			end

			if not is_menu then
				if reload.has(ie.x, ie.y) then
					reload.sound.play
					reload.ttl = 1.0
					replay_game
					return true
				end
			end
		end

		# Special commands
		if ie isa KeyEvent and ie.is_down then
			var c = ie.name

			if c == "4" or c == "escape" then
				# 4 is *back* on android
				if is_menu then
					# quit = true # broken
					new_menu
				else
					new_menu
				end
				return true
			end

			if is_menu then
				return false
			end

			if c == "[+]" or c == "=" then
				# [+] is keypad `+`
				size += 1
				deal_game
				return true
			else if c == "[-]" or c == "-" then
				size -= 1
				deal_game
				return true
			else if c == "[*]" or c == "]" then
				length += 1
				deal_game
				return true
			else if c == "[/]" or c == "[" then
				length -= 1
				deal_game
				return true
			else if c == "space" or c == "82" then
				# 82 is *menu* on android
				reload.sound.play
				reload.ttl = 1.0
				replay_game
				return true
			end

			print "got keydown: `{c}`"
		end

		return false
	end
end