using System;

using UnityEngine;

using Framework.Support;

using ConditionalAttribute = System.Diagnostics.ConditionalAttribute;

namespace Framework.Geometry.Lines.Intersection {

  /// <summary>Provides helper methods for the navigation classes</summary>
  public static class Intersector {

    /// <summary>Tests whether a point is inside an ellipse</summary>
    /// <param name="point">Point that will be tested for being inside the ellipse</param>
    /// <param name="ellipseCenter">Center of the ellipse the point will be tested against</param>
    /// <param name="ellipseExtents">Extents of the ellipse</param>
    /// <returns>True if the point lies within the ellipse, otherwise false</returns>
    public static bool IsPointInEllipse(
      Vector2 point, Vector2 ellipseCenter, Vector2 ellipseExtents
    ) {
      if((ellipseExtents.x == 0.0f) || (ellipseExtents.y == 0.0f)) {
        return false;
      }

      // Scale the point by the ellipse's aspect ratio so we can perform
      // a simple circle / point intersection test
      float aspect = ellipseExtents.x / ellipseExtents.y;
      point.y = (point.y - ellipseCenter.y) * aspect;
      point.x = (point.x - ellipseCenter.x);

      return point.SqrMagnitude() < (ellipseExtents.x * ellipseExtents.x);
    }

    /// <summary>Tests whether a point is within a rectangle</summary>
    /// <param name="point">Point that will be tested for being inside the rectangle</param>
    /// <param name="rectangleMin">Smaller coordinates of the rectangle</param>
    /// <param name="rectangleMax">Large coordinates of the rectangle</param>
    /// <returns>True if the point is inside the rectangle, false otherwise</returns>
    public static bool IsPointInRectangle(
      Vector2 point, Vector2 rectangleMin, Vector2 rectangleMax
    ) {
      if((rectangleMax.x <= rectangleMin.x) || (rectangleMax.y <= rectangleMin.y)) {
        return false;
      }

      return
        (point.x >= rectangleMin.x) &&
        (point.y >= rectangleMin.y) &&
        (point.x < rectangleMax.x) &&
        (point.y < rectangleMax.y);
    }

    /// <summary>Gets a point on a line segment at the given X coordinate</summary>
    /// <param name="segment">Line segment on which a point will be determined</param>
    /// <param name="x">X coordinate of the point that will be determined</param>
    /// <returns>A point on the line segment at the specified X coordinate</returns>
    /// <remarks>
    ///   If the point lies outside of the line segment, it will be extrapolated.
    /// </remarks>
    public static float GetLineSegmentYfromX(Segment2 segment, float x) {
      if(segment.From.x == segment.To.x) {
        return (segment.From.y + segment.To.y) / 2.0f;
      }

      // Inter- or extrapolate where we'll be on the Y axis at the specified X coordinate.
      Vector2 lineDirection = (segment.To - segment.From);
      float offsetX = x - segment.From.x;
      float offsetY = lineDirection.y * (offsetX / lineDirection.x);

      return segment.From.y + offsetY;
    }

    /// <summary>Finds the closest point to another point in a line segment</summary>
    /// <param name="segment">Line segment on which the closest point will be found</param>
    /// <param name="target">
    ///   Point to which the closest point on the line segment will be found
    /// </param>
    /// <returns>The closest point on the line segment to the target point</returns>
    public static Vector2 GetClosestPointOnLineSegment(
      Segment2 segment, Vector2 target
    ) {
      Vector2 lineDirection = (segment.To - segment.From);
      float lineLength = lineDirection.SqrMagnitude();
      if(lineLength == 0.0f) {
        return segment.From;
      }

      float t = Vector2.Dot(target - segment.From, lineDirection);
      if(t < 0.0f) {
        return segment.From;
      } else if(t > lineLength) {
        return segment.To;
      }

      return segment.From + lineDirection * (t / lineLength);
    }

