module;

#include <SDL2/SDL.h>

export module app;

import coral;
import coral.files;
import coral.image;
import coral.math;

import oar;

struct file_reader : public coral::file_reader {
	enum class [[nodiscard]] close_result {
		ok,
		io_unavailable,
	};

	enum class [[nodiscard]] open_result {
		ok,
		io_unavailable,
		access_denied,
		not_found,
	};

	file_reader(coral::fs * fs) : rw_ops{nullptr} {
		this->fs = fs;
	}

	close_result close() {
		if (::SDL_RWclose(this->rw_ops) != 0) return close_result::io_unavailable;

		this->rw_ops = nullptr;

		return close_result::ok;
	}

	bool is_open() const {
		return this->rw_ops != nullptr;
	}

	open_result open(coral::path const & file_path) {
		if (this->is_open()) switch (this->close()) {
			case close_result::ok: break;
			case close_result::io_unavailable: return open_result::io_unavailable;
			default: coral::unreachable();
		}

		this->rw_ops = ::SDL_RWFromFile(reinterpret_cast<char const *>(this->path_buffer), "r");

		if (this->rw_ops == nullptr) return open_result::not_found;

		return open_result::ok;
	}

	coral::expected<coral::usize, coral::io_error> read(coral::slice<coral::u8> const & buffer) override {
		if (!this->is_open()) return coral::io_error::unavailable;

		coral::usize const bytes_read{::SDL_RWread(this->rw_ops, buffer.pointer, sizeof(uint8_t), buffer.length)};

		if ((bytes_read == 0) && (::SDL_GetError() != nullptr)) return coral::io_error::unavailable;

		return bytes_read;
	}

	coral::expected<coral::u64, coral::io_error> seek(coral::u64 offset) override {
		if (!this->is_open()) return coral::io_error::unavailable;

		// TODO: Fix cast.
		coral::i64 const byte_position{
			::SDL_RWseek(this->rw_ops, static_cast<coral::i64>(offset), RW_SEEK_SET)};

		if (byte_position == -1) return coral::io_error::unavailable;

		return static_cast<coral::u64>(byte_position);
	}

	coral::expected<coral::u64, coral::io_error> tell() override {
		if (!this->is_open()) return coral::io_error::unavailable;

		coral::i64 const byte_position{::SDL_RWseek(this->rw_ops, 0, RW_SEEK_SET)};

		if (byte_position == -1) return coral::io_error::unavailable;

		return static_cast<coral::u64>(byte_position);
	}

	private:
	static constexpr coral::usize path_max{4096};

	coral::u8 path_buffer[path_max];

	coral::fs * fs;

	::SDL_RWops * rw_ops;
};

struct base_directory : public coral::fs {
	base_directory() : directory_path{} {
		char * const path{::SDL_GetBasePath()};

		if (path == nullptr) return;

		coral::usize path_length{0};

		while (path[path_length] != 0) path_length += 1;

		if (path_length == 0) {
			::SDL_free(path);

			return;
		}

		this->directory_path = {path, path_length};
	}

	~base_directory() override {
		::SDL_free(this->directory_path.begin());
	}

	void read_file(coral::path const & file_path, coral::callable<void(coral::file_reader &)> const & then) override {
		if (this->directory_path.length == 0) return;

		file_reader reader{this};

		if (reader.open(file_path) != file_reader::open_result::ok) return;

		then(reader);

		if (reader.close() != file_reader::close_result::ok) return;
	}

	void write_file(coral::path const & file_path, coral::callable<void(coral::file_writer &)> const & then) override {
		// Directory is read-only.
	}

	protected:
	coral::slice<char> directory_path;
};

struct user_directory : public coral::fs {
	user_directory(coral::path const & title) : directory_path{} {
		char * const path{::SDL_GetPrefPath("ona", title.begin())};

		if (path == nullptr) return;

		coral::usize path_length{0};

		while (path[path_length] != 0) path_length += 1;

		if (path_length == 0) {
			::SDL_free(path);

			return;
		}

		this->directory_path = {path, path_length};
	}

	~user_directory() override {
		::SDL_free(this->directory_path.begin());
	}

