# src/OnsetDetection.js

    /**
     * Spectral flux calculating and peaks finding
     * @class
     */
    export default class OnsetDetection {
        /**
         * Get spectral flux
         * @param {Float32Array} audioData - non-interleaved IEEE 32-bit linear PCM with a nominal range of -1 -> +1 (Web Audio API - Audio Buffer)
         * @param {Object} fft - object with methods for performing FFT
         * @param {Object} [params={}] - parameters
         * @param {Number} [params.bufferSize=2048] - FFT windows size
         * @param {Number} [params.hopSize=441] - spacing of audio frames in samples
         * @return {Array} spectralFlux - the array of spectral flux values
         */
        static calculateSF(audioData, fft, params = {}) {
            if (typeof fft == "undefined") {
                throw new ReferenceError("fft is undefined");
            }
            if (typeof fft.getHammingWindow !== "function" || typeof fft.getSpectrum !== "function") {
                throw new ReferenceError("fft doesn't contain getHammingWindow or getSpectrum methods");
            }
            // Array.fill polyfill
            if (!Array.prototype.fill) {
              Array.prototype.fill = function(value) {
                if (this == null) {
                  throw new TypeError('this is null or not defined');
                }
                var O = Object(this);
                var len = O.length >>> 0;
                var start = arguments[1];
                var relativeStart = start >> 0;
                 var k = relativeStart < 0 ?
                  Math.max(len + relativeStart, 0) :
                  Math.min(relativeStart, len);
                var end = arguments[2];
                var relativeEnd = end === undefined ?
                  len : end >> 0;
                var final = relativeEnd < 0 ?
                  Math.max(len + relativeEnd, 0) :
                  Math.min(relativeEnd, len);
                while (k < final) {
                  O[k] = value;
                  k++;
                }
                return O;
              };
            }
            params.bufferSize = params.bufferSize || 2048;
            //params.samplingRate = params.samplingRate || 44100;
            params.hopSize = params.hopSize || 441;

            const {bufferSize, hopSize} = params;

            let k = Math.floor(Math.log(bufferSize) / Math.LN2);
            if (Math.pow(2, k) !== bufferSize) {
                throw "Invalid buffer size (" + bufferSize + "), must be power of 2";
            }

            const hammWindow = fft.getHammingWindow(bufferSize);
            let spectralFlux = [];
            let spectrumLength = bufferSize / 2 + 1;
            let previousSpectrum = new Array(spectrumLength);
            previousSpectrum.fill(0);
            let im = new Array(bufferSize);

            let length = audioData.length;
            let zerosStart = new Array(bufferSize - hopSize);
            zerosStart.fill(0);
            audioData = zerosStart.concat(audioData);

            let zerosEnd = new Array(bufferSize - (audioData.length % hopSize));
            zerosEnd.fill(0);
            audioData = audioData.concat(zerosEnd);

            for (let wndStart = 0; wndStart < length; wndStart += hopSize) {
                let wndEnd = wndStart + bufferSize;

                let re = [];
                let k = 0;
                for (let i = wndStart; i < wndEnd; i++) {
                    re[k] = hammWindow[k] * audioData[i];
                    k++;
                }
                im.fill(0);

                fft.getSpectrum(re, im);

                let flux = 0;
                for(let j = 0; j < spectrumLength; j++) {
                    let value = re[j] - previousSpectrum[j];
                    flux += value < 0 ? 0 : value;
                }
                spectralFlux.push(flux);

                previousSpectrum = re;
            }

            return spectralFlux;
        }
        /**
         * Normalize data to have a mean of 0 and standard deviation of 1
         * @param {Array} data - data array
         */
        static normalize(data) {
            if (!Array.isArray(data)) {
                throw "Array expected";
            }
            if (data.length == 0) {
                throw "Array is empty";
            }
            let sum = 0;
            let squareSum = 0;
            for (let i = 0; i < data.length; i++) {
                sum += data[i];
                squareSum += data[i] * data[i];
            }
            let mean = sum / data.length;
            let standardDeviation = Math.sqrt( (squareSum - sum * mean) / data.length );
            if (standardDeviation == 0)
                standardDeviation = 1;
            for (let i = 0; i < data.length; i++) {
                data[i] = (data[i] - mean) / standardDeviation;
            }
        }
        /**
         * Finding local maxima in an array
         * @param {Array} spectralFlux - input data
         * @param {Object} [params={}] - parametrs
         * @param {Number} [params.decayRate=0.84] - how quickly previous peaks are forgotten
         * @param {Number} [params.peakFindingWindow=6] - minimum distance between peaks
         * @param {Number} [params.meanWndMultiplier=3] - multiplier for peak finding window
         * @param {Number} [params.peakThreshold=0.35] - minimum value of peaks
         * @return {Array} peaks - array of peak indexes
         */
        static findPeaks(spectralFlux, params = {}) {
            const length = spectralFlux.length;
            const sf = spectralFlux;
            const decayRate = params.decayRate || 0.84;
            const peakFindingWindow = params.peakFindingWindow || 6;
            const meanWndMultiplier = params.meanWndMultiplier || 3;
            const peakThreshold = params.peakThreshold || 0.35;

            let max = 0;
            let av = sf[0];
            let peaks = [];

            for (let i = 0; i < length; i++) {
                av = decayRate * av + (1 - decayRate) * sf[i];
                if (sf[i] < av) continue;

                let wndStart = i - peakFindingWindow;
                let wndEnd = i + peakFindingWindow + 1;

                if (wndStart < 0) wndStart = 0;
                if (wndEnd > length) wndEnd = length;
                if (av < sf[i]) av = sf[i];

                let isMax = true;
                for (let j = wndStart; j < wndEnd; j++) {
                    if (sf[j] > sf[i]) isMax = false;
                }
                if (isMax) {
                    let meanWndStart = i - peakFindingWindow * meanWndMultiplier;
                    let meanWndEnd = i + peakFindingWindow;
                    if (meanWndStart < 0) meanWndStart = 0;
                    if (meanWndEnd > length) meanWndEnd = length;
                    let sum = 0;
                    let count = meanWndEnd - meanWndStart;
                    for (let j = meanWndStart; j < meanWndEnd; j++) {
                        sum += sf[j];
                    }
                    if (sf[i] > sum / count + peakThreshold) {
                        peaks.push(i);
                    }
                }
            }

            if (peaks.length < 2) {
                throw "Fail to find peaks";
            }
            return peaks;
        }
    }