redef class GamnitDisplay

	# The EGL display
	var egl_display: EGLDisplay is noautoinit

	# The EGL context
	var egl_context: EGLContext is noautoinit

	# The EGL surface for the window
	var window_surface: EGLSurface is noautoinit

	# The selected EGL configuration
	var egl_config: EGLConfig is noautoinit

	# Setup the EGL display for the given `native_display`
	protected fun setup_egl_display(native_display: Pointer)
	do
		var egl_display = new EGLDisplay(native_display)
		assert egl_display.is_valid else print "new EGL display is not valid"

		egl_display.initialize
		assert egl_display.is_valid else print "EGL initialize error: {egl_display.error}"

		self.egl_display = egl_display
	end

	# Select an EGL config
	protected fun select_egl_config(red, green, blue, alpha, depth, stencil: Int)
	do
		var config_chooser = new EGLConfigChooser
		config_chooser.renderable_type_egl
		config_chooser.surface_type_egl
		config_chooser.red_size = red
		config_chooser.green_size = green
		config_chooser.blue_size = blue
		if alpha > 0 then config_chooser.alpha_size = alpha
		if depth > 0 then config_chooser.depth_size = depth
		if stencil > 0 then config_chooser.stencil_size = stencil

		config_chooser.sample_buffers = 1
		config_chooser.samples = 4

		config_chooser.close

		var configs = config_chooser.choose(egl_display)
		assert configs != null else print "Choosing EGL config failed: {egl_display.error}"
		assert not configs.is_empty else print "Found no EGL config"

		if debug_gamnit then
			print "EGL available configurations:"
			for config in configs do
				var attribs = config.attribs(egl_display)
				print "* Conformant to: {attribs.conformant}"
				print "  Caveats: {attribs.caveat}"
				print "  Size of RGBA: {attribs.red_size} {attribs.green_size} {attribs.blue_size} {attribs.alpha_size}"
				print "  Buffer, depth, stencil: {attribs.buffer_size} {attribs.depth_size} {attribs.stencil_size}"
				print "  Sample buffers, samples: {attribs.sample_buffers} {attribs.samples}"
			end
		end

		# We use the first one, it is recommended
		self.egl_config = configs.first
	end

	# Setup the EGL context for the given `native_window`
	protected fun setup_egl_context(native_window: Pointer)
	do
		var window_surface = egl_display.create_window_surface(egl_config, native_window, [0])
		assert window_surface.is_ok else print "Creating EGL window surface failed: {egl_display.error}"
		self.window_surface = window_surface

		egl_context = egl_display.create_context(egl_config)
		assert egl_context.is_ok else print "Creating EGL context failed: {egl_display.error}"

		var make_current_res = egl_display.make_current(window_surface, window_surface, egl_context)
		assert make_current_res else print "Creating EGL make current failed: {egl_display.error}"

		# TODO make the API selection configurable per platform
		assert egl_bind_opengl_es_api else print "EGL bind API failed: {egl_display.error}"
	end

	# Check if the current configuration of `native_window` is still valid
	#
	# There is two return values:
	# * Returns `true` if the Gamnit services should be recreated.
	# * Sets `native_window_is_invalid` if the system provided window handle is invalid.
	#   We should wait until we are provided a valid window handle.
	fun check_egl_context(native_window: Pointer): Bool
	do
		native_window_is_invalid = false

		if not egl_context.is_ok then
			# Needs recreating
			egl_context = egl_display.create_context(egl_config)
			assert egl_context.is_ok else print "Creating EGL context failed: {egl_display.error}"
		end

		var success = egl_display.make_current(window_surface, window_surface, egl_context)
		if not success then
			var error = egl_display.error
			print "check_egl_context make_current: {error}"


			if error.is_bad_native_window then
				# native_window is invalid
				native_window_is_invalid = true
				return true

			else if not error.is_success then
				# The context is now invalid, rebuild it
				setup_egl_context native_window
				return true
			end
		end
		return false
	end

	# Return value from `check_egl_context`, the current native window is invalid
	#
	# We should wait until we are provided a valid window handle.
	var native_window_is_invalid = false

	redef fun width do return window_surface.attribs(egl_display).width

	redef fun height do return window_surface.attribs(egl_display).height

	# Close the EGL context
	fun close_egl
	do
		egl_display.make_current(new EGLSurface.none, new EGLSurface.none, new EGLContext.none)
		egl_display.destroy_context(egl_context)
		egl_display.destroy_surface(window_surface)
	end

	redef fun flip
	do
		assert glGetError == gl_NO_ERROR

		assert egl_display.is_valid

		egl_display.swap_buffers(window_surface)
	end
