#include <SDL2/SDL.h>
#include <array>
#include <chrono>
#include <collection.hpp>
#include <game/activities/go.h>
#include <game/activities/idle.h>
#include <game/activity.h>
#include <game/gamestate.h>
#include <game/network/link.h>
#include <game/network/rail.h>
#include <game/objective.h>
#include <game/objectives/goto.h>
#include <game/orders.h>
#include <game/terrain.h>
#include <game/vehicles/railVehicle.h>
#include <game/vehicles/railVehicleClass.h>
#include <game/vehicles/train.h>
#include <game/worldobject.h>
#include <gfx/camera_controller.h>
#include <gfx/gl/camera.h>
#include <gfx/gl/shader.h>
#include <gfx/inputHandler.h>
#include <gfx/manualCameraController.h>
#include <gfx/renderable.h>
#include <gfx/window.h>
#include <glm/glm.hpp>
#include <memory>
#include <special_members.hpp>
#include <vector>

static const int DISPLAY_WIDTH = 1280;
static const int DISPLAY_HEIGHT = 1024;

class SDL_Application : public InputHandler, public std::enable_shared_from_this<SDL_Application>, GameState {
public:
	SDL_Application()
	{
		SDL_Init(SDL_INIT_EVERYTHING);

		SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
		SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
		SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
		SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
		SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
		SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
		SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
	}

	~SDL_Application() override
	{
		SDL_Quit();
	}

	NO_COPY(SDL_Application);
	NO_MOVE(SDL_Application);

	std::shared_ptr<Train> train;
	bool
	handleInput(SDL_Event & e) override
	{
		switch (e.type) {
			case SDL_QUIT:
				isRunning = false;
				return true;
			case SDL_KEYUP:
				switch (e.key.keysym.scancode) {
					case SDL_SCANCODE_G:
						train->currentActivity = std::make_unique<Go>();
						break;
					case SDL_SCANCODE_I:
						train->currentActivity = std::make_unique<Idle>();
						break;
					default:
						return false;
				}
				return true;
		}
		return false;
	}

	int
	run()
	{
		Collection<Window> windows;
		windows.create(DISPLAY_WIDTH, DISPLAY_HEIGHT, "OpenGL");

		world.create<Terrain>();

		{
			auto rl = world.create<RailLinks>();
			const glm::vec3 j {-1100, 15, -1100}, k {-1100, 15, -1000}, l {-1000, 20, -800}, m {-900, 30, -600},
					n {-600, 32, -500}, o {-500, 30, -800}, p {-600, 25, -900}, q {-1025, 10, -1175},
					r {-925, 10, -1075};
			const glm::vec3 s {-1100, 15, -500}, t {-1100, 15, -450}, u {-1000, 15, -400};
			auto l3 = rl->addLinksBetween(j, k);
			rl->addLinksBetween(k, l);
			rl->addLinksBetween(l, m);
			rl->addLinksBetween(m, n);
			rl->addLinksBetween(n, o);
			rl->addLinksBetween(o, p);
			// branch 1
			rl->addLinksBetween(p, q);
			rl->addLinksBetween(q, j);
			// branch 2
			rl->addLinksBetween(p, r);
			rl->addLinksBetween(r, j);
			// early loop
			rl->addLinksBetween(s, t);
			rl->addLinksBetween(l, s);
			rl->addLinksBetween(t, u);
			rl->addLinksBetween(u, m);
			train = world.create<Train>(l3);
			auto b47 = std::make_shared<RailVehicleClass>("brush47");
			for (int N = 0; N < 6; N++) {
				train->create<RailVehicle>(b47);
			}
			train->orders.removeAll();
			train->orders.create<GoTo>(&train->orders, l3->ends[1], l3->length, rl->findNodeAt({-1100, 15, -450}));
			train->currentActivity = train->orders.current()->createActivity();
		}

		Shader shader;
		Camera camera({-1250.0F, 35.0F, -1250.0F}, 70.0F, (float)DISPLAY_WIDTH / (float)DISPLAY_HEIGHT, 0.1F, 10000.0F);
		camera.Pitch(0.24);
		camera.RotateY(0.7854);
		shader.setView(camera.GetViewProjection());
		shader.setUniform("lightDirection", glm::normalize(glm::vec3 {1, -1, 0}));
		shader.setUniform("lightColor", {.6, .6, .6});
		shader.setUniform("ambientColor", {0.5, 0.5, 0.5});

		auto t_start = std::chrono::high_resolution_clock::now();

		inputStack.objects.push_back(shared_from_this());
		inputStack.objects.insert(
				inputStack.objects.begin(), world.create<ManualCameraController>(glm::vec2 {-1150, -1150}));

		while (isRunning) {
			processInputs();
			const auto t_end = std::chrono::high_resolution_clock::now();
			const auto t_passed = std::chrono::duration_cast<TickDuration>(t_end - t_start);

			world.apply(&WorldObject::tick, t_passed);
			world.apply<CameraController>(&CameraController::updateCamera, &camera);
			shader.setView(camera.GetViewProjection());
			windows.apply(&Window::Clear, 0.0F, 0.0F, 0.0F, 1.0F);
			world.apply<Renderable>(&Renderable::render, shader);
			windows.apply(&Window::SwapBuffers);

			t_start = t_end;
		}

		inputStack.removeAll();
		return 0;
	}

private:
	void
	processInputs()
	{
		for (SDL_Event e; SDL_PollEvent(&e);) {
			inputStack.applyOne(&InputHandler::handleInput, e);
		}
	}

	bool isRunning {true};
	Collection<InputHandler> inputStack;
};

int
main(int, char **)
{
	return std::make_shared<SDL_Application>()->run();
}