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

public class PlanetEditor : MonoBehaviour
{
          protected static Transform editorTransform;

          // MESH
          private Mesh mesh;
          private Vector3[] points;
          private Vector3[] vertices;
          private int[] triangles;
          private Vector2[] uvs;

          public float depthLimit = 25;

          public float brushStrength = 0.1f;
          public float brushSize = 1;

          void Start()
          {
              editorTransform = transform;
              mesh = GetComponent<MeshFilter>().mesh;
              Spheriphy();
          }

          void HitCollision(Vector3 colPoint)
          {
              LowerPoint(DefineBrushSize(colPoint), brushStrength);
          }

          void Spheriphy()
          {
              vertices = mesh.vertices;
              triangles = mesh.triangles;
              uvs = mesh.uv;

              mesh.Clear();
              mesh.vertices = vertices;
              mesh.triangles = triangles;
              mesh.uv = uvs;
              mesh.Optimize();
              mesh.RecalculateNormals();
              points = mesh.vertices;

              gameObject.AddComponent<MeshCollider>();
          }

          Vector3 FindNearestPoint(Vector3 point)
          {
              Vector3 nearestPoint = new Vector3();
              float lastDistance = 9999999;

              for (int i = 0; i < points.Length; i++)
              {
                  float distance = Vector3.Distance(point, points[i]);

                  if (distance < lastDistance)
                  {
                      lastDistance = distance;
                      nearestPoint = points[i];
                  }
              }
              return nearestPoint;
          }

          public Vector3[] DefineBrushSize(Vector3 point)
          {
              List<Vector3> brushPoints = new List<Vector3>();
              Vector3 nearestPoint = FindNearestPoint(point);

              for (int i = 0; i < points.Length; i++)
              {
                  float distance = Vector3.Distance(nearestPoint, points[i]);

                  if (distance <= brushSize)
                  {
                      brushPoints.Add(points[i]);
                  }
              }
              return brushPoints.ToArray();
          }

          public void LowerPoint(Vector3[] editPoints, float strength)
          {
              for (int z = 0; z < editPoints.Length; z++)
              {
                  for (int i = 0; i < points.Length; i++)
                  {
                      if (points[i] == editPoints[z])
                      {
                          float pointDistance = Vector3.Distance(points[i], editorTransform.position);

                          if (pointDistance > depthLimit)
                          {
                    for (int v = 0; v < editPoints.Length; v++)
                    {
                        points[i] = points[i].normalized * (pointDistance - strength);
                    }
                          }
                      }
                  }
              }
              UpdateMesh();
          }

          public void UpdateMesh()
          {
              mesh.Clear();
              mesh.vertices = points;
              mesh.triangles = triangles;
              mesh.uv = uvs;
              mesh.Optimize();
              mesh.RecalculateNormals();
              points = mesh.vertices;
          }
}