using DTS.Common.Interface;
using System;
using System.Buffers;
using System.Linq;
using System.Threading.Tasks;

namespace FftSharp
{
    public static class Transform
    {
        /// <summary>
        /// Compute the discrete Fourier Transform (in-place) using the FFT algorithm.
        /// </summary>
        /// <param name="buffer">Data to transform in-place. Length must be a power of 2.</param>
        public static void FFT(Complex[] buffer)
        {
            if (buffer is null)
                throw new ArgumentNullException(nameof(buffer));

            FFT(buffer.AsSpan());
        }

        /// <summary>
        /// Compute the discrete Fourier Transform (in-place) using the FFT algorithm.
        /// </summary>
        /// <param name="buffer">Data to transform in-place. Length must be a power of 2.</param>
        public static void FFT(Span<Complex> buffer)
        {
            if (buffer.Length == 0)
                throw new ArgumentException("Buffer must not be empty");

            if (!IsPowerOfTwo(buffer.Length))
                throw new ArgumentException("Buffer length must be a power of 2");

            FFT_WithoutChecks(buffer);
        }

        /// <summary>
        /// High performance FFT function.
        /// Complex input will be transformed in place.
        /// Input array length must be a power of two. This length is NOT validated.
        /// Running on an array with an invalid length may throw an invalid index exception.
        /// </summary>
        private static void FFT_WithoutChecks(Span<Complex> buffer)
        {
            for (int i = 1; i < buffer.Length; i++)
            {
                int j = BitReverse(i, buffer.Length);
                if (j > i)
                    (buffer[j], buffer[i]) = (buffer[i], buffer[j]);
            }

            for (int i = 1; i <= buffer.Length / 2; i *= 2)
            {
                double mult1 = -Math.PI / i;
                for (int j = 0; j < buffer.Length; j += (i * 2))
                {
                    for (int k = 0; k < i; k++)
                    {
                        int evenI = j + k;
                        int oddI = j + k + i;
                        Complex temp = new Complex(Math.Cos(mult1 * k), Math.Sin(mult1 * k));
                        temp *= buffer[oddI];
                        buffer[oddI] = buffer[evenI] - temp;
                        buffer[evenI] += temp;
                    }
                }
            }
        }

        /// <summary>
        /// Compute the inverse discrete Fourier Transform (in-place) using the FFT algorithm.
        /// </summary>
        /// <param name="buffer">Data to transform in-place. Length must be a power of 2.</param>
        public static void IFFT(Complex[] buffer)
        {
            if (buffer is null)
                throw new ArgumentNullException(nameof(buffer));

            if (buffer.Length == 0)
                throw new ArgumentException("Buffer must not be empty");

            if (!IsPowerOfTwo(buffer.Length))
                throw new ArgumentException("Buffer length must be a power of 2");

            IFFT_WithoutChecks(buffer);
        }

        private static void IFFT_WithoutChecks(Complex[] buffer)
        {
            // invert the imaginary component
            for (int i = 0; i < buffer.Length; i++)
                buffer[i] = new Complex(buffer[i].Real, -buffer[i].Imaginary);

            // perform a forward Fourier transform
            FFT(buffer);

            // invert the imaginary component again and scale the output
            for (int i = 0; i < buffer.Length; i++)
                buffer[i] = new Complex(
                    real: buffer[i].Real / buffer.Length,
                    imaginary: -buffer[i].Imaginary / buffer.Length);
        }

        /// <summary>
        /// Reverse the sequence of bits in an integer (01101 -> 10110)
        /// </summary>
        private static int BitReverse(int value, int maxValue)
        {
            int maxBitCount = (int)Math.Log(maxValue, 2);
            int output = value;
            int bitCount = maxBitCount - 1;

            value >>= 1;
            while (value > 0)
            {
                output = (output << 1) | (value & 1);
                bitCount -= 1;
                value >>= 1;
            }

            return (output << bitCount) & ((1 << maxBitCount) - 1);
        }

        /// <summary>
        /// Calculate sample frequency for each point in a FFT
        /// </summary>
        public static double[] FFTfreq(double sampleRate, int pointCount, bool oneSided = true)
        {
            double[] freqs = new double[pointCount];

            if (oneSided)
            {
                double fftPeriodHz = sampleRate / pointCount / 2;

                // freqs start at 0 and approach maxFreq
                for (int i = 0; i < pointCount; i++)
                    freqs[i] = i * fftPeriodHz;
                return freqs;
            }
            else
            {
                double fftPeriodHz = sampleRate / pointCount;

                // first half: freqs start a 0 and approach maxFreq
                int halfIndex = pointCount / 2;
                for (int i = 0; i < halfIndex; i++)
                    freqs[i] = i * fftPeriodHz;

                // second half: then start at -maxFreq and approach 0
                for (int i = halfIndex; i < pointCount; i++)
                    freqs[i] = -(pointCount - i) * fftPeriodHz;
                return freqs;
            }
        }

