/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.commons.math4.legacy.distribution;
  
  import java.util.ArrayList;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  
  import org.apache.commons.statistics.distribution.ContinuousDistribution;
  import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
  import org.apache.commons.math4.legacy.exception.MathArithmeticException;
  import org.apache.commons.math4.legacy.exception.NotANumberException;
  import org.apache.commons.math4.legacy.exception.NotFiniteNumberException;
  import org.apache.commons.math4.legacy.exception.NotPositiveException;
  import org.apache.commons.math4.legacy.exception.OutOfRangeException;
  import org.apache.commons.rng.UniformRandomProvider;
  import org.apache.commons.math4.legacy.core.Pair;
  
  /**
   * <p>Implementation of a real-valued {@link EnumeratedDistribution}.
   *
   * <p>Values with zero-probability are allowed but they do not extend the
   * support.<br>
   * Duplicate values are allowed. Probabilities of duplicate values are combined
   * when computing cumulative probabilities and statistics.</p>
   *
   * @since 3.2
   */
  public class EnumeratedRealDistribution
      implements ContinuousDistribution {
      /**
       * {@link EnumeratedDistribution} (using the {@link Double} wrapper)
       * used to generate the pmf.
       */
      protected final EnumeratedDistribution<Double> innerDistribution;
  
      /**
       * Create a discrete real-valued distribution using the given random number generator
       * and probability mass function enumeration.
       *
       * @param singletons array of random variable values.
       * @param probabilities array of probabilities.
       * @throws DimensionMismatchException if
       * {@code singletons.length != probabilities.length}
       * @throws NotPositiveException if any of the probabilities are negative.
       * @throws NotFiniteNumberException if any of the probabilities are infinite.
       * @throws NotANumberException if any of the probabilities are NaN.
       * @throws MathArithmeticException all of the probabilities are 0.
       */
      public EnumeratedRealDistribution(final double[] singletons,
                                        final double[] probabilities)
          throws DimensionMismatchException,
                 NotPositiveException,
                 MathArithmeticException,
                 NotFiniteNumberException,
                 NotANumberException {
          innerDistribution = new EnumeratedDistribution<>(createDistribution(singletons, probabilities));
      }
  
      /**
       * Creates a discrete real-valued distribution from the input data.
       * Values are assigned mass based on their frequency.
       *
       * @param data input dataset
       */
      public EnumeratedRealDistribution(final double[] data) {
          final Map<Double, Integer> dataMap = new LinkedHashMap<>();
          for (double value : data) {
              dataMap.merge(value, 1, Integer::sum);
          }
          final int massPoints = dataMap.size();
          final double denom = data.length;
          final double[] values = new double[massPoints];
          final double[] probabilities = new double[massPoints];
          int index = 0;
          for (Entry<Double, Integer> entry : dataMap.entrySet()) {
              values[index] = entry.getKey();
              probabilities[index] = entry.getValue().intValue() / denom;
              index++;
          }
          innerDistribution = new EnumeratedDistribution<>(createDistribution(values, probabilities));
      }
  
     /**
      * Create the list of Pairs representing the distribution from singletons and probabilities.
      *
      * @param singletons values
      * @param probabilities probabilities
      * @return list of value/probability pairs
      */
     private static List<Pair<Double, Double>>  createDistribution(double[] singletons, double[] probabilities) {
         if (singletons.length != probabilities.length) {
             throw new DimensionMismatchException(probabilities.length, singletons.length);
         }
 
         final List<Pair<Double, Double>> samples = new ArrayList<>(singletons.length);
 
         for (int i = 0; i < singletons.length; i++) {
             samples.add(new Pair<>(singletons[i], probabilities[i]));
         }
         return samples;
     }
 
     /**
      * For a random variable {@code X} whose values are distributed according to
      * this distribution, this method returns {@code P(X = x)}. In other words,
      * this method represents the probability mass function (PMF) for the
      * distribution.
      *
      * @param x the point at which the PMF is evaluated
      * @return the value of the probability mass function at point {@code x}
      */
     @Override
     public double density(final double x) {
         return innerDistribution.probability(x);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public double cumulativeProbability(final double x) {
         double probability = 0;
 
         for (final Pair<Double, Double> sample : innerDistribution.getPmf()) {
             if (sample.getKey() <= x) {
                 probability += sample.getValue();
             }
         }
 
         return probability;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public double inverseCumulativeProbability(final double p) throws OutOfRangeException {
         if (p < 0.0 || p > 1.0) {
             throw new OutOfRangeException(p, 0, 1);
         }
 
         double probability = 0;
         double x = getSupportLowerBound();
         for (final Pair<Double, Double> sample : innerDistribution.getPmf()) {
             if (sample.getValue() == 0.0) {
                 continue;
             }
 
             probability += sample.getValue();
             x = sample.getKey();
 
             if (probability >= p) {
                 break;
             }
         }
 
         return x;
     }
 
     /**
      * {@inheritDoc}
      *
      * @return {@code sum(singletons[i] * probabilities[i])}
      */
     @Override
     public double getMean() {
         double mean = 0;
 
         for (final Pair<Double, Double> sample : innerDistribution.getPmf()) {
             mean += sample.getValue() * sample.getKey();
         }
 
         return mean;
     }
 
     /**
      * {@inheritDoc}
      *
      * @return {@code sum((singletons[i] - mean) ^ 2 * probabilities[i])}
      */
     @Override
     public double getVariance() {
         double mean = 0;
         double meanOfSquares = 0;
 
         for (final Pair<Double, Double> sample : innerDistribution.getPmf()) {
             mean += sample.getValue() * sample.getKey();
             meanOfSquares += sample.getValue() * sample.getKey() * sample.getKey();
         }
 
         return meanOfSquares - mean * mean;
     }
 
     /**
      * {@inheritDoc}
      *
      * Returns the lowest value with non-zero probability.
      *
      * @return the lowest value with non-zero probability.
      */
     @Override
     public double getSupportLowerBound() {
         double min = Double.POSITIVE_INFINITY;
         for (final Pair<Double, Double> sample : innerDistribution.getPmf()) {
             if (sample.getKey() < min && sample.getValue() > 0) {
                 min = sample.getKey();
             }
         }
 
         return min;
     }
 
     /**
      * {@inheritDoc}
      *
      * Returns the highest value with non-zero probability.
      *
      * @return the highest value with non-zero probability.
      */
     @Override
     public double getSupportUpperBound() {
         double max = Double.NEGATIVE_INFINITY;
         for (final Pair<Double, Double> sample : innerDistribution.getPmf()) {
             if (sample.getKey() > max && sample.getValue() > 0) {
                 max = sample.getKey();
             }
         }
 
         return max;
     }
 
     /** {@inheritDoc} */
     @Override
     public ContinuousDistribution.Sampler createSampler(final UniformRandomProvider rng) {
         return innerDistribution.createSampler(rng)::sample;
     }
 }