using UnityEngine;
using System.Collections;

public class CursorGrid : MonoBehaviour {

	public Terrain terrain;
	private TerrainData terrainData;
	private Vector3 terrainSize;
	private int heightmapWidth;
	private int heightmapHeight;
	private float[,] heightmapData;
	public Transform Object1;
	public Transform Object2;

	void GetTerrainData()
	{
	    if ( !terrain )
	    {
	       terrain = Terrain.activeTerrain;
	    }

	    terrainData = terrain.terrainData;

	    terrainSize = terrain.terrainData.size;

	    heightmapWidth = terrain.terrainData.heightmapWidth;
	    heightmapHeight = terrain.terrainData.heightmapHeight;

	    heightmapData = terrainData.GetHeights( 0, 0, heightmapWidth, heightmapHeight );
	}

	private Vector3 rayHitPoint;
	private Vector3 heightmapPos;

	// Use this for initialization
	void Start () {
		GetTerrainData();
    	ConstructMesh();
		Debug.Log("Initiated.");
	}

	// Update is called once per frame
	void Update () {
		// raycast to the terrain
	    RaycastToTerrain();

	    // find the heightmap position of that hit
	    GetHeightmapPosition();

	    // Calculate Grid
	    CalculateGrid();

	    // Update Mesh
	    UpdateMesh();
	}

	void RaycastToTerrain()
	{
	    RaycastHit hit;
	    Ray rayPos = Camera.main.ScreenPointToRay( Input.mousePosition );

	    if ( Physics.Raycast( rayPos, out hit, Mathf.Infinity ) ) // also consider a layermask to just the terrain layer
	    {
	       Debug.DrawLine( Camera.main.transform.position, hit.point, Color.red );
	       rayHitPoint = hit.point;
	    }

		if(Input.GetKeyDown(KeyCode.Mouse0)){
			Debug.Log ("Instantiating Windmill.");
			Instantiate(Object1, hit.point, Quaternion.Euler (0,120,0));
		}

		if(Input.GetKeyDown(KeyCode.Mouse1)){
			Debug.Log ("Instantiating Farm.");
			Instantiate(Object2, hit.point, Quaternion.identity);
		}
	}


	void GetHeightmapPosition()
	{
	    // find the heightmap position of that hit
	    heightmapPos.x = ( rayHitPoint.x / terrainSize.x ) * ((float) heightmapWidth );
	    heightmapPos.z = ( rayHitPoint.z / terrainSize.z ) * ((float) heightmapHeight );

	    // convert to integer
	    heightmapPos.x = Mathf.Round( heightmapPos.x );
	    heightmapPos.z = Mathf.Round( heightmapPos.z );

	    // clamp to heightmap dimensions to avoid errors
	    heightmapPos.x = Mathf.Clamp( heightmapPos.x, 0, heightmapWidth - 1 );
	    heightmapPos.z = Mathf.Clamp( heightmapPos.z, 0, heightmapHeight - 1 );
	}


	// --------------------------------------------------------------------------- Calculate Grid

	private Vector3[,] mapGrid = new Vector3[ 9, 9 ];

	public float indicatorSize = 1.0f;
	public float indicatorOffsetY = 5.0f;


	void CalculateGrid()
	{
	    for ( int z = -4; z < 5; z ++ )
	    {
	       for ( int x = -4; x < 5; x ++ )
	       {
	         Vector3 calcVector;

	         calcVector.x = heightmapPos.x + ( x * indicatorSize );
	         calcVector.x /= ((float) heightmapWidth );
	         calcVector.x *= terrainSize.x;

	         float calcPosX = heightmapPos.x + ( x * indicatorSize );
	         calcPosX = Mathf.Clamp( calcPosX, 0, heightmapWidth - 1 );

	         float calcPosZ = heightmapPos.z + ( z * indicatorSize );
	         calcPosZ = Mathf.Clamp( calcPosZ, 0, heightmapHeight - 1 );

	         calcVector.y = heightmapData[ (int)calcPosZ, (int)calcPosX ] * terrainSize.y; // heightmapData is Y,X ; not X,Y (reversed)
	         calcVector.y += indicatorOffsetY; // raise slightly above terrain

	         calcVector.z = heightmapPos.z + ( z * indicatorSize );
	         calcVector.z /= ((float) heightmapHeight );
	         calcVector.z *= terrainSize.z;

	         mapGrid[ x + 4, z + 4 ] = calcVector;
	       }
	    }
	}


	// --------------------------------------------------------------------------- INDICATOR MESH

	private Mesh mesh;

	private Vector3[] verts;
	private Vector2[] uvs;
	private int[] tris;


	void ConstructMesh()
	{
	    if ( !mesh )
	    {
	       	mesh = new Mesh();
			MeshFilter f = GetComponent("MeshFilter") as MeshFilter;
			f.mesh = mesh;
	    	mesh.name = gameObject.name + "Mesh";
	    }

	    mesh.Clear();

	    verts = new Vector3[9 * 9];
	    uvs = new Vector2[9 * 9];
	    tris = new int[ 8 * 2 * 8 * 3];

	    float uvStep = 1.0f / 8.0f;

	    int index = 0;
	    int triIndex = 0;

	    for ( int z = 0; z < 9; z ++ )
	    {
	       for ( int x = 0; x < 9; x ++ )
	       {
	         verts[ index ] = new Vector3( x, 0, z );
	         uvs[ index ] = new Vector2( ((float)x) * uvStep, ((float)z) * uvStep );

	         if ( x < 8 && z < 8 )
	         {
	          tris[ triIndex + 0 ] = index + 0;
	          tris[ triIndex + 1 ] = index + 9;
	          tris[ triIndex + 2 ] = index + 1;

	          tris[ triIndex + 3 ] = index + 1;
	          tris[ triIndex + 4 ] = index + 9;
	          tris[ triIndex + 5 ] = index + 10;

	          triIndex += 6;
	         }

	         index ++;
	       }
	    }


	    // - Build Mesh -
	    mesh.vertices = verts;
	    mesh.uv = uvs;
	    mesh.triangles = tris;

	    mesh.RecalculateBounds();
	    mesh.RecalculateNormals();
	}


	void UpdateMesh()
	{
	    int index = 0;

	    for ( int z = 0; z < 9; z ++ )
	    {
	       for ( int x = 0; x < 9; x ++ )
	       {
	         verts[ index ] = mapGrid[ x, z ];

	         index ++;

	       }
	    }

	    // assign to mesh
	    mesh.vertices = verts;

	    mesh.RecalculateBounds();
	    mesh.RecalculateNormals();
	}

	void OnMouseUp ()

	{
	/*				GameObject newObject;

					newObject = (GameObject) Instantiate(Object1, hit.point, Quaternion.identity);

					Vector3 currentPosition = newObject.transform.position;

					currentPosition.y = currentPosition.y + 5.0f;

					newObject.transform.position = currentPosition;*/
	}
}