/**
 * Collection of functions equivalent to those provided by Microsoft Excel
 * but backed instead by Math.NET Numerics.
 * We do not recommend to use them except in an intermediate phase when
 * porting over solutions previously implemented in Excel.
 */
import { Normal } from './Distributions/Normal.js';
import { StudentT } from './Distributions/StudentT.js';
import { FisherSnedecor } from './Distributions/FisherSnedecor.js';
import { Beta } from './Distributions/Beta.js';
import { Gamma } from './Distributions/Gamma.js';
import { Exponential } from './Distributions/Exponential.js';
import { Hypergeometric } from './Distributions/Hypergeometric.js';
import { NegativeBinomial } from './Distributions/NegativeBinomial.js';
import { LogNormal } from './Distributions/LogNormal.js';
import { binomial } from './Distributions/binomial.js';
import { Poisson } from './Distributions/Poisson.js';
import { Weibull } from './Distributions/Weibull.js';
import { ArrayStatistics } from './Statistics/ArrayStatistics.js';
import { Statistics } from './Statistics/Statistics.js';
import { QuantileDefinition } from './Statistics/QuantileDefinition.js';
import { SpecialFunctions } from './SpecialFunctions/SpecialFunctions.js';

let ExcelFunctions = {
    /**
     * NormSDist
     * @param {number} z
     * @returns {number}
     */
    NormSDist: function(z) {
        return Normal.cdf(0, 1, z);
    },

    /**
     * NormSInv
     * @param {number} probability
     * @returns {number}
     */
    NormSInv: function(probability) {
        return Normal.invCDF(0, 1, probability);
    },

    /**
     * NormDist
     * @param {number} x
     * @param {number} mean
     * @param {number} standardDev
     * @param {boolean} cumulative
     * @returns {number}
     */
    NormDist: function(x, mean, standardDev, cumulative) {
        return cumulative ? Normal.cdf(mean, standardDev, x) : Normal.pdf(mean, standardDev, x);
    },

    /**
     * NormInv
     * @param {number} probability
     * @param {number} mean
     * @param {number} standardDev
     * @returns {number}
     */
    NormInv: function(probability, mean, standardDev) {
        return Normal.invCDF(mean, standardDev, probability);
    },

    /**
     * TDist
     * @param {number} x
     * @param {number} degreesFreedom
     * @param {number} tails
     * @returns {number}
     * @throws {Error}
     */
    TDist: function(x, degreesFreedom, tails) {
        switch (tails) {
            case 1:
                return 1 - StudentT.cdf(0, 1, degreesFreedom, x);

            case 2:
                return 1 - StudentT.cdf(0, 1, degreesFreedom, x) + StudentT.cdf(0, 1, degreesFreedom, -x);

            default:
                throw new Error('tails must be 1 or 2');
        }
    },

    /**
     * TInv
     * @param {number} probability
     * @param {number} degreesFreedom
     * @returns {number}
     */
    TInv: function(probability, degreesFreedom) {
        return -StudentT.invCDF(0, 1, degreesFreedom, probability / 2);
    },

    /**
     * FDist
     * @param {number} x
     * @param {number} degreesFreedom1
     * @param {number} degreesFreedom2
     * @returns {number}
     */
    FDist: function(x, degreesFreedom1, degreesFreedom2) {
        return 1 - FisherSnedecor.cdf(degreesFreedom1, degreesFreedom2, x);
    },

    /**
     * FInv
     * @param {number} probability
     * @param {number} degreesFreedom1
     * @param {number} degreesFreedom2
     * @returns {number}
     */
    FInv: function(probability, degreesFreedom1, degreesFreedom2) {
        return FisherSnedecor.invCDF(degreesFreedom1, degreesFreedom2, 1 - probability);
    },

    /**
     * BetaDist
     * @param {number} x
     * @param {number} alpha
     * @param {number} beta
     * @returns {number}
     */
    BetaDist: function(x, alpha, beta) {
        return Beta.cdf(alpha, beta, x);
    },

    /**
     * BetaInv
     * @param {number} probability
     * @param {number} alpha
     * @param {number} beta
     * @returns {number}
     */
    BetaInv: function(probability, alpha, beta) {
        return Beta.invCDF(alpha, beta, probability);
    },

    /**
     * GammaDist
     * @param {number} x
     * @param {number} alpha
     * @param {number} beta
     * @param {boolean} cumulative
     * @returns {number}
     */
    GammaDist: function(x, alpha, beta, cumulative) {
        return cumulative ? Gamma.cdf(alpha, 1 / beta, x) : Gamma.pdf(alpha, 1 / beta, x);
    },

    /**
     * GammaInv
     * @param {number} probability
     * @param {number} alpha
     * @param {number} beta
     * @returns {number}
     */
    GammaInv: function(probability, alpha, beta) {
        return Gamma.invCDF(alpha, 1 / beta, probability);
    },

    /**
     * Quartile
     * @param {Array<number>} array
     * @param {number} quant
     * @returns {number}
     * @throws {Error}
     */
    Quartile: function(array, quant) {
        switch (quant) {
            case 0:
                return ArrayStatistics.minimum(array);

            case 1:
                return Statistics.quantileCustom(array, 0.25, QuantileDefinition.R7);

            case 2:
                return Statistics.quantileCustom(array, 0.5, QuantileDefinition.R7);

            case 3:
                return Statistics.quantileCustom(array, 0.75, QuantileDefinition.R7);

            case 4:
                return ArrayStatistics.maximum(array);

            default:
                throw new Error('quant must be between 0 and 4');
        }
    },

    /**
     * Percentile
     * @param {Array<number>} array
     * @param {number} k
     * @returns {number}
     */
    Percentile: function(array, k) {
        return Statistics.quantileCustom(array, k, QuantileDefinition.R7);
    },

    /**
     * PercentRank
     * @param {Array<number>} array
     * @param {number} x
     * @returns {number}
     */
    PercentRank: function(array, x) {
        return Statistics.quantileRank(array, x);
    },

    /**
     * GAMMALN
     * @param {number} z
     * @returns {number}
     */
    GAMMALN: function(z) {
        return SpecialFunctions.gammaLn(z);
    },

    /**
     * ExponDist
     * @param {number} x
     * @param {number} rate
     * @param {boolean} state
     * @returns {number}
     */
    ExponDist: function(x, rate, state) {
        if (state) {
            return Exponential.cdf(rate, x);
        }
        return Exponential.pdf(rate, x);
    },

    /**
     * HypgeomDist
     * @param {number} k
     * @param {number} draws
     * @param {number} success
     * @param {number} population
     * @returns {number}
     */
    HypgeomDist: function(k, draws, success, population) {
        return Hypergeometric.pmf(population, success, draws, k);
    },

    /**
     * NegbinomDist
     * @param {number} k
     * @param {number} r
     * @param {number} p
     * @returns {number}
     */
    NegbinomDist: function(k, r, p) {
        return NegativeBinomial.pmf(r, p, k);
    },

    /**
     * LognormDist
     * @param {number} x
     * @param {number} mu
     * @param {number} sigma
     * @returns {number}
     */
    LognormDist: function(x, mu, sigma) {
        return LogNormal.cdf(mu, sigma, x);
    },

    /**
     * LogInv
     * @param {number} p
     * @param {number} mu
     * @param {number} sigma
     * @returns {number}
     */
    LogInv: function(p, mu, sigma) {
        return LogNormal.invCDF(mu, sigma, p);
    },

    /**
     * BinomDist
     * @param {number} k
     * @param {number} n
     * @param {number} p
     * @param {boolean} state
     * @returns {number}
     */
    BinomDist: function(k, n, p, state) {
        if (state === false) {
            return binomial.pmf(p, n, k);
        }
        return binomial.cdf(p, n, k);
    },

    /**
     * Poisson
     * @param {number} k
     * @param {number} lambda
     * @param {boolean} state
     * @returns {number}
     */
    Poisson: function(k, lambda, state) {
        if (state === false) {
            return Poisson.pmf(lambda, k);
        }
        return Poisson.cdf(lambda, k);
    },

    /**
     * Weibull
     * @param {number} x
     * @param {number} shape
     * @param {number} scale
     * @param {boolean} state
     * @returns {number}
     */
    Weibull: function(x, shape, scale, state) {
        if (state === false) {
            return Weibull.pdf(shape, scale, x);
        }
        return Weibull.cdf(shape, scale, x);
    }
};

export { ExcelFunctions };