using System;
using System.Collections;
using System.Collections.Generic;
using Framework.Layers;
using UnityEngine;
using UnityEditor;

namespace Framework.Navigation.Platformer {

  /// <summary>
  ///   Assists the user in editing ground definitions for the navigation system
  /// </summary>
  [CustomEditor(typeof(Ground))]
  public class GroundEditor : Editor {

    /// <summary>Tolerance below which poly lines are collapsed into single segments</summary>
    /// <remarks>
    ///   This is used by the automatic ground-polyline generation, which first samples
    ///   the whole of the continuous ground and then simplifies this into a polyline
    ///   that has as few points as possible.
    /// </remarks>
    private const float CollapseTolerance = 0.01f;

    /// <summary>How far from the floor the navigation ground will be placed</summary>
    /// <remarks>
    ///   This helps prevent flickering and feet sinking into the floor. If the value is
    ///   too high, it would look like actors have magic flying boots on.
    /// </remarks>
    private const float FloorDistance = 0.015f;

    /// <summary>Creates a new ground assigned to the right layer and all</summary>
    [MenuItem("GameObject/Create Other/Ground (Platformer Navigation)")]
    public static void CreateGround() {
      int layerIndex = LayerMask.NameToLayer("Navigation");
      if(layerIndex == -1) {
        Debug.LogWarning(
          "Could not find the 'Navigation' layer. You should add a custom layer with this" +
          "name and configure Unity's physics settings so that it doesn't collide with " +
          "anything. Falling back to 'Default' layer for this Ground object."
        );
      }

      GameObject groundGameObject = new GameObject("NavigationGround");
      if(layerIndex != -1) {
        groundGameObject.layer = layerIndex;
      }

      // This allows the navigation system to tell agents where they are
      BoxCollider collider = groundGameObject.AddComponent<BoxCollider>();
      collider.isTrigger = true;

      // Create a ground node with two default points
      Ground ground = groundGameObject.AddComponent<Ground>();
      ground.Heights = new Vector2[] { new Vector2(-0.5f, 0.0f), new Vector2(+0.5f, 0.0f) };
    }

    /// <summary>Called when the Unity editor draws the scene overlay GUI</summary>
    protected void OnSceneGUI() {
      drawGroundVertices();

      if(GUI.changed) {
        EditorUtility.SetDirty(target);
      }

      if(this.selectedHeightSampleIndex != -1) {
        Handles.BeginGUI();
        Vector2 buttonPosition = HandleUtility.WorldToGUIPoint(getSelectedHandlePosition());

        if(GUI.Button(new Rect(buttonPosition.x + 45, buttonPosition.y - 60, 30, 30), "+")) {
          insertNewSample();
        }
        if(GUI.Button(new Rect(buttonPosition.x - 75, buttonPosition.y - 60, 30, 30), "-")) {
          removeCurrentSample();
        }

        Handles.EndGUI();
      }
    }

    /// <summary>Called when Unity wants to layout or draw the inspector</summary>
    public override void OnInspectorGUI() {
      base.OnInspectorGUI();

      if(GUILayout.Button("Fit Ground")) {
        var ground = (Ground)target;
        FitGround(ground);
      }
      if(GUILayout.Button("Fit Collider")) {
        var ground = (Ground)target;
        FitGround(ground);
      }
    }

    /// <summary>Retrieves the position of the current selected handle</summary>
    /// <returns>The position of the currently selected handle</returns>
    private Vector3 getSelectedHandlePosition() {
      var ground = (Ground)target;
      if(this.selectedHeightSampleIndex == -1) {
        return ground.transform.position;
      } else {
        Vector2 height = ground.Heights[this.selectedHeightSampleIndex];
        Vector3 position = ground.transform.position;
        return position + new Vector3(height.x, height.y, 0.0f);
      }
    }