    /// <summary>Builds the union between a line segment and a rectangle</summary>
    /// <param name="segment">
    ///   Line segment that will be limited to the rectangle's area
    /// </param>
    /// <param name="rectangleMin">Coordinates of the rectangle's smaller corner</param>
    /// <param name="rectangleMax">Coordinates of the rectangle's larger corner</param>
    /// <returns>
    ///   The part of the line segment that was inside the rectangle or null if
    ///   the line segment was completely outside of the rectangle
    /// </returns>
    public static Segment2? GetLineSegmentRectangleUnion(
      Segment2 segment, Vector2 rectangleMin, Vector2 rectangleMax
    ) {
      if((rectangleMax.x <= rectangleMin.x) || (rectangleMax.y <= rectangleMin.y)) {
        return null;
      }

      // Determine the direction into which the line extends
      Vector2 lineDirection = (segment.To - segment.From);
      float lineLength = lineDirection.magnitude;
      lineDirection /= lineLength;

      // Determine the contacts between the line and the disc
      LineContacts contacts = FindLineRectangleContacts(
        segment.From, lineDirection, rectangleMin, rectangleMax
      );
      if(!contacts.HasContact) {
        return null; // Line never intersects the disc
      }
      if((contacts.EntryTime >= lineLength) || (contacts.ExitTime <= 0.0f)) {
        return null; // Intersection ouside of line segment
      }

      // Calculate the point of entry and exit into the ellipse
      return new Segment2(
        segment.From + lineDirection * Math.Max(contacts.EntryTime, 0.0f),
        segment.From + lineDirection * Math.Min(contacts.ExitTime, lineLength)
      );
    }

    /// <summary>Builds the union between a line segment and a disc</summary>
    /// <param name="segment">Line segment that will be limited to the disc's area</param>
    /// <param name="ellipseCenter">Center of the disc</param>
    /// <param name="discRadius">Radius of the disc</param>
    /// <returns>
    ///   The part of the line segment that was inside the disc or null if
    ///   the line segment was completely outside of the disc
    /// </returns>
    public static Segment2? GetLineSegmentEllipseUnion(
      Segment2 segment, Vector2 ellipseCenter, Vector2 ellipseExtents
    ) {
      if((ellipseExtents.x == 0) || (ellipseExtents.y == 0)) {
        return null;
      }

      // Scale the line by the ellipse's aspect ratio so we can process
      // the entire query as if it was a line/circle test
      float aspect = ellipseExtents.x / ellipseExtents.y;
      scaleY(ref segment, ellipseCenter.y, aspect);

      // Determine the direction into which the line extends
      Vector2 lineDirection = (segment.To - segment.From);
      float lineLength = lineDirection.magnitude;
      lineDirection /= lineLength;

      // Determine the contacts between the line and the disc
      LineContacts contacts = FindLineDiscContacts(
        segment.From - ellipseCenter, lineDirection, ellipseExtents.x
      );
      if(!contacts.HasContact) {
        return null; // Line never intersects the disc
      }
      if((contacts.EntryTime >= lineLength) || (contacts.ExitTime <= 0.0f)) {
        return null; // Intersection ouside of line segment
      }

      // Descale the line and direction from the ellipse's aspect ratio into
      // absolute coordinates again
      segment.From.y = (segment.From.y - ellipseCenter.y) / aspect + ellipseCenter.y;
      lineDirection.y /= aspect;

      // Calculate the point of entry and exit on the ellipse
      return new Segment2(
        segment.From + lineDirection * Math.Max(contacts.EntryTime, 0.0f),
        segment.From + lineDirection * Math.Min(contacts.ExitTime, lineLength)
      );
    }

