#include <unordered_set>
#include <iostream>
#include <Ogre.h>
#include <OgreBullet.h>
#include <BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h>
#include <OgreTerrain.h>
#include <OgreTerrainGroup.h>
#include <OgrePageManager.h>
#include <OgreTerrainPagedWorldSection.h>
#include <OgrePage.h>
#include <OgreTerrainPaging.h>

#include "GameData.h"
#include "Components.h"
#include "CharacterModule.h"
#include "SunModule.h"
#include "TerrainModule.h"

#define TERRAIN_SIZE 129
#define TERRAIN_WORLD_SIZE 4000.0f
#define ENDLESS_TERRAIN_FILE_PREFIX Ogre::String("EndlessWorldTerrain")
#define ENDLESS_TERRAIN_FILE_SUFFIX Ogre::String("dat")

#define ENDLESS_PAGING

// max range for a int16
#define ENDLESS_PAGE_MIN_X (-0x7FFF)
#define ENDLESS_PAGE_MIN_Y (-0x7FFF)
#define ENDLESS_PAGE_MAX_X 0x7FFF
#define ENDLESS_PAGE_MAX_Y 0x7FFF
namespace ECS
{

#define BRUSH_SIZE 64
struct HeightData {
	Ogre::Image img;
	Ogre::Image img_brushes;
	Ogre::Image img_noise;
	static HeightData *singleton;
	HeightData()
	{
		img.load(
			"world_map.png",
			Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
		img_brushes.load(
			"brushes.png",
			Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
		img_noise.load(
			"terrain.png",
			Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
	}
	static HeightData *get_singleton()
	{
		if (!singleton)
			singleton = new HeightData();
		return singleton;
	}
	float get_brush_height(int id, int x, int y)
	{
		int m = 0;
		switch (id) {
		case 0:
			m = 0;
			break;
		case 1:
			m = BRUSH_SIZE;
			break;
		default:
			OgreAssert(false, "bad brush id");
			break;
		}
		return img_brushes.getColourAt(x, y + m, 0).r;
	}
	float get_base_height(const Ogre::Vector2 &worldOffset, int x, int y)
	{
		float height = 0.0f;
		int world_x = worldOffset.x + x;
		int world_y = worldOffset.y + y;
		int world_img_x =
			world_x + (int)img.getWidth() * BRUSH_SIZE / 2;
		int world_img_y =
			world_y + (int)img.getHeight() * BRUSH_SIZE / 2;
		Ogre::ColourValue color, colorb1, colorb2;
		// float d;
		int map_img_x = world_img_x / (BRUSH_SIZE);
		int map_img_y = world_img_y / (BRUSH_SIZE);
		int brush_img_x = world_img_x % BRUSH_SIZE;
		int brush_img_y = world_img_y % BRUSH_SIZE;
		if (world_img_x < 0 ||
		    world_img_x >= img.getWidth() * BRUSH_SIZE ||
		    world_img_y < 0 ||
		    world_img_y >= img.getWidth() * BRUSH_SIZE) {
			height = -1.0f;
			goto out;
		}
		color = img.getColourAt(map_img_x, map_img_y, 0);
		colorb1 = img_brushes.getColourAt(brush_img_x,
						  brush_img_y + BRUSH_SIZE, 0);
		colorb2 = img_brushes.getColourAt(brush_img_x, brush_img_y, 0);
		// d = Ogre::Math::saturate(color.r - 0.05f);
		height = color.r;
out:
		return height;
	}
	float get_noise_height(const Ogre::Vector2 &worldOffset, int x, int y)
	{
		int h;
		Ogre::Vector2 noisePoint;

		struct noise_types {
			Ogre::Vector2 noiseOfft;
			float noiseMul;
			float noiseBias;
			float noiseAmp;
		};
		static struct noise_types noise_pass[] = {
			{ { -100.0f, 70.0f }, 10.2f, -0.55f, 5.0f },
			{ { -130.0f, 55.0f }, 5.35f, -0.55f, 1.0f }
		};
		static float noise_values[] = { 0.0f, 0.0f };
		for (h = 0; h < (int)sizeof(noise_values) /
					(int)sizeof(noise_values[0]);
		     h++) {
			noisePoint = (worldOffset + Ogre::Vector2(x, y) +
				      noise_pass[h].noiseOfft) *
				     noise_pass[h].noiseMul;
			int noise_x =
				(int)(noisePoint.x + img_noise.getWidth() / 2) %
				img_noise.getWidth();
			int noise_y = (int)(noisePoint.y +
					    img_noise.getHeight() / 2) %
				      img_noise.getHeight();
			Ogre::ColourValue noise_color =
				img_noise.getColourAt(noise_x, noise_y, 0);
			noise_values[h] =
				(noise_color.r + noise_pass[h].noiseBias) *
				noise_pass[h].noiseAmp;
		}
		return noise_values[0] + noise_values[1];
	}
	float get_height(Ogre::TerrainGroup *terrainGroup, long x, long y,
			 int j, int i)
	{
		uint16_t terrainSize = terrainGroup->getTerrainSize();
		Ogre::Vector2 worldOffset(Ogre::Real(x * (terrainSize - 1)),
					  Ogre::Real(y * (terrainSize - 1)));
		float brush_height0 =
			HeightData::get_singleton()->get_brush_height(
				0, j % BRUSH_SIZE, i % BRUSH_SIZE) -
			0.55f;
		float brush_height1 =
			HeightData::get_singleton()->get_brush_height(
				1, j % BRUSH_SIZE, i % BRUSH_SIZE) -
			0.55f;
		float mheight =
			Ogre::Math::lerp(
				brush_height1, brush_height0,
				HeightData::get_singleton()->get_base_height(
					worldOffset, j, i)) *
			120.0f;
		float height = mheight;
		if (mheight > 0.5f)
			height += 2.0f + get_noise_height(worldOffset, j, i);
		else if (mheight < -0.5f)
			height -= 2.0f + get_noise_height(worldOffset, j, i);
		return height;
	}
};
HeightData *HeightData::singleton = nullptr;

class FlatTerrainDefiner
	: public Ogre::TerrainPagedWorldSection::TerrainDefiner,
	  public Ogre::FrameListener {
	Ogre::SceneManager *mScnMgr;
	Ogre::Bullet::DynamicsWorld *mWorld;
	struct gen_collider {
		Ogre::TerrainGroup *group;
		long x;
		long y;
	};
	std::deque<struct gen_collider> collider_queue;

public:
	FlatTerrainDefiner(Ogre::SceneManager *scm,
			   Ogre::Bullet::DynamicsWorld *world)
		: Ogre::TerrainPagedWorldSection::TerrainDefiner()
		, Ogre::FrameListener()
		, mScnMgr(scm)
		, mWorld(world)
	{
		Ogre::Root::getSingleton().addFrameListener(this);
	}

private:
public:
	void define(Ogre::TerrainGroup *terrainGroup, long x, long y) override
	{
		uint16_t terrainSize = terrainGroup->getTerrainSize();
		float *heightMap = OGRE_ALLOC_T(float, terrainSize *terrainSize,
						MEMCATEGORY_GEOMETRY);
		//	float *heightMapCollider = OGRE_ALLOC_T(
		//		float, terrainSize *terrainSize, MEMCATEGORY_GEOMETRY);
		//		Ogre::Vector2 worldOrigin =
		//			Ogre::Vector2(img.getWidth(), img.getHeight()) * 0.5f;
		float chunk = 128.0f;
		Ogre::Vector2 revisedValuePoint;
		for (int i = 0; i < terrainSize; i++)
			for (int j = 0; j < terrainSize; j++) {
				float height =
					HeightData::get_singleton()->get_height(
						terrainGroup, x, y, j, i);

				// height = -2.0f;
				heightMap[i * terrainSize + j] = height;
				//				heightMapCollider[(terrainSize - i - 1) *
				//							  terrainSize +
				//						  j] = height;
			}
		terrainGroup->defineTerrain(x, y, heightMap);
		Ogre::LogManager::getSingleton().logError(
			"defined terrain at " +
			Ogre::StringConverter::toString(x) + " " +
			Ogre::StringConverter::toString(y));
		//		collider_queue.push_back(
		//			{ terrainGroup, x, y, heightMapCollider });
		delete[] heightMap;
		collider_queue.push_back({ terrainGroup, x, y });
	}
	bool frameStarted(const Ogre::FrameEvent &evt) override
	{
		(void)evt;
		update();
		return true;
	}
	void update()
	{
		static bool created = false;
		std::deque<struct gen_collider> output;
		while (!collider_queue.empty()) {
			Ogre::TerrainGroup *group =
				collider_queue.front().group;
			long x = collider_queue.front().x;
			long y = collider_queue.front().y;
			Ogre::Terrain *terrain = group->getTerrain(x, y);
			Ogre::Vector3 worldPos;
			group->convertTerrainSlotToWorldPosition(x, y,
								 &worldPos);
			if (terrain && terrain->getHeightData() &&
			    terrain->isLoaded() &&
			    !terrain->isDerivedDataUpdateInProgress()) {
				Ogre::LogManager::getSingleton().logError(
					"can create collider for " +
					Ogre::StringConverter::toString(x) +
					" " +
					Ogre::StringConverter::toString(y));
				float minH = terrain->getMinHeight();
				float maxH = terrain->getMaxHeight();
				int size = terrain->getSize();
				float worldSize = terrain->getWorldSize();
				if (true) {
					btRigidBody *body =
						mWorld->addTerrainRigidBody(
							group, x, y, 2,
							0x7ffffffd & (~16));
					OgreAssert(
						body,
						"Could not create RigidBody");
					Ogre::LogManager::getSingleton().logError(
						"created rigid body " +
						Ogre::StringConverter::toString(
							Ogre::Bullet::convert(
								body->getWorldTransform()
									.getOrigin())));
					Ogre::LogManager::getSingleton().logError(
						"minHeight " +
						Ogre::StringConverter::toString(
							minH));
					Ogre::LogManager::getSingleton().logError(
						"maxHeight " +
						Ogre::StringConverter::toString(
							maxH));
					Ogre::LogManager::getSingleton().logError(
						"size " +
						Ogre::StringConverter::toString(
							size));
					Ogre::LogManager::getSingleton().logError(
						"world size " +
						Ogre::StringConverter::toString(
							worldSize));
					Ogre::LogManager::getSingleton().logError(
						"created collider for " +
						Ogre::StringConverter::toString(
							x) +
						" " +
						Ogre::StringConverter::toString(
							y));
					created = true;
				}
				collider_queue.pop_front();
				// FIXME: create entities and components instead
				Ogre::SceneNode *items =
					terrain->_getRootSceneNode()
						->createChildSceneNode();
				for (int i = 0; i < ECS::get<PlacementObjects>()
							    .altar_items.size();
				     i++) {
					const struct PlacementObjects::item &item =
						ECS::get<PlacementObjects>()
							.altar_items[i];
					Ogre::Entity *ent =
						group->getSceneManager()
							->createEntity(
								item.entity);
					Ogre::SceneNode *what =
						items->createChildSceneNode();
					what->attachObject(ent);
					what->setOrientation(item.rotation);
					what->setPosition(item.position);
				}
			} else {
				output.push_back(collider_queue.front());
				collider_queue.pop_front();
			}
			if (collider_queue.empty() &&
			    !ECS::get<Terrain>().mTerrainReady) {
				ECS::get_mut<Terrain>().mTerrainReady = true;
				ECS::modified<Terrain>();
			}
		}
		collider_queue = output;
	}
};
class DummyPageProvider : public Ogre::PageProvider {
public:
	DummyPageProvider(btDynamicsWorld *world)
		: Ogre::PageProvider()
		, mBtWorld(world)
	{
	}
	std::unordered_map<Ogre::PageID, btRigidBody *> body;
	btDynamicsWorld *mBtWorld;
	bool prepareProceduralPage(Ogre::Page *page,
				   Ogre::PagedWorldSection *section)
	{
		return true;
	}
	bool loadProceduralPage(Ogre::Page *page,
				Ogre::PagedWorldSection *section)
	{
		return true;
	}
	bool unloadProceduralPage(Ogre::Page *page,
				  Ogre::PagedWorldSection *section)
	{
		return true;
	}
	bool unprepareProceduralPage(Ogre::Page *page,
				     Ogre::PagedWorldSection *section)
	{
		return true;
	}
};
struct TerrainPrivate {
	DummyPageProvider *mDummyPageProvider;
	Ogre::Timer mSunUpdate;
};

TerrainModule::TerrainModule(flecs::world &ecs)
{
	ecs.component<Terrain>().add(flecs::Singleton);
	ecs.component<TerrainPrivate>().add(flecs::Singleton);
	ecs.set<TerrainPrivate>({ nullptr, {} });
	ecs.system<const EngineData, const Camera, const Sun, Terrain,
		   TerrainPrivate>("SetupUpdateTerrain")
		.kind(flecs::OnUpdate)
		.each([](const EngineData &eng, const Camera &camera,
			 const Sun &sun, Terrain &terrain,
			 TerrainPrivate &priv) {
			if (!terrain.mTerrainGroup && sun.mSun && eng.mScnMgr) {
				std::cout << "Terrain setup\n";
				if (!priv.mDummyPageProvider)
					priv.mDummyPageProvider =
						new DummyPageProvider(
							eng.mWorld
								->getBtWorld());
				terrain.mTerrainGlobals =
					OGRE_NEW Ogre::TerrainGlobalOptions();

				OgreAssert(terrain.mTerrainGlobals,
					   "Failed to allocate global options");

				Ogre::LogManager::getSingleton().setMinLogLevel(
					Ogre::LML_TRIVIAL);

				terrain.mTerrainGroup =
					OGRE_NEW Ogre::TerrainGroup(
						eng.mScnMgr,
						Ogre::Terrain::ALIGN_X_Z,
						TERRAIN_SIZE,
						TERRAIN_WORLD_SIZE);
				terrain.mTerrainGroup->setFilenameConvention(
					ENDLESS_TERRAIN_FILE_PREFIX,
					ENDLESS_TERRAIN_FILE_SUFFIX);
				terrain.mTerrainGroup->setOrigin(
					terrain.mTerrainPos);
				// Configure global
				terrain.mTerrainGlobals->setMaxPixelError(0);
				// testing composite map
				// mTerrainGlobals->setCompositeMapDistance(30);
				terrain.mTerrainGlobals->setCompositeMapDistance(
					500);
				//mTerrainGlobals->setUseRayBoxDistanceCalculation(true);
				terrain.mTerrainGlobals
					->getDefaultMaterialGenerator()
					->setLightmapEnabled(false);

				terrain.mTerrainGlobals->setCompositeMapAmbient(
					eng.mScnMgr->getAmbientLight());
				terrain.mTerrainGlobals->setCompositeMapDiffuse(
					sun.mSun->getDiffuseColour());
				terrain.mTerrainGlobals->setLightMapDirection(
					sun.mSun->getDerivedDirection());

				// Configure default import settings for if we use imported image
				Ogre::Terrain::ImportData &defaultimp =
					terrain.mTerrainGroup
						->getDefaultImportSettings();
				defaultimp.terrainSize = TERRAIN_SIZE;
				defaultimp.worldSize = TERRAIN_WORLD_SIZE;
				defaultimp.inputScale = 1.0f;
				defaultimp.minBatchSize = 33;
				defaultimp.maxBatchSize = 65;
				Ogre::Image combined;
				combined.loadTwoImagesAsRGBA(
					"Ground23_col.jpg", "Ground23_spec.png",
					"General");
				Ogre::TextureManager::getSingleton().loadImage(
					"Ground23_diffspec", "General",
					combined);
				defaultimp.layerList.resize(1);

				defaultimp.layerList[0].worldSize = 60;
				defaultimp.layerList[0].textureNames.push_back(
					"Ground23_diffspec");
				// Paging setup
				terrain.mPageManager =
					OGRE_NEW Ogre::PageManager();
				// Since we're not loading any pages from .page files, we need a way just
				// to say we've loaded them without them actually being loaded
				terrain.mPageManager->setPageProvider(
					priv.mDummyPageProvider);
				terrain.mPageManager->addCamera(camera.mCamera);
				terrain.mPageManager->setDebugDisplayLevel(0);
				terrain.mTerrainPaging =
					OGRE_NEW Ogre::TerrainPaging(
						terrain.mPageManager);
				terrain.mPagedWorld =
					terrain.mPageManager->createWorld();
				terrain.mTerrainPagedWorldSection =
					terrain.mTerrainPaging
						->createWorldSection(
							terrain.mPagedWorld,
							terrain.mTerrainGroup,
							300, 800,
							ENDLESS_PAGE_MIN_X,
							ENDLESS_PAGE_MIN_Y,
							ENDLESS_PAGE_MAX_X,
							ENDLESS_PAGE_MAX_Y);

				terrain.mTerrainPagedWorldSection->setDefiner(
					OGRE_NEW FlatTerrainDefiner(
						eng.mScnMgr, eng.mWorld));

				terrain.mTerrainGroup->freeTemporaryResources();
				std::cout << "Terrain setup done\n";
				ECS::get().set<PlacementObjects>({});
			}
			if (sun.mSun &&
			    priv.mSunUpdate.getMilliseconds() > 1000) {
				terrain.mTerrainGlobals->setCompositeMapAmbient(
					eng.mScnMgr->getAmbientLight());
				terrain.mTerrainGlobals->setCompositeMapDiffuse(
					sun.mSun->getDiffuseColour());
				terrain.mTerrainGlobals->setLightMapDirection(
					sun.mSun->getDerivedDirection());
				std::cout << "sun pitch: "
					  << sun.mSunNode->getOrientation()
						     .getPitch()
					  << "\n";
				priv.mSunUpdate.reset();
			}
		});
	ecs.system<const CharacterBase, const Terrain>("UpdateTerrainStatus")
		.kind(flecs::OnUpdate)
		.without<TerrainReady>()
		.each([](const CharacterBase &ch, const Terrain &terrain) {
			std::cout << "mTerrainReady: " << terrain.mTerrainReady
				  << "\n";
			std::cout << "mBodyNode: " << ch.mBodyNode << "\n";
			if (ch.mBodyNode && terrain.mTerrainReady) {
				long x, y;
				Ogre::Vector3 pos = ch.mBodyNode->getPosition();
				terrain.mTerrainGroup
					->convertWorldPositionToTerrainSlot(
						pos, &x, &y);
				if (terrain.mTerrainGroup->getTerrain(x, y) &&
				    terrain.mTerrainGroup->getTerrain(x, y)
					    ->isLoaded())
					ECS::get().add<TerrainReady>();
			}
		});
	ecs.system<const Terrain, PlacementObjects>("UpdatePlacementObjects")
		.kind(flecs::OnUpdate)
		.each([](const Terrain &terrain, PlacementObjects &placement) {
			if (placement.altar_items.size() == 0) {
				struct PlacementObjects::item item;
				int i, j;
				int worldSize = terrain.mTerrainGroup
							->getTerrainWorldSize();
				uint16_t terrainSize =
					terrain.mTerrainGroup->getTerrainSize();
				item.entity = "altar.glb";
				item.rotation = Ogre::Quaternion(0, 0, 0, 1);
				item.position = Ogre::Vector3(0, 0, 0);
				float height =
					HeightData::get_singleton()->get_height(
						terrain.mTerrainGroup, 0, 0, 0,
						0);
				item.position.y = height;
				placement.altar_items.push_back(item);
				for (i = -64000; i < 64000; i += 1000)
					for (j = -64000; j < 64000; j += 1000) {
						if (i == 0 && j == 0)
							continue;
						Ogre::Vector3 position(i, 0, j);
						long xslot, yslot;
						terrain.mTerrainGroup
							->convertWorldPositionToTerrainSlot(
								position,
								&xslot, &yslot);
						Ogre::Vector3 slotpos;
						terrain.mTerrainGroup
							->convertTerrainSlotToWorldPosition(
								xslot, yslot,
								&slotpos);
						Ogre::Vector3 offset =
							(position - slotpos) *
							terrainSize / worldSize;
						height =
							HeightData::get_singleton()
								->get_height(
									terrain.mTerrainGroup,
									xslot,
									yslot,
									(int)offset.x +
										(terrainSize -
										 1) / 2,
									(int)offset.z +
										(terrainSize -
										 1) / 2);
#if 0
						height =
							terrain.mTerrainGroup
								->getHeightAtWorldPosition(
									position);
#endif
						if (height > -9.0f)
							continue;
						std::cout << "worldSize: "
							  << worldSize - 1
							  << std::endl;
						std::cout << "height: " << i
							  << " " << j << " "
							  << height
							  << std::endl;
						item.entity = "altar.glb";
						item.rotation =
							Ogre::Quaternion(0, 0,
									 0, 1);
						position.y = height;
						item.position = position;
						placement.altar_items.push_back(
							item);
					}
				for (i = 0; i < placement.altar_items.size();
				     i++) {
					std::cout << "placement: " << i << " "
						  << placement.altar_items[i]
							     .position
						  << std::endl;
				}
			}
			flecs::entity player = ECS::player;
			CharacterLocation &loc =
				player.get_mut<CharacterLocation>();
			float height =
				get_height(terrain.mTerrainGroup, loc.position);
			loc.position.y = height + 0.0f;
			player.get<CharacterBase>().mBodyNode->setPosition(
				loc.position);
			player.get<CharacterBase>().mBodyNode->setOrientation(
				Ogre::Quaternion());
			player.modified<CharacterLocation>();
		});
}
float TerrainModule::get_height(Ogre::TerrainGroup *group,
				const Ogre::Vector3 &position)
{
	int worldSize = group->getTerrainWorldSize();
	uint16_t terrainSize = group->getTerrainSize();
	long xslot, yslot;
	group->convertWorldPositionToTerrainSlot(position, &xslot, &yslot);
	Ogre::Vector3 slotpos;
	group->convertTerrainSlotToWorldPosition(xslot, yslot, &slotpos);
	Ogre::Vector3 offset = (position - slotpos) * terrainSize / worldSize;
	float height = HeightData::get_singleton()->get_height(
		group, xslot, yslot, (int)offset.x + (terrainSize - 1) / 2,
		(int)offset.z + (terrainSize - 1) / 2);
	return height;
}
}