using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;

using UnityEngine;

using Framework.Services;

using Debug = UnityEngine.Debug;

namespace Framework.Layers {

  /// <summary>Manages named layer masks throughout the game</summary>
  /// <remarks>
  ///   In order to keep layer masks consistent across multiple scenes and to ensure
  ///   this data is stored in one place only, the layer mask manager loads layer
  ///   masks from the resource file and lets you access them by name.
  /// </remarks>
  [ServiceScope(Scope.Global)]
  public class LayerMaskManager : Service, ILayerMaskService {

    /// <summary>Called when the component gets loaded into a game object</summary>
    protected override void Awake() {
      this.defaultMaskBuilt = new bool[32];
      this.defaultMask = new int[32];
      this.namedMasks = new Dictionary<string, int>();

      LoadLayerMaskList("DefaultLayerMasks");
      LoadLayerMaskList("LayerMasks");
    }

    /// <summary>Loads named layer masks from the specified resource</summary>
    /// <param name="resourcePath">
    ///   Path of the resource containing named layer mask definitions
    /// </param>
    public void LoadLayerMaskList(string resourcePath) {
      TextAsset layerMaskList = Resources.Load(resourcePath, typeof(TextAsset)) as TextAsset;
      if(layerMaskList == null) {
        Debug.LogWarning(
          "Layer mask list not found at path '" + resourcePath + "'"
        );
      } else {
        using(var reader = new StringReader(layerMaskList.text)) {
          LayerMaskListParser.Read(this.namedMasks, reader);
        }
      }
    }

    /// <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>
    /// <remarks>
    ///   Builds a mask from the named layers.
    /// </remarks>
    public static int BuildMask(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>
    ///   Looks up the default collision mask for the layer with the specified name
    /// </summary>
    /// <param name="layerName">
    ///   Name of the layer whose collision mask will be looked up
    /// </param>
    /// <returns>The default collision mask for the layer with the specified name</returns>
    public int GetDefaultMask(string layerName) {
      return GetDefaultMask(LayerMask.NameToLayer(layerName));
    }

    /// <summary>
    ///   Looks up the default collision mask for the layer with the specified index
    /// </summary>
    /// <param name="layerIndex">
    ///   Index of the layer whose collision mask will be looked up
    /// </param>
    /// <returns>The default collision mask for the layer with the specified index</returns>
    public int GetDefaultMask(int layerIndex) {
      enforceValidLayerIndex(layerIndex);

      if(!this.defaultMaskBuilt[layerIndex]) {
        int mask = 0;

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

        this.defaultMask[layerIndex] = mask;
        this.defaultMaskBuilt[layerIndex] = true;
      }

      return this.defaultMask[layerIndex];
    }

    /// <summary>
    ///   Invalidates the cache for the default layer mask with the specified name
    /// </summary>
    /// <param name="layerName">
    ///   Name of the default layer mask that will be invalidated
    /// </param>
    public void InvalidateDefaultMask(string layerName) {
      InvalidateDefaultMask(LayerMask.NameToLayer(layerName));
    }

    /// <summary>
    ///   Invalidates the cache for the default layer mask with the specified index
    /// </summary>
    /// <param name="layerIndex">
    ///   Index of the default layer mask that will be invalidated
    /// </param>
    public void InvalidateDefaultMask(int layerIndex) {
      enforceValidLayerIndex(layerIndex);

      this.defaultMaskBuilt[layerIndex] = false;
    }

    /// <summary>Retrieves one of the configured layer masks by its name</summary>
    /// <param name="layerMaskName">Name of the layer mask that will be retrieved</param>
    /// <returns>The layer mask with the specified name</returns>
    public int GetMask(string layerMaskName) {
      return this.namedMasks[layerMaskName];
    }

    /// <summary>Changes one of the configured layer masks</summary>
    /// <param name="layerMaskName">Name of the layer mask that will be changed</param>
    /// <param name="mask">New layer mask to store under that given name</param>
    public void SetMask(string layerMaskName, int mask) {
      this.namedMasks[layerMaskName] = 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 enforceValidLayerIndex(int layerIndex) {
      if((layerIndex < 0) || (layerIndex >= 32)) {
        throw new ArgumentException("Layer index must be in the 0-31 range", "layerIndex");
      }
    }

    /// <summary>Named collision masks that have been defined project-wide</summary>
    private IDictionary<string, int> namedMasks;
    /// <summary>Keeps track of which layer masks have already been queried</summary>
    private bool[/*32*/] defaultMaskBuilt;
    /// <summary>Stores the collision masks for each of the 32 possible layers</summary>
    private int[/*32*/] defaultMask;

  }

} // namespace Framework.Layers