using UnityEngine;
using System.Collections;
using System;
using System.Threading;
using System.Collections.Generic;

public class MapGenerator : MonoBehaviour
{

	// Þetta er hérna til þess að við getum valið hvað við viljum sjá inní Unity
	// Þetta leyfir okkur að sjá svarthvítu myndirnar sem að heimurinn reiknast útfrá
	public enum DrawMode
	{
		NoiseMap,
		ColorMap,
		Mesh,
		FalloffMap,
		HeatMap}
	;

	// Hérna geymist í hvaða drawMode við erum með stilt á
	public DrawMode drawMode;

	// Hérna getum við stillt hvort að við erum í Local eða Global
	// Normailzation Mode, Þetta hefur áhrif á þegar að mismunandi "reitir"
	// af heiminum snertast, ef við erum í global þá reiknast betur útúr þessu fyrir
	// marga reiti, en local er gott ef þú ert bara með einn reit
	public Noise.NormalizeMode normalizeMode;

	// Viðjum við hafa flata skyggingu ?? Já við viljum það þannig að þetta ætti alltaf að vera stillt á
	public bool useFlatShading;

	// Range er hérna til að Unity gefi okkur slider til að við getum "on the fly" breytt detail levelum
	// á terrain'inum inní editornum, þetta hefur engin áhrif þegar að leikurinn er "live"
	[Range (0, 6)]
	public int editorPreviewLOD;

	// Stilling fyrir hversu langt er á milli fjalla "basically"
	public float noiseScale;

	// Þetta er allt dót sem að er til að reikna hægðir og lægðir í heiminum
	public int octaves;
	[Range (0, 1)]
	public float persistance;
	public float lacunarity;

	// hér er seedið, það er stillt í Unity og ætti ekki að vera breytt, á að vera "80194"
	public int seed;

	// Offset á þennan chunk, notað til að við fáum ekki sama "height map" á alla reiti
	public Vector2 offset;

	// Þetta er notað til að "takmarka stærð heimsins", Falloff mappið lækkar landslagið eftir að þu ert
	// kominn lengra út á það og endar þá með að það sé svo bara sjór allt í kring
	public bool useFalloff;

	// Þetta er til að margfalda hæðartöluna svo að landslagið fái alvöru hæð, annars væru fjöllin bara
	// einhverjar þúfur
	public float meshHeightMultiplier;
	public AnimationCurve meshHeightCurve;

	// Stilling fyrir Unity Editorinn og leyfir okkur að auto updeita það sem að renderast í
	// editornum, gott ef við viljum sjá stillingar hafa áhrif á heiminn án þess að þurfa að
	// ýta á "Generate" takkan til að sjá þetta
	public bool autoUpdate;

	// Regions er listi af "ef hæðin á þessum punkti er þessi þá er jörðin svona á litin"
	// svona er vatn blátt, fjöll grá og grasið grænt, eins og er, þetta mun breytast
	public TerrainType[] regions;

	// Þetta er static instance af þessum classa, bara svo við getum sótt upplýsingar í hann
	// út öðrum clössum
	static MapGenerator instance;

	// Biome Systemið, þetta er ekki full klárað og á efitr að breytast dass
	public bool useBiomeSystem;
	public BiomeGenerator biomeGenerator = new BiomeGenerator ();
	public MapData heatMap;

	// Þetta er Array sem að geymir upplýsingar um falloff mappið
	float[,] falloffMap;

	// Þessir hérna tveir eru til þess að sækja map uplýsingar og reikna það á öðrum kjarna
	// á örgjafanum
	Queue<MapThreadInfo<MapData>> mapDataThreadInfoQueue = new Queue<MapThreadInfo<MapData>> ();
	Queue<MapThreadInfo<MeshData>> meshDataThreadInfoQueue = new Queue<MapThreadInfo<MeshData>> ();

	// Awake er skipun frá Unity og ég nota hana hér til að búa til falloff mappið
	void Awake ()
	{
		falloffMap = FalloffGenerator.generateFalloffMap (mapChunkSize);
	}


	// hérna færðu töluna um hversu margir punktar eru í "einum reit" af heimunum
	public static int mapChunkSize {
		get {
			setInstance ();
			if (instance.useFlatShading)
				return 95;
			else
				return 239;
		}
	}

	// Þessi skipun leyfir okkur að sjá hitt og þetta í editornum
	public void drawMapInEditor ()
	{

		setInstance ();
		MapData mapData = generateMapData (Vector2.zero);
		MapDisplay display = FindObjectOfType<MapDisplay> ();

		heatMap = biomeGenerator.generateHeatMapData (Vector2.zero, instance);

		if (drawMode == DrawMode.NoiseMap)
			display.drawTexture (TextureGenerator.textureFromHeightMap (mapData.heightMap));
		else if (drawMode == DrawMode.ColorMap)
			display.drawTexture (TextureGenerator.textureFromColorMap (mapData.colorMap, mapChunkSize, mapChunkSize));
		else if (drawMode == DrawMode.Mesh)
			display.drawMesh (MeshGenerator.generateTerrainMesh (mapData.heightMap, heatMap.heightMap, meshHeightMultiplier, meshHeightCurve, editorPreviewLOD, useFlatShading), TextureGenerator.textureFromColorMap (mapData.colorMap, mapChunkSize, mapChunkSize));
		else if (drawMode == DrawMode.FalloffMap)
			display.drawTexture (TextureGenerator.textureFromHeightMap (FalloffGenerator.generateFalloffMap (mapChunkSize)));
		else if (drawMode == DrawMode.HeatMap)
			display.drawTexture (TextureGenerator.textureFromHeightMap (heatMap.heightMap));
	}