    /// <summary>Locates the instants of intersection between a disc and a line</summary>
    /// <param name="lineOffset">Offset of the line from the disc's center</param>
    /// <param name="lineDirection">Direction into which the line extends</param>
    /// <param name="discRadius">Radius of the disc</param>
    /// <returns>The instants of intersection between the disc and the line</returns>
    public static LineContacts FindLineDiscContacts(
      Vector2 lineOffset, Vector2 lineDirection, float discRadius
    ) {
      float a0 = lineOffset.SqrMagnitude() - (discRadius * discRadius);
      float a1 = Vector2.Dot(lineDirection, lineOffset);

      float discrete = (a1 * a1) - a0;
      if(discrete > 0.0f) {
        discrete = Mathf.Sqrt(discrete);
        return new LineContacts(-a1 - discrete, -a1 + discrete);
      } else {
        return LineContacts.None;
      }
    }

    /// <summary>Finds the points where a line enters and leaves a rectangle</summary>
    /// <param name="lineOffset">Offset of the line from the coordinate system's center</param>
    /// <param name="lineDirection">Direction into which the line extends</param>
    /// <param name="rectangleMin">Coordinates of the rectangle's smaller corner</param>
    /// <param name="rectangleMax">Coordinates of the rectangle's larger corner</param>
    /// <returns>
    ///   The entry and exit times of the line across the rectangle or LineContacts.None
    ///   if the line didn't cross the rectangle.
    /// </returns>
    public static LineContacts FindLineRectangleContacts(
      Vector2 lineOffset, Vector2 lineDirection, Vector2 rectangleMin, Vector2 rectangleMax
    ) {
      LineContacts contacts = LineContacts.None;

      // If the line is not parallel to the Y axis, find out when it will cross
      // the limits of the rectangle horizontally
      if(lineDirection.x != 0.0f) {
        float leftTouchTime = (rectangleMin.x - lineOffset.x) / lineDirection.x;
        float rightTouchTime = (rectangleMax.x - lineOffset.x) / lineDirection.x;
        contacts.EntryTime = Math.Min(leftTouchTime, rightTouchTime);
        contacts.ExitTime = Math.Max(leftTouchTime, rightTouchTime);
      } else if((lineOffset.x < rectangleMin.x) || (lineOffset.x > rectangleMax.x)) {
        return LineContacts.None;
      }

      // If the line is not parallel to the X axis, find out when it will cross
      // the limits of the rectangle vertically
      if(lineDirection.y != 0.0f) {
        float topTouchTime = (rectangleMin.y - lineOffset.y) / lineDirection.y;
        float bottomTouchTime = (rectangleMax.y - lineOffset.y) / lineDirection.y;

        // If the line was parallel to the Y axis (and we already made sure that it actually
        // goes through the rectangle), only the Y axis needs to be taken into account.
        if(lineDirection.x == 0.0f) {
          contacts.EntryTime = Math.Min(topTouchTime, bottomTouchTime);
          contacts.ExitTime = Math.Max(topTouchTime, bottomTouchTime);
        } else {
          float verticalEntryTime = Math.Min(topTouchTime, bottomTouchTime);
          float verticalExitTime = Math.Max(topTouchTime, bottomTouchTime);

          // If the line already left the rectangle on one axis before entering it on
          // the other, it is going past the corner of the rectangle without touching it
          if((verticalExitTime < contacts.EntryTime) || (contacts.ExitTime < verticalEntryTime)) {
            return LineContacts.None;
          }

          contacts.EntryTime = Math.Max(verticalEntryTime, contacts.EntryTime);
          contacts.ExitTime = Math.Min(verticalExitTime, contacts.ExitTime);
        }
      } else if((lineOffset.y < rectangleMin.y) || (lineOffset.y > rectangleMax.y)) {
        return LineContacts.None;
      }

      return contacts;
    }

    /// <summary>Scales a line segment along the Y axis</summary>
    /// <param name="segment">Line segment that will be sclaed</param>
    /// <param name="centerY">Center relative to which the line segment will be scaled</param>
    /// <param name="scaleY">Factor by which the line segment will be scaled</param>
    private static void scaleY(ref Segment2 segment, float centerY, float scaleY) {
      segment.From.y = (segment.From.y - centerY) * scaleY + centerY;
      segment.To.y = (segment.To.y - centerY) * scaleY + centerY;
    }

  }

} // namespace Framework.Geometry.Lines.Intersection