	void read_file(coral::path const & file_path, coral::callable<void(coral::file_reader &)> const & then) override {
		if (this->directory_path.length == 0) return;

		file_reader reader{this};

		if (reader.open(file_path) != file_reader::open_result::ok) return;

		then(reader);

		if (reader.close() != file_reader::close_result::ok) return;
	}

	void write_file(coral::path const & file_path, coral::callable<void(coral::file_writer &)> const & then) override {
		// Directory is read-only.
	}

	protected:
	coral::slice<char> directory_path;
};

export namespace app {
	enum class log_level {
		notice,
		warning,
		error,
	};

	struct system {
		system(coral::path const & title) : res{&base, "base_directory.oar"}, user{title} {}

		coral::fs & base_fs() {
			return this->base;
		}

		bool poll() {
			while (::SDL_PollEvent(&this->sdl_event) != 0) {
				switch (this->sdl_event.type) {
					case SDL_QUIT: return false;
				}
			}

			return true;
		}

		coral::fs & res_fs() {
			return this->res;
		}

		void log(app::log_level level, coral::slice<char const> const & message) {
			coral::i32 const length{static_cast<coral::i32>(
				coral::min(message.length, static_cast<size_t>(coral::i32_max)))};

			::SDL_LogMessage(SDL_LOG_CATEGORY_APPLICATION,
				SDL_LOG_PRIORITY_INFO, "%.*s", length, message.pointer);
		}

		coral::allocator & thread_safe_allocator() {
			return this->allocator;
		}

		coral::fs & user_fs() {
			return this->user;
		}

		private:
		::SDL_Event sdl_event;

		struct : public coral::allocator {
			coral::u8 * reallocate(coral::u8 * maybe_allocation, coral::usize requested_size) override {
				return reinterpret_cast<coral::u8 *>(::SDL_malloc(requested_size));
			}

			void deallocate(void * allocation) override {
				::SDL_free(allocation);
			}
		} allocator;

		base_directory base;

		user_directory user;

		oar::archive res;
	};

	struct graphics {
		enum class [[nodiscard]] show_result {
			ok,
			out_of_memory,
		};

		struct canvas {
			coral::color background_color;
		};

		graphics(coral::path const & title) {
			this->retitle(title);
		}

		void present() {
			if (this->sdl_renderer != nullptr) {
				::SDL_RenderPresent(this->sdl_renderer);
			}
		}

		void render(canvas & source_canvas) {
			if (this->sdl_renderer != nullptr) {
				SDL_SetRenderDrawColor(this->sdl_renderer, source_canvas.background_color.to_r8(),
					source_canvas.background_color.to_g8(), source_canvas.background_color.to_b8(),
						source_canvas.background_color.to_a8());

				SDL_RenderClear(this->sdl_renderer);
			}
		}

		void retitle(coral::path const & title) {
			this->title = title;

			if (this->sdl_window != nullptr)
				::SDL_SetWindowTitle(this->sdl_window, this->title.begin());
		}

		show_result show(coral::u16 physical_width, coral::u16 physical_height) {
			if (this->sdl_window == nullptr) {
				constexpr int sdl_windowpos = SDL_WINDOWPOS_UNDEFINED;
				constexpr coral::u32 sdl_windowflags = 0;

				this->sdl_window = ::SDL_CreateWindow(this->title.begin(), sdl_windowpos,
					sdl_windowpos, static_cast<int>(physical_width), static_cast<int>(physical_height),
						sdl_windowflags);

				if (this->sdl_window == nullptr) return show_result::out_of_memory;
			} else {
				::SDL_ShowWindow(this->sdl_window);
			}

			if (this->sdl_renderer == nullptr) {
				constexpr coral::u32 sdl_rendererflags = 0;

				this->sdl_renderer = ::SDL_CreateRenderer(this->sdl_window, -1, sdl_rendererflags);

				if (this->sdl_renderer == nullptr) return show_result::out_of_memory;
			}

			return show_result::ok;
		}

		private:
		coral::path title;

		::SDL_Window * sdl_window = nullptr;

		::SDL_Renderer * sdl_renderer = nullptr;
	};

	using graphical_runnable = coral::callable<int(system &, graphics &)>;

	int display(coral::path const & title, graphical_runnable const & run) {
		system app_system{title};
		graphics app_graphics{title};

		return run(app_system, app_graphics);
	}
}