	// þetta er hér til að vera viss um að "instancið" af þessum classa sé ekki "null"
	static void setInstance ()
	{
		if (instance == null)
			instance = FindObjectOfType<MapGenerator> ();
	}

	// þetta er multy tasking dót, ekki pæla of mikið í þessu
	public void requestMapData (Vector2 center, Action<MapData> callback)
	{
		ThreadStart threadStart = delegate {
			MapDataThread (center, callback);
		};

		new Thread (threadStart).Start ();
	}

	void MapDataThread (Vector2 center, Action<MapData> callback)
	{
		MapData mapData = generateMapData (center);
		lock (mapDataThreadInfoQueue) {
			mapDataThreadInfoQueue.Enqueue (new MapThreadInfo<MapData> (callback, mapData));
		}
	}

	public void requestMeshData (MapData mapData, int lod, Action<MeshData> callback)
	{
		ThreadStart threadStart = delegate {
			MeshDataThread (mapData, lod, callback);
		};
		new Thread (threadStart).Start ();
	}

	void MeshDataThread (MapData mapData, int lod, Action<MeshData> callback)
	{
		MeshData meshData = MeshGenerator.generateTerrainMesh (mapData.heightMap, heatMap.heightMap, meshHeightMultiplier, meshHeightCurve, lod, useFlatShading);
		lock (meshDataThreadInfoQueue) {
			meshDataThreadInfoQueue.Enqueue (new MapThreadInfo<MeshData> (callback, meshData));
		}
	}


	// þetta er skipun frá unity sem að sér um að senda update áður en að hver einasti frame er búin til
	// þessi skipun er semsagt kölluð jafn oft og FPS'ið þitt á sek, semsagt öruglega yfir 100 sinnum á sec
	// hér erum við í þessu tilfelli bara að vera viss um að ef það þarf að reikna eitthvað þá er verið að
	// láta hinn kjarnan af örgjafanum sjá um að reikna
	void Update ()
	{
		if (mapDataThreadInfoQueue.Count > 0) {
			for (int i = 0; i < mapDataThreadInfoQueue.Count; i++) {
				MapThreadInfo<MapData> threadInfo = mapDataThreadInfoQueue.Dequeue ();
				threadInfo.callback (threadInfo.parameter);
			}
		}

		if (meshDataThreadInfoQueue.Count > 0) {
			for (int i = 0; i < meshDataThreadInfoQueue.Count; i++) {
				MapThreadInfo<MeshData> threadInfo = meshDataThreadInfoQueue.Dequeue ();
				threadInfo.callback (threadInfo.parameter);
			}
		}
	}

	// Hér gerist smá af töfrunum en þetta er það sem að setur saman allar upplýsingar um mappið svo það sé bara hægt að skila því og GO !!
	MapData generateMapData (Vector2 center)
	{
		float[,] noiseMap = Noise.generateNoiseMap (mapChunkSize + 2, mapChunkSize + 2, seed, noiseScale, octaves, persistance, lacunarity, center + offset, normalizeMode);

		heatMap = biomeGenerator.generateHeatMapData (center, instance);

		Color[] colorMap = new Color[mapChunkSize * mapChunkSize];
		for (int y = 0; y < mapChunkSize; y++) {
			for (int x = 0; x < mapChunkSize; x++) {
				if (useFalloff) {
					noiseMap [x, y] = Mathf.Clamp01 (noiseMap [x, y] - falloffMap [x, y]);
				}
				float currentHeight = noiseMap [x, y];
				for (int i = 0; i < regions.Length; i++) {
					if (currentHeight >= regions [i].height) {
						Color color = regions [i].color;
						if (useBiomeSystem) {
							color.r += heatMap.heightMap [x, y] / 5;
							color.g += heatMap.heightMap [x, y] / 5;
							color.b += heatMap.heightMap [x, y] / 5;
						}
						colorMap [y * mapChunkSize + x] = color;
					} else {
						break;
					}
				}
			}
		}

		return new MapData (noiseMap, colorMap);
	}

	// Skipun í Unity sem að leyfir okkur að tékka stillingar sem var breytt í editornum og þannig að ef sumar tölur
	// meiga ekki vera minni en 1 eða 0 þá setjum við þær í 0 ef þú setur þessar neðar
	void OnValidate ()
	{
		if (lacunarity < 1)
			lacunarity = 1;
		if (octaves < 0)
			octaves = 0;

		falloffMap = FalloffGenerator.generateFalloffMap (mapChunkSize);
	}

	struct MapThreadInfo<T>
	{
		public readonly Action<T> callback;
		public readonly T parameter;

		public MapThreadInfo (Action<T> callback, T parameter)
		{
			this.callback = callback;
			this.parameter = parameter;
		}
	}

}


// Þetta kemur upp í Unity undir "Regions" og þar er hægt að stilla frá þessari hæð að næstu þá er jörðin svona á litin
[System.Serializable]
public struct TerrainType
{
	public string name;
	public float height;
	public Color color;
}


// þetta er bara hlutur til að geima mappið í, bara fyrir þægindiß
public struct MapData
{
	public readonly float[,] heightMap;
	public readonly Color[] colorMap;

	public MapData (float[,] heightMap, Color[] colorMap)
	{
		this.heightMap = heightMap;
		this.colorMap = colorMap;
	}

}