// ClassicalSharp copyright 2014-2016 UnknownShadow200 | Licensed under MIT
using System;
using ClassicalSharp.GraphicsAPI;
using OpenTK;

namespace ClassicalSharp.Renderers {
	
	public static class ChunkSorter {

		public static void UpdateSortOrder( Game game, ChunkUpdater updater ) {
			Vector3 cameraPos = game.CurrentCameraPos;
			Vector3I newChunkPos = Vector3I.Floor( cameraPos );
			newChunkPos.X = (newChunkPos.X & ~0x0F) + 8;
			newChunkPos.Y = (newChunkPos.Y & ~0x0F) + 8;
			newChunkPos.Z = (newChunkPos.Z & ~0x0F) + 8;
			if( newChunkPos == updater.chunkPos ) return;
			
			ChunkInfo[] chunks = game.MapRenderer.chunks;
			int[] distances = updater.distances;
			Vector3I pPos = newChunkPos;
			updater.chunkPos = pPos;
			
			for( int i = 0; i < chunks.Length; i++ ) {
				ChunkInfo info = chunks[i];
				distances[i] = Utils.DistanceSquared( info.CentreX, info.CentreY, info.CentreZ,
				                                     pPos.X, pPos.Y, pPos.Z );
				
				int dX1 = (info.CentreX - 8) - pPos.X, dX2 = (info.CentreX + 8) - pPos.X;
				int dY1 = (info.CentreY - 8) - pPos.Y, dY2 = (info.CentreY + 8) - pPos.Y;
				int dZ1 = (info.CentreZ - 8) - pPos.Z, dZ2 = (info.CentreZ + 8) - pPos.Z;
				
				// Back face culling: make sure that the chunk is definitely entirely back facing.
				info.DrawLeft = !(dX1 <= 0 && dX2 <= 0);
				info.DrawRight = !(dX1 >= 0 && dX2 >= 0);
				info.DrawFront = !(dZ1 <= 0 && dZ2 <= 0);
				info.DrawBack = !(dZ1 >= 0 && dZ2 >= 0);
				info.DrawBottom = !(dY1 <= 0 && dY2 <= 0);
				info.DrawTop = !(dY1 >= 0 && dY2 >= 0);
			}

			// NOTE: Over 5x faster compared to normal comparison of IComparer<ChunkInfo>.Compare
			if( distances.Length > 1 )
				QuickSort( distances, chunks, 0, chunks.Length - 1 );
			updater.ResetUsedFlags();
			//SimpleOcclusionCulling();
		}
		
		static void QuickSort( int[] keys, ChunkInfo[] values, int left, int right ) {
			while( left < right ) {
				int i = left, j = right;
				int pivot = keys[(i + j) / 2];
				// partition the list
				while( i <= j ) {
					while( pivot > keys[i] ) i++;
					while( pivot < keys[j] ) j--;
					
					if( i <= j ) {
						int key = keys[i]; keys[i] = keys[j]; keys[j] = key;
						ChunkInfo value = values[i]; values[i] = values[j]; values[j] = value;
						i++; j--;
					}
				}
				
				// recurse into the smaller subset
				if( j - left <= right - i ) {
					if( left < j )
						QuickSort( keys, values, left, j );
					left = i;
				} else {
					if( i < right )
						QuickSort( keys, values, i, right );
					right = j;
				}
			}
		}
	}
}