using System;

 using System.Collections.Generic;

 using System.ComponentModel;

 using System.Diagnostics;

 using CSCore;

 using CSCore.DSP;

 namespace Visualization

 {

     public class SpectrumBase : INotifyPropertyChanged

     {

         private const int ScaleFactorLinear = 9;

         protected const int ScaleFactorSqr = 2;

         protected const double MinDbValue = -90;

         protected const double MaxDbValue = 0;

         protected const double DbScale = (MaxDbValue - MinDbValue);

         protected float[] iFftBuffer;

         private int _fftSize;        

         private bool _isXLogScale;

         private int _maxFftIndex;

         private int _maximumFrequency = 20000;

         private int _maximumFrequencyIndex;

         private int _minimumFrequency = 20; //Default spectrum from 20Hz to 20kHz

         private int _minimumFrequencyIndex;

         private ScalingStrategy _scalingStrategy;

         private int[] _spectrumIndexMax;

         private int[] _spectrumLogScaleIndexMax;

         private ISpectrumProvider _spectrumProvider;

         protected int SpectrumResolution;

         private bool _useAverage;

         public int MaximumFrequency

         {

             get { return _maximumFrequency; }

             set

             {

                 if (value <= MinimumFrequency)

                 {

                     throw new ArgumentOutOfRangeException("value",

                         "Value must not be less or equal the MinimumFrequency.");

                 }

                 _maximumFrequency = value;

                 UpdateFrequencyMapping();

                 RaisePropertyChanged("MaximumFrequency");

             }

         }

         public int MinimumFrequency

         {

             get { return _minimumFrequency; }

             set

             {

                 if (value < 0)

                     throw new ArgumentOutOfRangeException("value");

                 _minimumFrequency = value;

                 UpdateFrequencyMapping();

                 RaisePropertyChanged("MinimumFrequency");

             }

         }

         [BrowsableAttribute(false)]

         public ISpectrumProvider SpectrumProvider

         {

             get { return _spectrumProvider; }

             set

             {

                 if (value == null)

                     throw new ArgumentNullException("value");

                 _spectrumProvider = value;

                 RaisePropertyChanged("SpectrumProvider");

             }

         }

         public bool IsXLogScale

         {

             get { return _isXLogScale; }

             set

             {

                 _isXLogScale = value;

                 UpdateFrequencyMapping();

                 RaisePropertyChanged("IsXLogScale");

             }

         }

         public ScalingStrategy ScalingStrategy

         {

             get { return _scalingStrategy; }

             set

             {

                 _scalingStrategy = value;

                 RaisePropertyChanged("ScalingStrategy");

             }

         }

         public bool UseAverage

         {

             get { return _useAverage; }

             set

             {

                 _useAverage = value;

                 RaisePropertyChanged("UseAverage");

             }

         }

         [BrowsableAttribute(false)]

         public FftSize FftSize

         {

             get { return (FftSize) _fftSize; }

             protected set

             {

                 if ((int) Math.Log((int) value, 2) % 1 != 0)

                     throw new ArgumentOutOfRangeException("value");

                 _fftSize = (int) value;

                 _maxFftIndex = _fftSize / 2 - 1;

                 iFftBuffer = new float[_fftSize];

                 RaisePropertyChanged("FFTSize");

             }

         }

         public event PropertyChangedEventHandler PropertyChanged;

         protected virtual void UpdateFrequencyMapping()

         {

             _maximumFrequencyIndex = Math.Min(_spectrumProvider.GetFftBandIndex(MaximumFrequency) + 1, _maxFftIndex);

             _minimumFrequencyIndex = Math.Min(_spectrumProvider.GetFftBandIndex(MinimumFrequency), _maxFftIndex);

             int actualResolution = SpectrumResolution;

             int indexCount = _maximumFrequencyIndex - _minimumFrequencyIndex;

             double linearIndexBucketSize = Math.Round(indexCount / (double) actualResolution, 3);

             _spectrumIndexMax = _spectrumIndexMax.CheckBuffer(actualResolution, true);

             _spectrumLogScaleIndexMax = _spectrumLogScaleIndexMax.CheckBuffer(actualResolution, true);

             double maxLog = Math.Log(actualResolution, actualResolution);

             for (int i = 1; i < actualResolution; i++)

             {

                 int logIndex =

                     (int) ((maxLog - Math.Log((actualResolution + 1) - i, (actualResolution + 1))) * indexCount) +

                     _minimumFrequencyIndex;

                 _spectrumIndexMax[i - 1] = _minimumFrequencyIndex + (int) (i * linearIndexBucketSize);

                 _spectrumLogScaleIndexMax[i - 1] = logIndex;

             }

             if (actualResolution > 0)

             {

                 _spectrumIndexMax[_spectrumIndexMax.Length - 1] =

                     _spectrumLogScaleIndexMax[_spectrumLogScaleIndexMax.Length - 1] = _maximumFrequencyIndex;

             }

         }

         protected virtual SpectrumPointData[] CalculateSpectrumPoints(double maxValue, float[] fftBuffer)

         {

             var dataPoints = new List<SpectrumPointData>();

             //double value0 = 0, value = 0;

             //double lastValue = 0;

             //double actualMaxValue = maxValue;

             //int spectrumPointIndex = 0;

             int b0 = _minimumFrequencyIndex;

             int x, y;

             for (x = 0; x < SpectrumResolution; x++)

             {

                 float peak = 0;

                 //SL: We should have to compute that only once for a given resolution.

                 // Try using the existing pre-computed array we have and refactor that whole mess.

                 int b1 = (int)Math.Pow(2, x * 10.0 / (SpectrumResolution - 1)); 

                 //int b1 = (IsXLogScale ? _spectrumLogScaleIndexMax[x] : _spectrumIndexMax[x]);

                 if (b1 > _maximumFrequencyIndex) b1 = _maximumFrequencyIndex;

                 if (b1 <= b0) b1 = b0 + 1;

                 for (; b0 < b1; b0++)

                 {

                     if (peak < fftBuffer[1 + b0]) peak = fftBuffer[1 + b0];

                 }

                 const int KHeightScaleFactor = 5; // SL: You can play with that scale factor to tune the height of the bars

                 y = (int)(Math.Sqrt(peak) * KHeightScaleFactor * maxValue); 

                 if (y > maxValue) y = (int)maxValue;

                 if (y < 0) y = 0;

                 dataPoints.Add(new SpectrumPointData { SpectrumPointIndex = x, Value = y });

                 //_spectrumdata.Add((byte)y);

                 //Console.Write("{0, 3} ", y);

             }

             /*

             for (int i = _minimumFrequencyIndex; i <= _maximumFrequencyIndex; i++)

             {

                 switch (ScalingStrategy)

                 {

                     case ScalingStrategy.Decibel:

                         value0 = (((20 * Math.Log10(fftBuffer[i])) - MinDbValue) / DbScale) * actualMaxValue;

                         break;

                     case ScalingStrategy.Linear:

                         value0 = (fftBuffer[i] * ScaleFactorLinear) * actualMaxValue;

                         break;

                     case ScalingStrategy.Sqrt:

                         value0 = ((Math.Sqrt(fftBuffer[i])) * ScaleFactorSqr) * actualMaxValue;

                         break;

                 }

                 bool recalc = true;

                 value = Math.Max(0, Math.Max(value0, value));

                 while (spectrumPointIndex <= _spectrumIndexMax.Length - 1 &&

                        i ==

                        (IsXLogScale

                            ? _spectrumLogScaleIndexMax[spectrumPointIndex]

                            : _spectrumIndexMax[spectrumPointIndex]))

                 {

                     if (!recalc)

                         value = lastValue;

                     if (value > maxValue)

                         value = maxValue;

                     if (_useAverage && spectrumPointIndex > 0)

                         value = (lastValue + value) / 2.0;

                     dataPoints.Add(new SpectrumPointData {SpectrumPointIndex = spectrumPointIndex, Value = value});

                     lastValue = value;

                     value = 0.0;

                     spectrumPointIndex++;

                     recalc = false;

                 }

                 //value = 0;

             }

             */

             return dataPoints.ToArray();

         }

         protected void RaisePropertyChanged(string propertyName)

         {

             if (PropertyChanged != null && !String.IsNullOrEmpty(propertyName))

                 PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

         }

         [DebuggerDisplay("{Value}")]

         protected struct SpectrumPointData

         {

             public int SpectrumPointIndex;

             public double Value;

         }

     }

 }