        /// <summary>
        /// Return the distance between each FFT point in frequency units (Hz)
        /// </summary>
        public static double FFTfreqPeriod(int sampleRate, int pointCount)
        {
            return .5 * sampleRate / pointCount;
        }

        /// <summary>
        /// Test if a number is an even power of 2
        /// </summary>
        public static bool IsPowerOfTwo(int x)
        {
            return ((x & (x - 1)) == 0) && (x > 0);
        }

        /// <summary>
        /// Create an array of Complex data given the real component
        /// </summary>
        public static Complex[] MakeComplex(double[] real)
        {
            Complex[] com = new Complex[real.Length];
            MakeComplex(com, real);
            return com;
        }

        /// <summary>
        /// Create an array of Complex data given the real component
        /// </summary>
        public static void MakeComplex(Span<Complex> com, Span<double> real)
        {
            if (com.Length != real.Length)
                throw new ArgumentOutOfRangeException("Input length must match");
            for (int i = 0; i < real.Length; i++)
                com[i] = new Complex(real[i], 0);
        }

        /// <summary>
        /// Compute the 1D discrete Fourier Transform using the Fast Fourier Transform (FFT) algorithm
        /// </summary>
        /// <param name="input">real input (must be an array with length that is a power of 2)</param>
        /// <returns>transformed input</returns>
        public static Complex[] FFT(double[] input)
        {
            if (input is null)
                throw new ArgumentNullException(nameof(input));

            if (input.Length == 0)
                throw new ArgumentException("Input must not be empty");

            if (!IsPowerOfTwo(input.Length))
                throw new ArgumentException("Input length must be an even power of 2");

            Complex[] buffer = MakeComplex(input);
            FFT(buffer);
            return buffer;
        }

        /// <summary>
        /// Compute the 1D discrete Fourier Transform using the Fast Fourier Transform (FFT) algorithm
        /// </summary>
        /// <param name="input">real input (must be an array with length that is a power of 2)</param>
        /// <returns>real component of transformed input</returns>
        public static Complex[] RFFT(double[] input)
        {
            if (input is null)
                throw new ArgumentNullException(nameof(input));

            if (input.Length == 0)
                throw new ArgumentException("Input must not be empty");

            if (!IsPowerOfTwo(input.Length))
                throw new ArgumentException("Input length must be an even power of 2");

            Complex[] realBuffer = new Complex[input.Length / 2 + 1];
            RFFT(realBuffer, input);
            return realBuffer;
        }

        /// <summary>
        /// Compute the 1D discrete Fourier Transform using the Fast Fourier Transform (FFT) algorithm
        /// </summary>
        /// <param name="destination">Memory location of the results (must be an equal to input length / 2 + 1)</param>
        /// <param name="input">real input (must be an array with length that is a power of 2)</param>
        /// <returns>real component of transformed input</returns>
        public static void RFFT(Span<Complex> destination, Span<double> input)
        {
            if (!IsPowerOfTwo(input.Length))
                throw new ArgumentException("Input length must be an even power of 2");

            if (destination.Length != input.Length / 2 + 1)
                throw new ArgumentException("Destination length must be an equal to input length / 2 + 1");

            Complex[] temp = ArrayPool<Complex>.Shared.Rent(input.Length);

            try
            {
                Span<Complex> buffer = temp;
                MakeComplex(buffer, input);
                FFT(buffer);
                buffer.Slice(0, destination.Length).CopyTo(destination);
            }
            catch (Exception ex)
            {
                throw new Exception("Could not calculate RFFT", ex);
            }
            finally
            {
                ArrayPool<Complex>.Shared.Return(temp);
            }
        }

        /// <summary>
        /// Return a Complex array as an array of its absolute values
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static double[] Absolute(Complex[] input)
        {
            double[] output = new double[input.Length];
            for (int i = 0; i < output.Length; i++)
                output[i] = input[i].Magnitude;
            return output;
        }

        /// <summary>
        /// Calculte power spectrum density (PSD) original (RMS) units
        /// </summary>
        /// <param name="input">real input</param>
        public static double[] FFTmagnitude(double[] input)
        {
            double[] output = new double[input.Length / 2 + 1];
            FFTmagnitude(output, input);
            return output;
        }

