using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

//CSCore

using CSCore;

using CSCore.Win32;

using CSCore.DSP;

using CSCore.Streams;

using CSCore.CoreAudioAPI;

using CSCore.SoundIn;

// Visualization

using Visualization;

namespace SharpDisplayManager

{

    class AudioManager

    {

        // Volume management

        private MMDeviceEnumerator iMultiMediaDeviceEnumerator;

        private MMNotificationClient iMultiMediaNotificationClient;

        private MMDevice iMultiMediaDevice;

        private AudioEndpointVolume iAudioEndpointVolume;

        private AudioEndpointVolumeCallback iAudioEndpointVolumeCallback;

        EventHandler<DefaultDeviceChangedEventArgs> iDefaultDeviceChangedHandler;

        EventHandler<AudioEndpointVolumeCallbackEventArgs> iVolumeChangedHandler;

        // Audio visualization

        private WasapiCapture iSoundIn;

        private IWaveSource iWaveSource;

        private LineSpectrum iLineSpectrum;

        private int iVisualizerCount = 0;

        public LineSpectrum Spectrum { get { return iLineSpectrum; } }

        public AudioEndpointVolume Volume { get { return iAudioEndpointVolume; } }

        public MMDevice DefaultDevice { get { return iMultiMediaDevice; } }

        /// <summary>

        /// Increment our visualizer count

        /// </summary>

        public void AddVisualizer()

        {

            if (iVisualizerCount == 0)

            {

                // If we need at least one visualizer then we need to start our engine.

                StartAudioVisualization();

            }

            //TODO: Check bounds?

            iVisualizerCount++;

        }

        /// <summary>

        /// Decrement our visualizer counter.

        /// </summary>

        public void RemoveVisualizer()

        {

            if (iVisualizerCount == 1)

            {

                // When reaching zero visualization is not need and we stop our engine

                StopAudioVisualization();

                iVisualizerCount = 0;

            }

            // Defensive: Make sure we don't go below zero

            else if (iVisualizerCount>0)

            {

                iVisualizerCount--;

            }

        }

        /// <summary>

        /// 

        /// </summary>

        /// <param name="aDefaultDeviceChangedHandler"></param>

        /// <param name="aVolumeChangedHandler"></param>

        public void Open(   EventHandler<DefaultDeviceChangedEventArgs> aDefaultDeviceChangedHandler,

                            EventHandler<AudioEndpointVolumeCallbackEventArgs> aVolumeChangedHandler)

        {

            //Create device and register default device change notification

            iMultiMediaDeviceEnumerator = new MMDeviceEnumerator();

            iMultiMediaNotificationClient = new MMNotificationClient(iMultiMediaDeviceEnumerator);

            iMultiMediaNotificationClient.DefaultDeviceChanged += iDefaultDeviceChangedHandler = aDefaultDeviceChangedHandler;

            iMultiMediaDevice = iMultiMediaDeviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Render,Role.Multimedia);

            //Register to get volume modifications

            iAudioEndpointVolume = AudioEndpointVolume.FromDevice(iMultiMediaDevice);

            iAudioEndpointVolumeCallback = new AudioEndpointVolumeCallback();

            iAudioEndpointVolumeCallback.NotifyRecived += iVolumeChangedHandler = aVolumeChangedHandler;

            iAudioEndpointVolume.RegisterControlChangeNotify(iAudioEndpointVolumeCallback);

            if (iVisualizerCount > 0)

            {

                // We probably got restarted, make sure visualization is running if needed

                StartAudioVisualization();

            }

        }

        /// <summary>

        /// 

        /// </summary>

        public void Close()

        {

            StopAudioVisualization();

            // Client up our MM objects in reverse order

            if (iAudioEndpointVolumeCallback != null && iAudioEndpointVolume != null)

            {

                iAudioEndpointVolume.UnregisterControlChangeNotify(iAudioEndpointVolumeCallback);

            }

            if (iAudioEndpointVolumeCallback != null)

            {

                iAudioEndpointVolumeCallback.NotifyRecived -= iVolumeChangedHandler;

                iAudioEndpointVolumeCallback = null;

            }

            if (iAudioEndpointVolume != null)

            {

                iAudioEndpointVolume.Dispose();

                iAudioEndpointVolume = null;

            }

            if (iMultiMediaDevice != null)

            {

                iMultiMediaDevice.Dispose();

                iMultiMediaDevice = null;

            }

            if (iMultiMediaNotificationClient != null)

            {

                iMultiMediaNotificationClient.DefaultDeviceChanged -= iDefaultDeviceChangedHandler;

                iMultiMediaNotificationClient.Dispose();

                iMultiMediaNotificationClient = null;

            }

            if (iMultiMediaDeviceEnumerator != null)

            {

                iMultiMediaDeviceEnumerator.Dispose();

                iMultiMediaDeviceEnumerator = null;

            }

        }

        /// <summary>

        /// 

        /// </summary>

        private void StartAudioVisualization()

        {

            //Open the default device 

            iSoundIn = new WasapiLoopbackCapture();

            //Our loopback capture opens the default render device by default so the following is not needed

            //iSoundIn.Device = MMDeviceEnumerator.DefaultAudioEndpoint(DataFlow.Render, Role.Console);

            iSoundIn.Initialize();

            SoundInSource soundInSource = new SoundInSource(iSoundIn);

            ISampleSource source = soundInSource.ToSampleSource();

            const FftSize fftSize = FftSize.Fft2048;

            //create a spectrum provider which provides fft data based on some input

            BasicSpectrumProvider spectrumProvider = new BasicSpectrumProvider(source.WaveFormat.Channels, source.WaveFormat.SampleRate, fftSize);

            //linespectrum and voiceprint3dspectrum used for rendering some fft data

            //in oder to get some fft data, set the previously created spectrumprovider 

            iLineSpectrum = new LineSpectrum(fftSize)

            {

                SpectrumProvider = spectrumProvider,

                UseAverage = false, // Does not matter since we hacked it

                BarCount = 16,

                BarSpacing = 1,

                IsXLogScale = true, // Does not matter since we hacked it

                ScalingStrategy = ScalingStrategy.Decibel // Does not matter since we hacked it

            };

            //the SingleBlockNotificationStream is used to intercept the played samples

            var notificationSource = new SingleBlockNotificationStream(source);

            //pass the intercepted samples as input data to the spectrumprovider (which will calculate a fft based on them)

            notificationSource.SingleBlockRead += (s, a) => spectrumProvider.Add(a.Left, a.Right);

            iWaveSource = notificationSource.ToWaveSource(16);

            // We need to read from our source otherwise SingleBlockRead is never called and our spectrum provider is not populated

            byte[] buffer = new byte[iWaveSource.WaveFormat.BytesPerSecond / 2];

            soundInSource.DataAvailable += (s, aEvent) =>

            {

                int read;

                while ((read = iWaveSource.Read(buffer, 0, buffer.Length)) > 0) ;

            };

            //Start recording

            iSoundIn.Start();

        }

        /// <summary>

        /// 

        /// </summary>

        private void StopAudioVisualization()

        {

            if (iSoundIn != null)

            {

                iSoundIn.Stop();

            }

                if (iWaveSource != null)

            {

                iWaveSource.Dispose();

                iWaveSource = null;

            }

            if (iSoundIn != null)

            {

                iSoundIn.Dispose();

                iSoundIn = null;

            }

            iLineSpectrum = null;

        }

    }

}