    /// <summary>Removes the currently selected height sample from the ground</summary>
    private void removeCurrentSample() {
      if(this.selectedHeightSampleIndex == -1) {
        return;
      }

      var ground = (Ground)target;
      Vector2[] previousHeights = ground.Heights;
      ground.Heights = new Vector2[ground.Heights.Length - 1];

      for(int index = 0; index < ground.Heights.Length; ++index) {
        int previousIndex = index;
        if(index >= this.selectedHeightSampleIndex) {
          ++previousIndex;
        }
        ground.Heights[index] = previousHeights[previousIndex];
      }

      if(this.selectedHeightSampleIndex >= ground.Heights.Length) {
        this.selectedHeightSampleIndex = ground.Heights.Length - 1;
      }
    }

    /// <summary>Inserts a new sample behind the current selected sample</summary>
    private void insertNewSample() {
      if(this.selectedHeightSampleIndex == -1) {
        return; // Or use last sample?
      }

      var ground = (Ground)target;
      Vector2[] previousHeights = ground.Heights;
      ground.Heights = new Vector2[ground.Heights.Length + 1];

      for(int index = 0; index < ground.Heights.Length; ++index) {
        int previousIndex = index;
        if(index > this.selectedHeightSampleIndex) {
          --previousIndex;
        }
        ground.Heights[index] = previousHeights[previousIndex];
      }

      // If a height sample is inserted between two other height samples, place it in
      // the middle of the two samples
      if(ground.Heights.Length > this.selectedHeightSampleIndex + 2) {
        Vector2 center = (
          ground.Heights[this.selectedHeightSampleIndex] +
          ground.Heights[this.selectedHeightSampleIndex + 2]
        ) / 2.0f;

        ground.Heights[this.selectedHeightSampleIndex + 1] = center;
      } else if(this.selectedHeightSampleIndex > 0) {
        Vector2 extrapolated = ground.Heights[this.selectedHeightSampleIndex] + (
          ground.Heights[this.selectedHeightSampleIndex] -
          ground.Heights[this.selectedHeightSampleIndex - 1]
        );
        ground.Heights[this.selectedHeightSampleIndex + 1] = extrapolated;
      }

      ++this.selectedHeightSampleIndex;
    }

    /// <summary>
    ///   Draws editing handles at the locations of the ground's height samples
    /// </summary>
    private void drawGroundVertices() {
      var ground = (Ground)target;
      Vector3 position = ground.transform.position;

      // Go over each height sample and calculate its position in world coordinates
      for(int index = 0; index < ground.Heights.Length; ++index) {
        Vector2 vertex = ground.Heights[index];

        var center = new Vector3(position.x, position.y, position.z);
        center.x += vertex.x;
        center.y += vertex.y;

        // Always draw the normal handle
        drawNormalHandle(index, center);

        // Allow the user to move the currently selected height sample around
        if(index == this.selectedHeightSampleIndex) {
          drawMoveHandle(center);
        }
      }
    }

    /// <summary>Draws a normal handle for a height sample</summary>
    /// <param name="index">Index if the height sample for which a handle will be drawn</param>
    /// <param name="center">Absolute position of the height sample</param>
    private void drawNormalHandle(int index, Vector3 center) {
      bool wasHandleClicked = Handles.Button(
        center,
        Quaternion.identity,
        0.2f, // size
        0.3f, // pickSize
        Handles.CylinderHandleCap
      );
      if(wasHandleClicked) {
        this.selectedHeightSampleIndex = index;
      }
    }

    /// <summary>Draws a handle that supports moving for a height sample</summary>
    /// <param name="center">Absolute position of the height sample</param>
    private void drawMoveHandle(Vector3 center) {
      var ground = (Ground)target;
      Vector3 position = ground.transform.position;

      // Let Unity know that this object is being changed so it can take care
      // of recording its state in the undo history when moving ceases.
      Undo.RecordObject(ground, "Move Ground Point");

      // Draw the handle and update the height sample with the new position
      Vector3 newPosition = Handles.PositionHandle(center, Quaternion.identity);
      ground.Heights[this.selectedHeightSampleIndex].x = newPosition.x - position.x;
      ground.Heights[this.selectedHeightSampleIndex].y = newPosition.y - position.y;
    }