end

redef class GamnitDisplay

	redef var width = 200
	redef var height = 300

	# Underlying GLKit game controller and view
	var glk_view: NitGLKView is noautoinit

	redef fun setup
	do
		var view = new GamnitGLKView
		view.multiple_touch_enabled = true
		self.glk_view = view
		self.width = view.drawable_width
		self.height = view.drawable_height
	end
end

redef class GamnitDisplay

	# Actual width or desired width of the window, can be set before calling `setup`
	fun width=(value: Int) do requested_width = value
	private var requested_width = 1920

	# Actual height or desired height of the window, can be set before calling `setup`
	fun height=(value: Int) do requested_height = value
	private var requested_height = 1080

	redef fun show_cursor do return sdl.show_cursor

	redef fun show_cursor=(val) do sdl.show_cursor = val

	redef fun lock_cursor=(val) do sdl.relative_mouse_mode = val

	redef fun lock_cursor do return sdl.relative_mouse_mode

	# Setup SDL, wm, EGL in order
	redef fun setup
	do
		if debug_gamnit then print "Setting up SDL"
		self.sdl_window = setup_sdl(requested_width, requested_height)

		if debug_gamnit then print "Setting up window manager"
		setup_egl_display sdl_window.wm_info.display_handle

		if debug_gamnit then print "Setting up EGL context"
		select_egl_config(red_bits, green_bits, blue_bits, 8, 8, 0)
		setup_egl_context sdl_window.wm_info.window_handle
	end

	# Close EGL and SDL in reverse order of `setup` (nothing to do for X11)
	redef fun close
	do
		close_egl
		close_sdl
	end

	# ---
	# SDL

	# The SDL display managing the window and events
	var sdl_window: SDLWindow is noautoinit

	# Title of the window, must be set before creating the window (or redef)
	var window_title = "gamnit game" is lazy, writable

	# Setup the SDL display and lib
	fun setup_sdl(window_width, window_height: Int): SDLWindow
	do
		assert sdl.initialize((new SDLInitFlags).video.audio) else
			print_error "Failed to initialize SDL2: {sdl.error}"
		end

		var img_flags = (new SDLImgInitFlags).png.jpg
		assert sdl.img.initialize(img_flags) == img_flags else
			print_error "Failed to initialize SDL2 IMG: {sdl.error}"
		end

		var sdl_window = new SDLWindow(window_title.to_cstring, window_width, window_height, sdl_window_flags)
		assert not sdl_window.address_is_null else
			print_error "Failed to create SDL2 window: {sdl.error}"
		end

		# Audio support
		var inited = mix.initialize(mix_init_flags)
		if inited != mix_init_flags then
			print_error "Failed to load SDL2 mixer format supports: {mix.error}"
		end

		var open = mix.open_audio(44100, mix.default_format, 2, 1024)
		if not open then
			print_error "Failed to initialize SDL2 mixer: {mix.error}"
		end

		return sdl_window
	end

	# SDL2 window initialization flags
	#
	# The default value supports OpenGL and window resizing.
	var sdl_window_flags: SDLWindowFlags = (new SDLWindowFlags).opengl.resizable is lazy, writable

	# SDL2 mixer initialization flags
	#
	# Defaults to FLAC, MP3 and OGG.
	var mix_init_flags: MixInitFlags = mix.flac | mix.mp3 | mix.ogg is lazy, writable

	# Close the SDL display
	fun close_sdl
	do
		sdl_window.destroy
		mix.close_audio
		mix.quit
		sdl.finalize
	end
end

redef class GamnitDisplay

	redef fun setup
	do
		var native_display = egl_default_display
		var native_window = app.native_app_glue.window

		setup_egl_display native_display

		# We need 8 bits per color for selection by color
		select_egl_config(red_bits, green_bits, blue_bits, 0, 8, 0)

		var format = egl_config.attribs(egl_display).native_visual_id
		assert not native_window.address_is_null
		native_window.set_buffers_geometry(0, 0, format)

		setup_egl_context native_window
	end

	redef fun close do close_egl
end

redef class GamnitDisplay

	# With stereoscopic view, the aspect ratio (in each eye) is half of the screen
	redef fun aspect_ratio do return super / 2.0
end

redef class GamnitDisplay
	redef var aspect_ratio = super is lazy
end

redef class GamnitDisplay

	redef var width = 1080
	redef var height = 720

	# Update `width` and `height`
	private fun update_size
	do
		var context = app.native_activity
		self.width = context.window_width
		self.height = context.window_height
	end
end