using System;

using UnityEngine;

namespace Framework.Support {

  /// <summary>Casts differen collider shapes into the world</summary>
  public class ShapeCaster {
    
    #region enum ColliderShape

    /// <summary>Shape of a collider</summary>
    private enum ColliderShape : uint {

      /// <summary>The collider is a perfectly round sphere</summary>
      Sphere = 0,
      /// <summary>The collider is a cylinder with hemispheres at its ends</summary>
      Capsule = 1,
      /// <summary>The collider is a box with different side lengths</summary>
      Box = 2
      
    }
    
    #endregion // enum ColliderShape
    
    /// <summary>Delegate for a shape cast with a single result</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="hitInfo">Receives informations about the collider that was hit</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>True if the shape cast hit another collider</returns>
    private delegate bool ShapeCastDelegate(
      Vector3 position, Vector3 direction,
      out RaycastHit hitInfo,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    );
    
    /// <summary>Delegate for a shape cast that returns all hit colliders</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>A list of all colliders hit by the shape cast</returns>
    private delegate RaycastHit[] ShapeCastAllDelegate(
      Vector3 position, Vector3 direction,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    );
    
    /// <summary>Delegate for a shape cast that write all hit colliders into an array</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="results">Array that will receive the colliders that were hit</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>The number of colliders that were hit by the shape cast</returns>
    private delegate int ShapeCastNonAllocDelegate(
      Vector3 position, Vector3 direction,
      RaycastHit[] results,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    );
    
    /// <summary>Initialized a new collider caster</summary>
    /// <param name="collider">Collider that will be cast</param>
    public ShapeCaster(Collider collider) {
      this.shapeCastDelegates = new ShapeCastDelegate[] {
        sphereCast, capsuleCast, boxCast
      };
      this.shapeCastAllDelegates = new ShapeCastAllDelegate[] {
        sphereCastAll, capsuleCastAll, boxCastAll
      };
      this.shapeCastNonAllocDelegates = new ShapeCastNonAllocDelegate[] {
        sphereCastNonAlloc, capsuleCastNonAlloc, boxCastNonAlloc
      };

      changeCollider(collider);
    }

    /// <summary>Collider the caster is casting</summary>
    /// <exception cref="ArgumentException">
    ///   Thrown if the collider was not of a support type
    /// </exception>
    public Collider Collider {
      get {
        switch(this.colliderShape) {
          case ColliderShape.Sphere: { return this.sphereCollider; }
          case ColliderShape.Capsule: { return this.capsuleCollider; }
          case ColliderShape.Box: { return this.boxCollider; }
          default: { throw new InvalidOperationException("Invalid collider"); }
        }
      }
      set {
        if(!ReferenceEquals(value, Collider)) {
          changeCollider(value);
        }
      }
    }

    /// <summary>Casts the shape of the collider into the specified direction</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction the shape will be cast into</param>
    /// <param name="hitInfo">Receives informations about the collider that was hit</param>
    /// <param name="maxDistance">Maximum distance to consider for collisions</param>
    /// <param name="layerMask">Layers the shape can hit colliders on</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>True if a collider was hit by the shape cast</returns>
    public bool ShapeCast(
      Vector3 position, Vector3 direction,
      out RaycastHit hitInfo,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    ) {
      return this.shapeCastDelegates[(int)this.colliderShape](
        position, direction, out hitInfo, maxDistance, layerMask, queryTriggerInteraction
      );
    }

    /// <summary>Delegate for a shape cast that returns all hit colliders</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>A list of all colliders hit by the shape cast</returns>
    public RaycastHit[] ShapeCastAll(
      Vector3 position, Vector3 direction,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    ) {
      return this.shapeCastAllDelegates[(int)this.colliderShape](
        position, direction, maxDistance, layerMask, queryTriggerInteraction
      );
    }

    /// <summary>Delegate for a shape cast that write all hit colliders into an array</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="results">Array that will receive the colliders that were hit</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>The number of colliders that were hit by the shape cast</returns>
    public int ShapeCastNonAlloc(
      Vector3 position, Vector3 direction,
      RaycastHit[] results,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    ) {
      return this.shapeCastNonAllocDelegates[(int)this.colliderShape](
        position, direction, results, maxDistance, layerMask, queryTriggerInteraction
      );
    }

