using BotSharp.Algorithm.HiddenMarkovModel.MathUtils.Distribution;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BotSharp.Algorithm.HiddenMarkovModel.MathUtils.Statistics
{
    /// <summary>
    /// Confidence interval for a population mean: Computed as the sample mean +/- a margin of eror (critical value corresponding to the middle XX% of
    /// the normal distribution times the standard error of the sampling distribution).The XX% is the confidence level.
    /// 
    /// Suppose we took many samples and built a confidence interval from each sample using the equation:
    ///   sampleMean +/- 1.96 * SE, 
    /// where SE is the StandardError(sampleStdDev, sampleSize)
    /// Then about 95% of those intervals would contain the true population mean, mu
    /// 
    /// The confidence interval is always about the unknown population mean, and the confidence level tells us how confident we are that the unknown population mean lies in the confidence interval
    /// 
    /// Commonly used confidence levels in practice re 90%, 95%, 98% and 99%.
    /// 
    /// When confidence interval increases, accurarcy increases, but precision decreases.
    /// 
    /// When the sample size increases, the standard error decreases, which decreases the confidence interval at the same confidence level => increases both the accuracy and precision.
    /// 
    /// For continuous variable:
    /// If the sample size is smaller than 30, then the CLT does not hold for the sample mean, and the student's t distribution must be used in place of normal distribution for the sample mean, in this case:
    ///   sampleMean +/- t_{n-1} * SE, 
    /// where n is the sample size, t_{n-1} is the critical values in student's distribution having degrees of freedom (n-1), and SE is the StandardError(sampleStdDev, sampleSize).
    /// </summary>
    public class ConfidenceInterval
    {
        /// <summary>
        /// Return the confidence interval of the population mean (measured on a continuous random variable) given a random sample
        /// 
        /// Note that this is for a variable whose values are continuous
        /// </summary>
        /// <param name="sampleMean">point estimate sample mean given by the random sample</param>
        /// <param name="sampleStdDev">point estimate sample standard deviation given by the random sample</param>
        /// <param name="sampleSize">size of the random sample</param>
        /// <param name="confidence_level"></param>
        /// <returns></returns>
        public static double[] GetConfidenceInterval(double sampleMean, double sampleStdDev, int sampleSize, double confidence_level, bool useStudentT = false)
        {
            double standard_error = StandardError.GetStandardError(sampleStdDev, sampleSize);
            double[] confidence_interval = new double[2];

            double p1 = (1 - confidence_level) / 2.0;
            double p2 = 1 - p1;

            double critical_value1 = 0;
            double critical_value2 = 0;

            if (sampleSize < 30 || useStudentT) //if sample size is smaller than 30, then CLT for population statistics such as sample mean no longer holds and Student's t distribution should be used in place of the normal distribution
            {
                int df = sampleSize - 1;
                critical_value1 = StudentT.GetQuantile(p1, df);
                critical_value2 = StudentT.GetQuantile(p2, df);
            }
            else
            {
                critical_value1 = Gaussian.GetQuantile(p1);
                critical_value2 = Gaussian.GetQuantile(p2);
            }

            confidence_interval[0] = sampleMean + critical_value1 * standard_error;
            confidence_interval[1] = sampleMean + critical_value2 * standard_error;

            return confidence_interval;
        }

        /// <summary>
        /// Get the confidence interval of a continuous variable for a random sample 
        /// </summary>
        /// <param name="sample"></param>
        /// <param name="confidence_level"></param>
        /// <returns></returns>
        public static double[] GetConfidenceInterval(double[] sample, double confidence_level, bool useStudentT = false)
        {
            double sampleMean = Mean.GetMean(sample);
            double sampleStdDev = StdDev.GetStdDev(sample, sampleMean);

            return GetConfidenceInterval(sampleMean, sampleStdDev, sample.Length, confidence_level, useStudentT);
        }

        /// <summary>
        /// Get the confidence interval for the proportion of SUCCESS in the population at the given confidence level
        /// 
        /// Note that this is for a variable whose values are categorical containing only one of two values {SUCCESS, FAILURE}
        /// </summary>
        /// <param name="sample">random sample each entry is either SUCCESS (i.e. true) or FAILURE (i.e. false)</param>
        /// <param name="confidence_level"></param>
        /// <returns>The confidence interval for the proportion of SUCCESS in the population at the given confidence level</returns>
        public static double[] GetConfidenceInterval(bool[] sample, double confidence_level, bool useStudentT = false)
        {
            double point_estimate_proportion = 0;
            for (int i = 0; i < sample.Length; ++i)
            {
                point_estimate_proportion += (sample[i] ? 1 : 0);
            }
            point_estimate_proportion /= sample.Length;

            return GetConfidenceInterval(point_estimate_proportion, sample.Length, confidence_level, useStudentT);
        }

        /// <summary>
        /// Get the confidence interval for the difference between two classes
        /// 
        /// Note that this is for variables with continuous values
        /// </summary>
        /// <param name="sample_for_var1">random sample drawn for class 1</param>
        /// <param name="sample_for_var2">random sample drawn for class 2</param>
        /// <param name="confidence_level">confidencen level</param>
        /// <returns>The confidence interval for the difference between two classes in the population given the confidence level</returns>
        public static double[] GetConfidenceIntervalForDiff(double[] sample_for_var1, double[] sample_for_var2, double confidence_level, bool useStudentT = false, double correlation = 0)
        {
            double point_estimate, SE;
            LinearCombination.Diff(sample_for_var1, sample_for_var2, correlation, out point_estimate, out SE);

            double p1 = (1 - confidence_level) / 2;
            double p2 = 1 - p1;

            double critical_value1 = 0;
            double critical_value2 = 0;

            if (sample_for_var1.Length < 30 || sample_for_var2.Length < 30 || useStudentT) //if sample size is smaller than 30, then CLT for population statistics such as sample mean no longer holds and Student's t distribution should be used in place of the normal distribution
            {
                int df = System.Math.Min(sample_for_var1.Length - 1, sample_for_var2.Length - 1);
                critical_value1 = StudentT.GetQuantile(p1, df);
                critical_value2 = StudentT.GetQuantile(p2, df);
            }
            else
            {
                critical_value1 = Gaussian.GetQuantile(p1);
                critical_value2 = Gaussian.GetQuantile(p2);
            }

            return new double[] { point_estimate + critical_value1 * SE, point_estimate + critical_value2 * SE };
        }

        /// <summary>
        /// Return the confidence interval of the difference between two classes in terms of the proportion of SUCCESS in the population at a given confidence level
        /// 
        /// Note that each class should be a categorical variable with two levels : {SUCCESS, FAILURE}
        /// Note that class 1 and class 2 are not paired or dependent
        /// </summary>
        /// <param name="p_hat1">point estimate of the proportion of SUCCESS in class 1</param>
        /// <param name="p_hat2">point estimate of the proportion of SUCCESS in class 2</param>
        /// <param name="n1">sample size in class 1</param>
        /// <param name="n2">sample size in class 2</param>
        /// <param name="confidence_level">The given confidence level</param>
        /// <param name="useSimulation">Flag for whether simulation should be used instead of the normal distribution for proportion of SUCCESS</param>
        /// <returns>The confidence interval of the difference between two classes in terms of the proportion of SUCCESS</returns>
        public static double[] GetConfidenceInterval(double p_hat1, double p_hat2, int n1, int n2, double confidence_level, bool useSimulation = false, int simulationCount = 500)
        {
            bool shouldUseSimulation = useSimulation;

            double p1 = (1 - confidence_level) / 2;
            double p2 = 1 - p1;

            if (!shouldUseSimulation && (p_hat1 * n1 < 10 || (1 - p_hat1) * n1 < 10 || p_hat2 * n2 < 10 || (1 - p_hat2) * n2 < 10))
            {
                shouldUseSimulation = true;
            }

            if (shouldUseSimulation)
            {
                double[] sim_sample1 = new double[simulationCount]; // this will follow a normal distribution based on CTL for proportion
                double[] sim_sample2 = new double[simulationCount]; // this will follow a normal distribution based on CLT for proportion

                int simulationSampleSize = System.Math.Max((int)System.Math.Max(10 / p_hat1, 10 / (1 - p_hat1)) * 2, (int)System.Math.Max(10 / p_hat2, 10 / (1 - p_hat2)) * 2);

                for (int i = 0; i < simulationCount; ++i)
                {
                    int successCount1 = 0;
                    int successCount2 = 0;
                    for (int j = 0; j < simulationSampleSize; ++j)
                    {
                        if (DistributionModel.GetUniform() <= p_hat1)
                        {
                            successCount1++;
                        }
                        if (DistributionModel.GetUniform() <= p_hat2)
                        {
                            successCount2++;
                        }
                    }
                    sim_sample1[i] = (double)(successCount1) / simulationSampleSize;
                    sim_sample2[i] = (double)(successCount2) / simulationSampleSize;
                }

                double sim_mu1 = Mean.GetMean(sim_sample1);
                double sim_sigma1 = StdDev.GetStdDev(sim_sample1, sim_mu1);

                double sim_mu2 = Mean.GetMean(sim_sample2);
                double sim_sigma2 = StdDev.GetStdDev(sim_sample2, sim_mu2);

                double sim_mud = sim_mu1 - sim_mu2;
                double sim_SE = System.Math.Sqrt(sim_sigma1 * sim_sigma1 + sim_sigma2 * sim_sigma2);

                return new double[] { sim_mud + Gaussian.GetPercentile(p1) * sim_SE, sim_mud + Gaussian.GetQuantile(p2) * sim_SE };
            }
            else
            {
                double SE = System.Math.Sqrt((p_hat1 * (1 - p_hat1) / n1 + (p_hat2 * (1 - p_hat2)) / n2));

                double pd_hat = p_hat1 - p_hat2;


                return new double[] { pd_hat + Gaussian.GetQuantile(p1) * SE, pd_hat + Gaussian.GetQuantile(p2) * SE };
            }
        }

        /// <summary>
        /// Return the confidence interval of the population mean at a given confidence level, given the point estimate sample mean are known from multiple groups / classes
        /// 
        /// Note that each class should be a continuous variable.
        /// </summary>
        /// <param name="sampleMeans">point estimate sample means from different groups/classes</param>
        /// <param name="sampleStdDev">point estimate sample standard deviations from different groups / classes</param>
        /// <param name="sampleSizes">sample size from different classes</param>
        /// <param name="confidence_level">The given confidence level</param>
        /// <param name="useStudentT">whether student t should be used for test statistic</param>
        /// <returns>The confidence level of the population mean at the given confidence level</returns>
        public static double[] GetConfidenceInterval(double[] sampleMeans, double[] sampleStdDev, int[] sampleSizes, double confidence_level, bool useStudentT = false)
        {
            double[] standardErrors = new double[sampleMeans.Length];
            for (int i = 0; i < sampleMeans.Length; ++i)
            {
                standardErrors[i] = StandardError.GetStandardError(sampleStdDev[i], sampleSizes[i]);
            }

            double standardError = StandardError.GetStandardErrorForWeightAverages(sampleSizes, standardErrors);
            double sampleMean = Mean.GetMeanForWeightedAverage(sampleMeans, sampleSizes);

            double p1 = (1 - confidence_level) / 2.0;
            double p2 = 1 - p1;

            bool shouldUseStudentT = useStudentT;
            if (!shouldUseStudentT)
            {
                for (int i = 0; i < sampleSizes.Length; ++i)
                {
                    if (sampleSizes[i] < 30)
                    {
                        shouldUseStudentT = true;
                        break;
                    }
                }
            }

            double critical_value1 = 0;
            double critical_value2 = 0;

            if (shouldUseStudentT)
            {
                int smallestSampleSize = int.MaxValue;
                for (int i = 0; i < sampleSizes.Length; ++i)
                {
                    if (sampleSizes[i] < smallestSampleSize)
                    {
                        smallestSampleSize = sampleSizes[i];
                    }
                }
                int df = smallestSampleSize - 1;
                critical_value1 = StudentT.GetQuantile(p1, df);
                critical_value2 = StudentT.GetQuantile(p2, df);
            }
            else
            {
                critical_value1 = Gaussian.GetQuantile(p1);
                critical_value2 = Gaussian.GetQuantile(p2);
            }

            double[] confidence_interval = new double[2];
            confidence_interval[0] = sampleMean + critical_value1 * standardError;
            confidence_interval[1] = sampleMean + critical_value2 * standardError;

            return confidence_interval;
        }

        /// <summary>
        /// Return the confidence interval for proportion of SUCCESS in the population at a given confidence level given the sample proportion point estimate
        /// </summary>
        /// <param name="proportion">sample proportion point estimate</param>
        /// <param name="sampleSize">sample size</param>
        /// <param name="confidence_level"></param>
        /// <returns>confidence interval for proportion of SUCCESS in the population at a given confidence level</returns>
        public static double[] GetConfidenceInterval(double proportion, int sampleSize, double confidence_level, bool useSimulation = false, int simulationCount = 500)
        {
            double standard_error = StandardError.GetStandardErrorForProportion(proportion, sampleSize);

            double p1 = (1 - confidence_level) / 2;
            double p2 = 1 - p1;

            int expected_success_count = (int)(proportion * sampleSize);
            int expected_failure_count = (int)((1 - proportion) * sampleSize);
            if (expected_failure_count < 10 || expected_success_count < 10 || useSimulation) //if np < 10 or n(1-p) < 10, then CLT for proportion no longer holds and simulation should be used in place of the normal distribution
            {
                double[] sampleProportions = new double[simulationCount];
                int simulationSampleSize = (int)System.Math.Max(10 / proportion, 10 / (1 - proportion)) * 2;
                for (int i = 0; i < simulationCount; ++i)
                {
                    int successCount = 0;
                    for (int j = 0; j < simulationSampleSize; ++j)
                    {
                        if (DistributionModel.GetUniform() <= proportion)
                        {
                            successCount++;
                        }
                    }
                    sampleProportions[i] = (double)successCount / simulationSampleSize;
                }

                double proportion_mu = Mean.GetMean(sampleProportions);
                double proportion_sigma = StdDev.GetStdDev(sampleProportions, proportion_mu);

                return new double[] { proportion_mu + Gaussian.GetPercentile(p1) * proportion_sigma, proportion_mu + Gaussian.GetQuantile(p2) * proportion_sigma };
            }
            else
            {
                double critical_value1 = Gaussian.GetQuantile(p1);
                double critical_value2 = Gaussian.GetQuantile(p2);

                double[] confidence_interval = new double[2];
                confidence_interval[0] = proportion + critical_value1 * standard_error;
                confidence_interval[1] = proportion + critical_value2 * standard_error;

                return confidence_interval;
            }


        }

        /// <summary>
        /// Calculate the confidence interval for the proportion of SUCCESS in the population at a given confidence interval, given the point estimate proprotions are known from multiple groups 
        /// 
        /// Note that this is only for categorical variable with two levels : SUCCESS, FAILURE
        /// </summary>
        /// <param name="proportions">The point estimate proportion of SUCESS obtained from multiple groups</param>
        /// <param name="sampleSizes">The sample size of each group</param>
        /// <param name="confidence_level">The given confidence interval</param>
        /// <returns>The confidence interval for the proportion of SUCCESS in the population at the given confidence level</returns>
        public static double[] GetConfidenceInterval(double[] proportions, int[] sampleSizes, double confidence_level, bool useSimulation = false, int simulationCount = 500)
        {
            double p1 = (1 - confidence_level) / 2;
            double p2 = 1 - p1;

            bool shouldUseSimulation = useSimulation;

            if (!shouldUseSimulation)
            {
                for (int i = 0; i < sampleSizes.Length; ++i)
                {
                    int n_i = sampleSizes[i];
                    int expected_success_count = (int)(proportions[i] * n_i);
                    int expected_failure_count = (int)((1 - proportions[i]) * n_i);
                    if (expected_failure_count < 10 || expected_success_count < 10)
                    {
                        shouldUseSimulation = true;
                        break;
                    }
                }
            }

            if (shouldUseSimulation)
            {
                double sucess_count = 0;
                double total_count = 0;
                for (int i = 0; i < sampleSizes.Length; ++i)
                {
                    int n_i = sampleSizes[i];
                    sucess_count += proportions[i] * n_i;
                    total_count += n_i;
                }

                double p_hat = sucess_count / total_count;

                double[] sampleProportions = new double[simulationCount];
                int simulationSampleSize = (int)System.Math.Max(10 / p_hat, 10 / (1 - p_hat)) * 2;
                for (int i = 0; i < simulationCount; ++i)
                {
                    int successCount = 0;
                    for (int j = 0; j < simulationSampleSize; ++j)
                    {
                        if (DistributionModel.GetUniform() <= p_hat)
                        {
                            successCount++;
                        }
                    }
                    sampleProportions[i] = (double)successCount / simulationSampleSize;
                }

                double proportion_mu = Mean.GetMean(sampleProportions);
                double proportion_sigma = StdDev.GetStdDev(sampleProportions, proportion_mu);

                return new double[] { proportion_mu + Gaussian.GetPercentile(p1) * proportion_sigma, proportion_mu + Gaussian.GetQuantile(p2) * proportion_sigma };
            }
            else
            {
                double[] standardErrors = new double[proportions.Length];
                for (int i = 0; i < proportions.Length; ++i)
                {
                    standardErrors[i] = StandardError.GetStandardErrorForProportion(proportions[i], sampleSizes[i]);
                }

                double standardError = StandardError.GetStandardErrorForWeightAverages(sampleSizes, standardErrors);

                double sampleMean = Mean.GetMeanForWeightedAverage(proportions, sampleSizes);


                double critical_value1 = 0;
                double critical_value2 = 0;

                critical_value1 = Gaussian.GetQuantile(p1);
                critical_value2 = Gaussian.GetQuantile(p2);

                double[] confidence_interval = new double[2];
                confidence_interval[0] = sampleMean + critical_value1 * standardError;
                confidence_interval[1] = sampleMean + critical_value2 * standardError;

                return confidence_interval;
            }
        }

    }
}