using System;
using System.Collections.Generic;

using UnityEngine;

using Random = UnityEngine.Random;

namespace Framework.Support {

  /// <summary>Contains helper methods for randomness</summary>
  public static class RandomHelper {

    /// <summary>Picks one element from the array by random</summary>
    /// <typeparam name="T">Type of elements to select between</typeparam>
    /// <param name="choices">Elements amongst which a random one should be picked</param>
    /// <returns>A random element from the provided choices</returns>
    public static T SelectRandom<T>(T[] choices) {
      if((choices == null) || (choices.Length == 0)) {
        return default(T);
      }

      return choices[Random.Range(0, choices.Length)];
    }

    /// <summary>Picks one element from the list by random</summary>
    /// <typeparam name="T">Type of elements in the list to select between</typeparam>
    /// <param name="choices">Elements amongst which a random one should be picked</param>
    /// <returns>A random element from the provided choices</returns>
    public static T SelectRandom<T>(IList<T> choices) {
      if((choices == null) || (choices.Count == 0)) {
        return default(T);
      }

      return choices[Random.Range(0, choices.Count)];
    }

    private const float Perigon = Mathf.PI * 2.0f;

    /// <summary>Random generate whose output roughly follows a sine function</summary>
    /// <param name="time">Time for which to generate a random value</param>
    /// <param name="frequency">How fast the output will shake</param>
    /// <returns>The random value following a sine function</returns>
    public static float RandomSine(float time, float frequency) {
      float sine = unwind(time, 0.0f, 1.0f);
      sine *= Perigon * frequency; // The sine method can cope with *some* loops
      sine += Random.Range(-0.5f, 0.5f);
      return Mathf.Sin(sine);
    }

    /// <summary>Unwinds a value in a circular (repeating) value range</summary>
    /// <param name="value">Value that will be unwound</param>
    /// <param name="min">Lower limit of the circular value range</param>
    /// <param name="max">Upper limit of the circular value range</param>
    /// <returns>The unwound value</returns>
    private static float unwind(float value, float min, float max) {
      float range = (max - min);
      float floor = Mathf.Floor((value - min) / range);
      return value - (floor * range);
    }

  }

} // namespace Framework.Support