#ifndef __JMATH__JRANDOM__
#define __JMATH__JRANDOM__

#include <limits>

#include "TRandom3.h"

#include "JMath/JLimits.hh"

/**
 * \file
 *
 * Definition of random value generator.
 * \author mdejong
 */
namespace JMATH {}
namespace JPP { using namespace JMATH; }

namespace JMATH {


  /**
   * Template definition of random value generator.
   */
  template<class T, bool is_specialized = JLimits<T>::is_specialized>
  struct JRandom;


  /**
   * Template spacialisation of JMATH::JRandom for numerical values.
   */
  template<class T>
  struct JRandom<T, true> {
    /**
     * Get uniformly distributed random value between numerical limits.
     *
     * \return                    random value
     */  
    static inline T getRandom()
    {
      return gRandom->Uniform((Double_t) JLimits<T>::min(), (Double_t) JLimits<T>::max());
    }


    /**
     * Get uniformly distributed random value between given limits.
     *
     * \param  min                minimal value
     * \param  max                maximal value
     * \return                    random value
     */ 
    static inline T getRandom(const T min,
			      const T max)
    {
      return (T) gRandom->Uniform((Double_t) min, (Double_t) max);
    }
  };


  /**
   * Template specialisation for data type <tt>double</tt> because TRandom has 32 bits.
   */
  template<>
  inline double JRandom<double>::getRandom()
  {
    return gRandom->Uniform((Double_t) JLimits<float>::min(), (Double_t) JLimits<float>::max());
  }
  

  /**
   * Template spacialisation of JMATH::JRandom for non-numerical data types.
   *
   * The template argument <tt>T</tt> should have the default constructor and
   * the following method should be implemented for this data type.
   * <pre>
   *   void %randomize(T* object);
   * </pre>
   */
  template<class T>
  struct JRandom<T, false> {
    /**
     * Get random value.
     *
     * \return                    random value
     */  
    static inline const T& getRandom()
    {
      new (&value) T();

      randomize(&value);

      return value;
    }

  private:
    static T value;
  };


  /**
   * Definition of value.
   */
  template<class T>
  T JRandom<T, false>::value;


  /**
   * Get random value.
   *
   * \return                    random value
   */  
  template<class T>
  inline T getRandom()
  {
    return JRandom<T>::getRandom();
  }


  /**
   * Get uniformly distributed random value between given limits.
   *
   * \param  min                minimal value
   * \param  max                maximal value
   * \return                    random value
   */
  template<class T>
  inline T getRandom(const T min,
		     const T max)
  {
    return JRandom<T, true>::getRandom(min, max);
  }


  /**
   * Get uniformly distributed random value between given limits.
   *
   * \param  min                minimal value
   * \param  max                maximal value
   * \param  precision          precision
   * \return                    random value
   */
  template<class T>
  inline T getRandom(const T min,
		     const T max,
		     const T precision)
  {
    return JRandom<T, true>::getRandom(min, max);
  }


  /**
   * Template specialisation for data type <tt>double</tt>.
   */
  template<>
  inline double getRandom(const double min,
			  const double max,
			  const double precision)
  {
    double value = getRandom<double>(min, max);

    if (precision != 0.0) {

      const long long int ip = (long long int) (1.0 / precision);

      value = ((double) ((long long int) (value * ip))) / ip;
    }

    return value;
  }
}

#endif