    /// <summary>Changes the collider that will be cast as a shape</summary>
    /// <param name="collider">New collider to cast</param>
    /// <exception cref="ArgumentException">
    ///   Thrown if the collider was not of a support type
    /// </exception>
    private void changeCollider(Collider collider) {
      this.sphereCollider = (collider as SphereCollider);
      this.capsuleCollider = (collider as CapsuleCollider);
      this.boxCollider = (collider as BoxCollider);

      if(this.sphereCollider != null) {
        this.colliderShape = ColliderShape.Sphere;
      } else if(this.capsuleCollider != null) {
        this.colliderShape = ColliderShape.Capsule;
      } else if(this.boxCollider != null) {
        this.colliderShape = ColliderShape.Box;
      } else {
        throw new ArgumentException("Unsupported collider type", "collider");
      }
    }
    
    /// <summary>Returns informations for the first hit of a sphere cast</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="hitInfo">Receives informations about the collider that was hit</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>True if the shape cast hit another collider</returns>
    private bool sphereCast(
      Vector3 position, Vector3 direction,
      out RaycastHit hitInfo,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    ) {
      return Physics.SphereCast(
        position + this.sphereCollider.center,
        this.sphereCollider.radius,
        direction,
        out hitInfo,
        maxDistance, layerMask, queryTriggerInteraction
      );
    }    

    /// <summary>Returns informations for the first hit of a capsule cast</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="hitInfo">Receives informations about the collider that was hit</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>True if the shape cast hit another collider</returns>
    private bool capsuleCast(
      Vector3 position, Vector3 direction,
      out RaycastHit hitInfo,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    ) {
      Vector3 point1 = position + this.capsuleCollider.center;
      Vector3 point2 = point1;

      float halfHeight = this.capsuleCollider.height / 2.0f;
      switch(this.capsuleCollider.direction) {
        case 0: {
          point1.x -= halfHeight;
          point2.x += halfHeight;
          break;
        }
        case 1: {
          point1.y -= halfHeight;
          point2.y += halfHeight;
          break;
        }
        case 2: {
          point1.z -= halfHeight;
          point2.z += halfHeight;
          break;
        }
      }

      return Physics.CapsuleCast(
        point1, point2, this.capsuleCollider.radius,
        direction,
        out hitInfo,
        maxDistance, layerMask, queryTriggerInteraction
      );
    }    

    /// <summary>Returns informations for the first hit of a box cast</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="hitInfo">Receives informations about the collider that was hit</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>True if the shape cast hit another collider</returns>
    private bool boxCast(
      Vector3 position, Vector3 direction,
      out RaycastHit hitInfo,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    ) {
      Vector3 extents = this.boxCollider.size / 2.0f; 
      return Physics.BoxCast(
        position + this.boxCollider.center, extents,
        direction,
        out hitInfo,
        this.boxCollider.transform.rotation,
        maxDistance, layerMask, queryTriggerInteraction
      );
    }    

    /// <summary>Returns informations for all colliders hit by a sphere cast</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>A list of all colliders hit by the shape cast</returns>
    private RaycastHit[] sphereCastAll(
      Vector3 position, Vector3 direction,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    ) {
      return Physics.SphereCastAll(
        position + this.sphereCollider.center,
        this.sphereCollider.radius,
        direction,
        maxDistance, layerMask, queryTriggerInteraction
      );
    }

    /// <summary>Returns informations for all colliders hit by a sphere cast</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>A list of all colliders hit by the shape cast</returns>
    private RaycastHit[] capsuleCastAll(
      Vector3 position, Vector3 direction,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    ) {
      Vector3 point1 = position + this.capsuleCollider.center;
      Vector3 point2 = point1;

      float halfHeight = this.capsuleCollider.height / 2.0f;
      switch(this.capsuleCollider.direction) {
        case 0: {
          point1.x -= halfHeight;
          point2.x += halfHeight;
          break;
        }
        case 1: {
          point1.y -= halfHeight;
          point2.y += halfHeight;
          break;
        }
        case 2: {
          point1.z -= halfHeight;
          point2.z += halfHeight;
          break;
        }
      }

      return Physics.CapsuleCastAll(
        point1, point2, this.capsuleCollider.radius,
        direction,
        maxDistance, layerMask, queryTriggerInteraction
      );
    }
    
