using System;

using UnityEngine;

using Framework.Services;
using Framework.Support;

namespace Framework.Cinematics {

  /// <summary>Contains movement instructions for one actor</summary>
  public class Track : ScriptComponent {

    /// <summary>Movement instructions that the actor should execute</summary>
    public Instruction[] Instructions;

    /// <summary>Guesses the position at which the cinematic track begins</summary>
    /// <returns>The position at which the cinematic track probably begins</returns>
    /// <remarks>
    ///   The start position is not fixed because animation tracks may simply pick up
    ///   a character from an arbitrary position and let him/her walk towards the first
    ///   goal. Thus use the position of the first goal at the origin.
    /// </remarks>
    public Vector3 GuessInitialPosition() {
#if false
      for(int index = 0; index < this.Instructions.Length; ++index) {
        if(isMovingInstruction(this.Instructions[index].Action)) {
          return transform.position + this.Instructions[index].Position;
        }
      }
#endif
      return transform.position;
    }

    /// <summary>Called to visualize the movement instructions in the editor</summary>
    protected virtual void OnDrawGizmos() {
      Matrix4x4 oldMatrix = Gizmos.matrix;
      Color oldColor = Gizmos.color;
      try {
        if(this.Instructions != null) {
          drawInstructions();
        }
      }
      finally {
        Gizmos.color = oldColor;
        Gizmos.matrix = oldMatrix;
      }
    }

    /// <summary>Draws the insturctions in the cinematic track</summary>
    private void drawInstructions() {
      Vector3 origin = GuessInitialPosition();

      bool hasDrawnSpecialInstruction = false;
      for(int index = 0; index < this.Instructions.Length; ++index) {
        Vector3 destination;
        if(isMovingInstruction(this.Instructions[index].Action)) {
          destination = transform.position + this.Instructions[index].Position;
        } else {
          destination = origin;
        }

        switch(this.Instructions[index].Action) {
          case Action.Walk: {
            drawWalkInstruction(origin, destination);
            hasDrawnSpecialInstruction = false;
            break;
          }
          case Action.Jump: {
            drawJumpInstruction(origin, destination);
            hasDrawnSpecialInstruction = false;
            break;
          }
          case Action.Turn: {
            drawTurnInstruction(origin, transform.position + this.Instructions[index].Position);
            hasDrawnSpecialInstruction = false;
            break;
          }
          default: {
            if(!hasDrawnSpecialInstruction) {
              drawOtherInstruction(destination);
              hasDrawnSpecialInstruction = true;
            }
            break;
          }
        }

        origin = destination;
      }
    }

    /// <summary>Draws a walk instruction from one place to another</summary>
    /// <param name="origin">Location the walk instruction begins at</param>
    /// <param name="target">Location the walk instruction ends at</param>
    private void drawWalkInstruction(Vector3 origin, Vector3 target) {
      if(origin == target) {
        origin.x -= 0.125f;
        target.x += 0.125f;
      }

      Vector3 direction = Vector3.Normalize(target - origin);
      Gizmos.matrix = Matrix4x4.TRS(
        origin, //(origin + target) / 2.0f,
        Quaternion.LookRotation(direction),
        Vector3.one
      );

      // Using the transformation matrix from before, draw the line segment
      // as a cube (because this uses the depth buffer and makes ground placement
      // much easier to check)
      float length = (target - origin).magnitude;
      Gizmos.color = new Color(1.0f, 1.0f, 0.5f, 0.75f);
      Gizmos.DrawCube(
        new Vector3(0.0f, -0.05f, length / 2.0f),
        new Vector3(0.25f, 0.1f, length)
      );
    }

    /// <summary>Draws a jump instruction into a scene</summary>
    /// <param name="origin">Point from which the character will jump off</param>
    /// <param name="target">Point at which the character will land</param>
    private void drawJumpInstruction(Vector3 origin, Vector3 target) {
      CubicBezierCurve curve = new CubicBezierCurve();
      curve.P0 = origin;
      curve.P1 = Vector3.Lerp(origin, target, 0.5f);
      curve.P2 = Vector3.Lerp(origin, target, 0.75f);
      curve.P3 = target;

      float apex = Math.Max(origin.y, target.y) + 0.5f;
      curve.P1.y = apex;
      curve.P2.y = apex;

      Gizmos.matrix = Matrix4x4.identity;
      Gizmos.color = new Color(1.0f, 1.0f, 0.0f, 1.0f);
      drawCubicBezierCurve(curve);
    }

    /// <summary>Draws an instruction to look at a target into the scene</summary>
    /// <param name="origin">Location the turn instruction will be drawn at</param>
    /// <param name="target">Target the turn instruction will look at</param>
    private void drawTurnInstruction(Vector3 origin, Vector3 target) {
      Vector3 direction = Vector3.Normalize(target - origin);
      Gizmos.matrix = Matrix4x4.TRS(
        origin,
        Quaternion.LookRotation(direction),
        Vector3.one
      );

      Gizmos.color = new Color(1.0f, 1.0f, 0.0f, 1.0f);
      Gizmos.DrawFrustum(Vector3.zero, 10.0f, 2.0f, 0.1f, 1.0f);
      //Gizmos.DrawSphere(target, 0.1f);
    }

    /// <summary>Draws a special (non-movement) instruction into the scene</summary>
    /// <param name="target">Location the special instruction will be drawn at</param>
    private void drawOtherInstruction(Vector3 target) {
      Gizmos.matrix = Matrix4x4.identity;
      Gizmos.color = new Color(1.0f, 1.0f, 1.0f, 0.75f);
      Gizmos.DrawSphere(target, 0.1f);
    }

    /// <summary>Draws a cubic bezier curve using the provided supporting points</summary>
    /// <param name="p0">Location from which the curve starts</param>
    /// <param name="p1">Point towards which the direction of the curve starts out</param>
    /// <param name="p2">Point from which towards p3 the direction of the curve ends</param>
    /// <param name="p3">Location at which the curve ends</param>
    private static void drawCubicBezierCurve(CubicBezierCurve curve) {
      Vector3 previous;
      Vector3 current = curve.P0;
      for(int index = 1; index < 10; ++index) {
        previous = current;
        current = curve.GetPointAtTime((float)index / 10.0f);
        Gizmos.DrawLine(previous, current);
      }
      Gizmos.DrawLine(current, curve.P3);
    }

    /// <summary>
    ///   Checks whether the specified instruction changes the agent's position
    /// </summary>
    /// <param name="action">Action that will be checked</param>
    /// <returns>True if the action declares a movement instruction</returns>
    private bool isMovingInstruction(Action action) {
      return (action == Action.Walk) || (action == Action.Jump);
    }

  }

} // namespace Framework.Cinematics