#include <SDL2/SDL.h>

#include <algorithm>
#include <chrono>
#include <functional>
#include <memory>
#include <print>
#include <random>
#include <vector>

template <typename SDLT, auto deletef>
struct sdl_wrapper_t : std::unique_ptr<SDLT, decltype(deletef)> {
	explicit sdl_wrapper_t(SDLT* p)
		: std::unique_ptr<SDLT, decltype(deletef)>{p, deletef} {}

	operator SDLT*() { return std::unique_ptr<SDLT, decltype(deletef)>::get(); }
};

using window_t = sdl_wrapper_t<SDL_Window, SDL_DestroyWindow>;
using surface_t = sdl_wrapper_t<SDL_Surface, SDL_FreeSurface>;
using renderer_t = sdl_wrapper_t<SDL_Renderer, SDL_DestroyRenderer>;

auto operator+(SDL_Point a, SDL_Point b) {
	return SDL_Point{.x = a.x + b.x, .y = a.y + b.y};
}

auto operator<=>(const SDL_Point& a, const SDL_Point& b) {
	auto y_comp = a.x <=> b.x;
	if (y_comp != std::strong_ordering::equal) { return y_comp; }
	return a.y <=> b.y;
}

auto operator==(const SDL_Point& a, const SDL_Point& b) {
	return a.x == b.x && a.y == b.y;
}

constexpr int width = 3440;
constexpr int height = 1440;

template <auto EF>
struct [[nodiscard("give this a name so SDL_Quit is called at the end"
)]] Defer {
	Defer() = default;
	Defer(const Defer&) = delete;
	Defer(Defer&&) = delete;
	auto operator=(Defer&&) = delete;
	auto operator=(const Defer&) = delete;

	~Defer() { EF(); }
};

int main() {
	if (SDL_Init(SDL_INIT_VIDEO) < 0) {
		std::println("fuck");
		return EXIT_FAILURE;
	}
	Defer<SDL_Quit> defer_SDL_Quit;

	window_t window{SDL_CreateWindow(
		"random walk", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width,
		height, SDL_WINDOW_FULLSCREEN
	)};
	if (!window) {
		std::println(
			"Window could not be created! SDL_Error: {}", SDL_GetError()
		);
		return EXIT_FAILURE;
	}

	// owned by window
	// auto* window_surface = SDL_GetWindowSurface(window);

	renderer_t renderer{SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED)
	};
	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
	SDL_RenderClear(renderer);
	SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);


	auto surface = surface_t{SDL_GetWindowSurface(window)};

	std::vector<SDL_Point> points;
	SDL_Point pos{.x = width / 2, .y = height / 2};
	points.push_back(pos);
	const SDL_Point directions[] = {
		{.x = -1, .y = 0}, {.x = 1, .y = 0}, {.x = 0, .y = -1}, {.x = 0, .y = 1}
	};

	std::mt19937_64 rne(std::random_device{}());
	std::uniform_int_distribution dist(0, 3);

	bool continu = true;
	const auto start = std::chrono::steady_clock::now();
	auto next_frame = start;
	long total_points = 0;
	while (continu) {
		{
			SDL_Point newpoint;
			do {
				newpoint = pos + directions[dist(rne)];
			} while (newpoint.x < 0 or newpoint.x >= width or newpoint.y < 0 or
			         newpoint.y >= height);
			pos = newpoint;
			points.push_back(newpoint);
			++total_points;
		}
		const auto goal = 200'000'000;
		if (total_points >= goal) {
			continu = false;
			std::println(
				"took {} to get to {} random steps",
				std::chrono::duration_cast<std::chrono::duration<double>>(
					std::chrono::steady_clock::now() - start
				),
				goal
			);
		}

		// render present; poll events
		auto render_start = std::chrono::steady_clock::now();
		if (render_start > next_frame) {
			next_frame += std::chrono::milliseconds{200};

			{
				std::ranges::sort(points, std::less<>{});
				auto [first, last] = std::ranges::unique(points);
				points.resize(std::ranges::distance(points.begin(), first));
			}
			SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
			SDL_RenderDrawPoints(renderer, points.data(), std::ssize(points));
			SDL_RenderPresent(renderer);
			SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
			SDL_RenderClear(renderer);

			SDL_Event e;
			while (SDL_PollEvent(&e)) {
				if (e.type == SDL_QUIT) { continu = false; }
			}

			auto render_end = std::chrono::steady_clock::now();

			std::println(
				"drawn {} points in {}", std::ssize(points),
				std::chrono::duration_cast<std::chrono::milliseconds>(
					render_end - render_start
				)
			);
			if (render_end > next_frame) {
				next_frame = render_end + std::chrono::milliseconds{100};
			}
		}
	}

	// leaking memory, nothing I can do
}