        /// <summary>
        /// Calculte power spectrum density (PSD) original (RMS) units
        /// </summary>
        /// <param name="destination">Memory location of the results.</param>
        /// <param name="input">real input</param>
        public static void FFTmagnitude(Span<double> destination, Span<double> input)
        {
            if (!IsPowerOfTwo(input.Length))
                throw new ArgumentException("Input length must be an even power of 2");

            var temp = ArrayPool<Complex>.Shared.Rent(destination.Length);
            try
            {
                var buffer = temp.AsSpan(0, destination.Length);

                // first calculate the FFT
                RFFT(buffer, input);

                // first point (DC component) is not doubled
                destination[0] = buffer[0].Magnitude / input.Length;

                // subsequent points are doubled to account for combined positive and negative frequencies
                for (int i = 1; i < buffer.Length; i++)
                    destination[i] = 2 * buffer[i].Magnitude / input.Length;
            }
            catch (Exception ex)
            {
                throw new Exception("Could not calculate FFT magnitude", ex);
            }
            finally
            {
                ArrayPool<Complex>.Shared.Return(temp);
            }
        }

        /// <summary>
        /// Calculte power spectrum density (PSD) in dB units
        /// </summary>
        /// <param name="input">real input</param>
        public static double[] FFTpower(double[] input)
        {
            if (!IsPowerOfTwo(input.Length))
                throw new ArgumentException("Input length must be an even power of 2");

            double[] output = FFTmagnitude(input);
            Parallel.For(0, output.Length, i => output[i] = 2 * 10 * Math.Log10(output[i]));

            return output;
        }

        /// <summary>
        /// Calculte power spectrum density (PSD) in dB units
        /// </summary>
        /// <param name="destination">Memory location of the results.</param>
        /// <param name="input">real input</param>
        public static void FFTpower(Span<double> destination, double[] input)
        {
            if (!IsPowerOfTwo(input.Length))
                throw new ArgumentException("Input length must be an even power of 2");

            FFTmagnitude(destination, input);
            for (int i = 0; i < destination.Length; i++)
                destination[i] = 2 * 10 * Math.Log10(destination[i]);
        }