    /// <summary>Scans the floor and automatically fits a polyline to the walkable area</summary>
    /// <param name="ground">Ground that will be fitted to the floor mesh</param>
    public void FitGround(Ground ground) {
      IList<Vector2> samples = gatherHeightSamples(ground);
      simplifyHeightSamples(samples);

#if DEBUG_GROUND_FITTING
      Debug.Log("  Simplified to " + samples.Count + " height samples");
      for(int index = 0; index < samples.Count; ++index) {
        Debug.Log("Sample #" + index.ToString() + " at " + samples[index].ToString());
      }
#endif

      if(samples.Count >= 2) {
        float left = samples[0].x;
        float right = samples[samples.Count - 1].x;
        float center = Mathf.Floor((left + right) / 2.0f);

        float lowestY = samples[0].y;
        for(int index = 1; index < samples.Count; ++index) {
          lowestY = samples[index].y;
        }

        Vector3 position = ground.transform.position;
        position.x = center;
        position.y = lowestY + FloorDistance;
        position.z = 0;
        ground.transform.position = position;

        ground.Heights = new Vector2[samples.Count];
        for(int index = 0; index < samples.Count; ++index) {
          ground.Heights[index] = new Vector2(
            samples[index].x - center, samples[index].y - lowestY
          );
        }
      }
    }

    /// <summary>Gathers height samples for the navigation ground</summary>
    /// <returns>All height samples from end to end of the navigation ground</returns>
    private static IList<Vector2> gatherHeightSamples(Ground ground) {
      var samples = new List<Vector2>();

      Vector3 position = ground.transform.position;
      position.y += 1.0f;

      int defaultLayerMask = LayerMaskHelper.GetLayerMaskFor("Default");

      RaycastHit hitInfo;
      if(!Physics.Raycast(position, Vector3.down, out hitInfo, 2.0f, defaultLayerMask)) {
        throw new InvalidOperationException(
          "Could not find any solid objects below the navigation ground's location"
        );
      }

      position = hitInfo.point;
      samples.Add(new Vector2(position.x, position.y));

      // Collect samples in negative direction
      for(var offset = new Vector2(); ; offset.x -= 0.1f) {
        Vector3 origin = new Vector3(position.x + offset.x, position.y + offset.y + 1.0f, 0.0f);
        if(!Physics.Raycast(origin, Vector3.down, out hitInfo, 2.0f, defaultLayerMask)) {
          Debug.Log("Ground fitting: Left end at " + origin.ToString() + " in chasm.");
          break;
        }

        float heightDifference = hitInfo.distance - 1.0f;
        if(Mathf.Abs(heightDifference) > 0.1f) {
          Debug.Log("Ground fitting: Left end at " + origin.ToString() + " in wall.");
          break;
        }

        Vector2 sample = new Vector2(hitInfo.point.x, hitInfo.point.y);
        samples.Insert(0, sample);

        offset.y = hitInfo.point.y - position.y;
      }

      // Collect samples in positive direction
      for(var offset = new Vector2(); ; offset.x += 0.1f) {
        Vector3 origin = new Vector3(position.x + offset.x, position.y + offset.y + 1.0f, 0.0f);
        if(!Physics.Raycast(origin, Vector3.down, out hitInfo, 2.0f, defaultLayerMask)) {
          Debug.Log("Ground fitting: Right end at " + origin.ToString() + " in chasm.");
          break;
        }

        float heightDifference = hitInfo.distance - 1.0f;
        if(Mathf.Abs(heightDifference) > 0.1f) {
          Debug.Log("Ground fitting: Right end at " + origin.ToString() + " in wall.");
          break;
        }

        Vector2 sample = new Vector2(hitInfo.point.x, hitInfo.point.y);
        samples.Add(sample);

        offset.y = hitInfo.point.y - position.y;
      }

      return samples;
    }

