using System;
using System.Diagnostics;

using UnityEngine;

namespace Framework.Layers {

  /// <summary>Provides helper methods for working with layer masks</summary>
  public static class LayerMaskHelper {

    /// <summary>Index of the layer all game objects are on by default</summary>
    public static readonly int DefaultLayer = 0; //LayerMask.NameToLayer("Default");
    /// <summary>Index of the layer used for transparent effects</summary>
    public static readonly int TransparentFxLayer = 1; //LayerMask.NameToLayer("TransparentFX");
    /// <summary>Index of the layer which by default is ignored by all raycasts</summary>
    public static readonly int IgnoreRaycastLayer = 2; //LayerMask.NameToLayer("IgnoreRaycast");
    /// <summary>Index of the layer intended to bodies of water</summary>
    public static readonly int WaterLayer = 4; //LayerMask.NameToLayer("Water");
    /// <summary>Index of the layer on which world-space UI should be</summary>
    public static readonly int UiLayer = 5;//LayerMask.NameToLayer("UI");

    /// <summary>Builds a layer mask for the specified layers</summary>
    /// <param name="layers">Layers that should be part of the mask</param>
    /// <returns>The layer mask for the specified layers</returns>
    public static int GetLayerMaskFor(params string[] layers) {
      int mask = 0;

      for(int index = 0; index < layers.Length; ++index) {
        int layerIndex = LayerMask.NameToLayer(layers[index]);
        mask |= 1 << layerIndex;
      }

      return mask;
    }

    /// <summary>Gets the layer mask for collision with the specified layer</summary>
    /// <param name="layerName">Name of the layer whose mask will be returned</param>
    /// <returns>The layer collision mask for the specified layer</returns>
    /// <remarks>
    ///   Because calculating the layer mask is a bit costly, the masks will be cached.
    ///   If you change layer collision masks at runtime via Physics.IgnoreLayerCollision(),
    ///   the masks returned by this method will reflect that change until you also
    ///   call <see cref="InvalidateCache" />.
    /// </remarks>
    public static int GetLayerCollisionMaskFor(string layerName) {
      return GetLayerCollisionMaskFor(LayerMask.NameToLayer(layerName));
    }

    /// <summary>Gets the layer mask for collision with the specified layer</summary>
    /// <param name="layerIndex">Index of the layer whose mask will be returned</param>
    /// <returns>The layer collision mask for the specified layer</returns>
    /// <remarks>
    ///   Because calculating the layer mask is a bit costly, the masks will be cached.
    ///   If you change layer collision masks at runtime via Physics.IgnoreLayerCollision(),
    ///   the masks returned by this method will not reflect that change until you also
    ///   call <see cref="InvalidateCache" />.
    /// </remarks>
    public static int GetLayerCollisionMaskFor(int layerIndex) {
      enforceLayerIndexValid(layerIndex);

      // If we have already cached the result, provide it from the cache
      if(layerMaskQueried[layerIndex]) {
        return layerMask[layerIndex];
      }

      // Result was not cached, query the layer mask and put it in the cache
      int mask = queryLayerCollisionMask(layerIndex);
      layerMaskQueried[layerIndex] = true;
      layerMask[layerIndex] = mask;

      return mask;
    }

    /// <summary>Invalidates the cached layer mask for the specified layer index</summary>
    /// <param name="layerName">
    ///   Name of the layer whose cached layer mask will be invalidated
    /// </param>
    public static void InvalidateCache(string layerName) {
      InvalidateCache(LayerMask.NameToLayer(layerName));
    }

    /// <summary>Invalidates the cached layer mask for the specified layer index</summary>
    /// <param name="layerIndex">Layer index whose cached layer mask will be invalidated</param>
    public static void InvalidateCache(int layerIndex) {
      enforceLayerIndexValid(layerIndex);

      layerMaskQueried[layerIndex] = false;
    }

    /// <summary>Queries the collision mask of the specified layer</summary>
    /// <param name="layerIndex">Layer whose collision mask will be queried</param>
    /// <returns>The collision mask of the specified layer</returns>
    private static int queryLayerCollisionMask(int layerIndex) {
      int mask = 0;

      for(int index = 0; index < 32; ++index) {
        if(!Physics.GetIgnoreLayerCollision(layerIndex, index)) {
          mask |= (1 << index);
        }
      }

      return mask;
    }

    /// <summary>Throws an exception if the layer index is not valid</summary>
    /// <param name="layerIndex">Layer index that will be checked</param>
    [Conditional("DEBUG")]
    private static void enforceLayerIndexValid(int layerIndex) {
      if((layerIndex < 0) || (layerIndex >= 32)) {
        throw new ArgumentException("Layer index must be in the 0-31 range", "layerIndex");
      }
    }

    /// <summary>Keeps track of which layer masks have already been queried</summary>
    private static bool[/*32*/] layerMaskQueried = new bool[32];
    /// <summary>Stores the collision masks for each of the 32 possible layers</summary>
    private static int[/*32*/] layerMask = new int[32];

  }

} // namespace Framework.Layers