        public static double[] PSD_Welch(double[] input, long sampleRate, WindowType windowType, int windowWidth, int overlapPct, WindowAveragingType averagingType, SetReadCalcProgressValueDelegate SetProgress = null)
        {
            if (!IsPowerOfTwo(windowWidth))
                throw new ArgumentException("Window width must be an even power of 2");
            object counter_lock = new object();
            var completed = 0;
            var progress = 0D;

            // "The signal is split up into overlapping segments: the original data segment is split up into L data segments of length M, overlapping by D points"
            var overlapWidth = (int)(overlapPct / 100D * windowWidth);
            var step = windowWidth - overlapWidth;

            double[][] segments = new double[input.Length / step][];
            if (null != SetProgress) SetProgress(string.Format(DTS.Common.Strings.Strings.GeneratingPSD, DTS.Common.Strings.Strings.GeneratingPSD_CreatingSegments), 0D);
            Parallel.For(0, input.Length / step, index =>
            {
                var i = index * step;
                var width = i + windowWidth < input.Length ? windowWidth : input.Length - i;
                var newSegment = new double[windowWidth];
                Array.Copy(input, i, newSegment, 0, width);
                segments[i / step] = newSegment;
                lock (counter_lock)
                {
                    completed++;
                    var pct = (double)completed / (input.Length / step) * 100;
                    if (Math.Floor(pct) > progress)
                    {
                        progress = pct;
                        if (null != SetProgress) SetProgress(String.Empty, progress);//only update on whole % changes
                    }
                }
            });
            if (null != SetProgress) SetProgress(string.Empty, 100D);

            // "After the data is split up into overlapping segments, the individual L data segments have a window applied to them"
            if (null != SetProgress) SetProgress(string.Format(DTS.Common.Strings.Strings.GeneratingPSD, DTS.Common.Strings.Strings.GeneratingPSD_ApplyingWindows), 0D);
            var window = Window.GetWindow(windowType);
            window.Create(segments[0].Length, false);
            completed = 0;
            progress = 0D;
            Parallel.For(0, segments.Length, i =>
            {
                window.ApplyInPlace(segments[i], false);
                lock (counter_lock)
                {
                    completed++;
                    var pct = (double)completed / segments.Length * 100;
                    if (Math.Floor(pct) > progress)
                    {
                        progress = pct;
                        if (null != SetProgress) SetProgress(String.Empty, progress);//only update on whole % changes
                    }
                }
            });
            if (null != SetProgress) SetProgress(string.Empty, 100D);

            // "After doing the above, the periodogram is calculated by computing the discrete Fourier transform...
            if (null != SetProgress) SetProgress(string.Format(DTS.Common.Strings.Strings.GeneratingPSD, DTS.Common.Strings.Strings.GeneratingPSD_CalculatingFFTs), 0D);
            completed = 0;
            progress = 0D;
            Complex[][] windowFFTs = new Complex[segments.Length][];
            Parallel.For(0, segments.Length, i =>
            {
                windowFFTs[i] = RFFT(segments[i]);
                lock (counter_lock)
                {
                    completed++;
                    var pct = (double)completed / segments.Length * 100;
                    if (Math.Floor(pct) > progress)
                    {
                        progress = pct;
                        if (null != SetProgress) SetProgress(String.Empty, progress);//only update on whole % changes
                    }
                }
            });
            if (null != SetProgress) SetProgress(string.Empty, 100D);

            //...and then computing the squared magnitude of the result.
            // The individual periodograms are then averaged, which reduces the variance of the individual power measurements. The end result is an array of power measurements vs. frequency 'bin'."
            if (null != SetProgress) SetProgress(string.Format(DTS.Common.Strings.Strings.GeneratingPSD, DTS.Common.Strings.Strings.GeneratingPSD_CalculatingResults), 0D);
            var scale = sampleRate * windowWidth;
            var denominator = sampleRate * segments.Length * windowWidth;
            var results = new double[windowFFTs[0].Length];

            progress = 0D;
            Parallel.For(0, results.Length, i =>
            {
                switch (averagingType)
                {
                    case WindowAveragingType.PeakHoldMax:
                        var max = windowFFTs.Max(fft => fft[i].MagnitudeSquared * 2);
                        results[i] = Math.Abs(max / scale);
                        break;
                    case WindowAveragingType.PeakHoldMin:
                        var min = windowFFTs.Where(fft => fft[i].MagnitudeSquared != 0).Min(fft => fft[i].MagnitudeSquared * 2);
                        results[i] = Math.Abs(min / scale);
                        break;
                    case WindowAveragingType.Averaging:
                    default:
                        var numerator = windowFFTs.Sum(fft => fft[i].MagnitudeSquared * 2);
                        results[i] = Math.Abs(numerator / denominator);
                        break;
                }
                lock (counter_lock)
                {
                    completed++;
                    var pct = (double)completed / segments.Length * 100;
                    if (Math.Floor(pct) > progress)
                    {
                        progress = pct;
                        if (null != SetProgress) SetProgress(String.Empty, progress);//only update on whole % changes
                    }
                }
            });
            if (null != SetProgress) SetProgress(string.Empty, 100D);

            return results;
        }

        public static double MelToFreq(double mel)
        {
            return 700 * (Math.Pow(10, mel / 2595d) - 1);
        }

        public static double MelFromFreq(double frequencyHz)
        {
            return 2595 * Math.Log10(1 + frequencyHz / 700);
        }

        public static double[] MelScale(double[] fft, int sampleRate, int melBinCount)
        {
            double freqMax = sampleRate / 2;
            double maxMel = MelFromFreq(freqMax);

            double[] fftMel = new double[melBinCount];
            double melPerBin = maxMel / (melBinCount + 1);
            for (int binIndex = 0; binIndex < melBinCount; binIndex++)
            {
                double melLow = melPerBin * binIndex;
                double melHigh = melPerBin * (binIndex + 2);

                double freqLow = MelToFreq(melLow);
                double freqHigh = MelToFreq(melHigh);

                int indexLow = (int)(fft.Length * freqLow / freqMax);
                int indexHigh = (int)(fft.Length * freqHigh / freqMax);
                int indexSpan = indexHigh - indexLow;

                double binScaleSum = 0;
                for (int i = 0; i < indexSpan; i++)
                {
                    double binFrac = (double)i / indexSpan;
                    double indexScale = (binFrac < .5) ? binFrac * 2 : 1 - binFrac;
                    binScaleSum += indexScale;
                    fftMel[binIndex] += fft[indexLow + i] * indexScale;
                }
                fftMel[binIndex] /= binScaleSum;
            }

            return fftMel;
        }

        public static T[] SubArray<T>(this T[] array, int offset, int length)
        {
            T[] result = new T[length];
            Array.Copy(array, offset, result, 0, length);
            return result;
        }
    }
}