    /// <summary>Simplifies the speicfied polyline</summary>
    /// <param name="samples">Polyline vertices that will be simplified</param>
    private static void simplifyHeightSamples(IList<Vector2> samples) {
      if((samples != null) && (samples.Count > 2)) {
        eliminateOrSplit(samples, 0, samples.Count - 1);
      }
    }

    /// <summary>
    ///   Eliminates the vertices between the two indices or finds a new split point
    /// </summary>
    /// <param name="samples">Samples of the poly line</param>
    /// <param name="leftIndex">Index of the first vertex considered for simplification</param>
    /// <param name="rightIndex">Index of the last vertex considered for simplification</param>
    private static void eliminateOrSplit(
      IList<Vector2> samples, int leftIndex, int rightIndex
    ) {
      float largestDistance = 0.0f;
      int largestIndex = -1;

      // Look for the vertex with the largest distance to the line segment connecting
      // the corner vertices between which we're working
      for(int index = leftIndex + 1; index < rightIndex; ++index) {
        float distance = squaredDistanceToSegment(
          samples[leftIndex], samples[rightIndex], samples[index]
        );
        if(distance > largestDistance) {
          largestDistance = distance;
          largestIndex = index;
        }
      }

      // If all vertices were within the tolerance, throw them away and replace them by
      // a single line segment
      if(largestDistance < CollapseTolerance) {
        for(int index = rightIndex - 1; index > leftIndex; --index) {
          samples.RemoveAt(index);
        }
      } else { // Otherwise, use the biggest deviation as a new supporting vertex
        eliminateOrSplit(samples, largestIndex, rightIndex);
        eliminateOrSplit(samples, leftIndex, largestIndex);
      }
    }

    /// <summary>Calculates the distance of a point to a line segment</summary>
    /// <param name="start">Start of the line segment</param>
    /// <param name="end">End of the line segment</param>
    /// <param name="point">Point whose distance to the line segment will be calculated</param>
    /// <returns>The distance of the point to the line segment</returns>
    private static float squaredDistanceToSegment(Vector2 start, Vector2 end, Vector2 point) {
      Vector2 lineDirection = end - start;
      Vector2 pointOffset = point - start;

      float dot = Vector2.Dot(pointOffset, lineDirection);
      float interval = dot / lineDirection.sqrMagnitude;
#if POINTS_CAN_LIE_PAST_LINE_ENDS
      if(interval <= 0.0f) {
        return pointOffset.sqrMagnitude;
      } else if(interval >= 1.0f) {
        return (point - end).sqrMagnitude;
      } else {
#endif
        return (point - (start + lineDirection * interval)).sqrMagnitude;
#if POINTS_CAN_LIE_PAST_LINE_ENDS
      }
#endif
    }

#if false
    /// <summary>Makes the ground's collider fit the covered area</summary>
    public void FitCollider() {
      enforceAtLeastTwoHeightsAssigned();

      BoxCollider collider = GetComponent<BoxCollider>();
      if(collider == null) {
        throw new InvalidOperationException(
          "Cannot fit collider on '" + name + "' because no BoxCollider has been added"
        );
      }

      Vector2 min = this.Heights[0];
      Vector2 max = this.Heights[0];
      for(int index = 1; index < this.Heights.Length; ++index) {
        float x = this.Heights[index].x;
        float y = this.Heights[index].y;
        if(x < min.x) {
          min.x = x;
        }
        if(x > max.x) {
          max.x = x;
        }
        if(y < min.y) {
          min.y = y;
        }
        if(y > max.y) {
          max.y = y;
        }
      }

      max.y += 3.5f; // Player height + jump safety zone
      collider.size = new Vector3(max.x - min.x, max.y - min.y, 2.0f);
      collider.center = new Vector3((min.x + max.x) / 2.0f, (min.y + max.y) / 2.0f, 0.0f);
    }
#endif
    
    /// <summary>Index of the currently selected height sample</summary>
    private int selectedHeightSampleIndex = -1;

  }

} // namespace Framework.Navigation.Platformer