    /// <summary>Returns informations for all colliders hit by a sphere cast</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>A list of all colliders hit by the shape cast</returns>
    private RaycastHit[] boxCastAll(
      Vector3 position, Vector3 direction,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    ) {
      Vector3 extents = this.boxCollider.size / 2.0f; 
      return Physics.BoxCastAll(
        position + this.boxCollider.center, extents,
        direction,
        this.boxCollider.transform.rotation,
        maxDistance, layerMask, queryTriggerInteraction
      );
    }

    /// <summary>Write informations for all colliders hit by a sphere cast into an array</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="results">Array that will receive the colliders that were hit</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>The number of colliders that were hit by the shape cast</returns>
    private int sphereCastNonAlloc(
      Vector3 position, Vector3 direction,
      RaycastHit[] results,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    ) {
      return Physics.SphereCastNonAlloc(
        position + this.sphereCollider.center,
        this.sphereCollider.radius,
        direction,
        results,
        maxDistance, layerMask, queryTriggerInteraction
      );
    }

    /// <summary>Write informations for all colliders hit by a capsule cast into an array</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="results">Array that will receive the colliders that were hit</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>The number of colliders that were hit by the shape cast</returns>
    private int capsuleCastNonAlloc(
      Vector3 position, Vector3 direction,
      RaycastHit[] results,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    ) {
      Vector3 point1 = position + this.capsuleCollider.center;
      Vector3 point2 = point1;

      float halfHeight = this.capsuleCollider.height / 2.0f;
      switch(this.capsuleCollider.direction) {
        case 0: {
          point1.x -= halfHeight;
          point2.x += halfHeight;
          break;
        }
        case 1: {
          point1.y -= halfHeight;
          point2.y += halfHeight;
          break;
        }
        case 2: {
          point1.z -= halfHeight;
          point2.z += halfHeight;
          break;
        }
      }

      return Physics.CapsuleCastNonAlloc(
        point1, point2, this.capsuleCollider.radius,
        direction,
        results,
        maxDistance, layerMask, queryTriggerInteraction
      );
    }

    /// <summary>Write informations for all colliders hit by a box cast into an array</summary>
    /// <param name="position">Position of the game object carrying the collider</param>
    /// <param name="direction">Direction into which the shape will be cast</param>
    /// <param name="results">Array that will receive the colliders that were hit</param>
    /// <param name="maxDistance">Maximum distance to consider for the shape cast</param>
    /// <param name="layerMask">Layers on which to check for collisions</param>
    /// <param name="queryTriggerInteraction">How to deal with trigger colliders</param>
    /// <returns>The number of colliders that were hit by the shape cast</returns>
    private int boxCastNonAlloc(
      Vector3 position, Vector3 direction,
      RaycastHit[] results,
      float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction
    ) {
      Vector3 extents = this.boxCollider.size / 2.0f; 
      return Physics.BoxCastNonAlloc(
        position + this.boxCollider.center, extents,
        direction,
        results,
        this.boxCollider.transform.rotation,
        maxDistance, layerMask, queryTriggerInteraction
      );
    }

    /// <summary>Delegates for single hit shape casting methods</summary>
    private readonly ShapeCastDelegate[/*2*/] shapeCastDelegates;
    /// <summary>Delegates for multi hit shape casting methods</summary>
    private readonly ShapeCastAllDelegate[/*2*/] shapeCastAllDelegates;
    /// <summary>Delegates for multi hit allocation-free shape casting methods</summary>
    private readonly ShapeCastNonAllocDelegate[/*2*/] shapeCastNonAllocDelegates;
    
    /// <summary>Shape of the collider that is cast by this caster</summary>
    private ColliderShape colliderShape;
    
    /// <summary>Sphere collider that will be cast if this is a sphere caster</summary>
    private SphereCollider sphereCollider;
    /// <summary>Sphere collider that will be cast if this is a capsule caster</summary>
    private CapsuleCollider capsuleCollider;
    /// <summary>Sphere collider that will be cast if this is a box caster</summary>
    private BoxCollider boxCollider;

  }

} // namespace Framework.Support