using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel.Security;
using System.Threading.Tasks;
using BarRaider.SdTools;
using NAudio.Wave;
using NAudio.Wave.SampleProviders;
using Newtonsoft.Json;

class CachedSound
{
    public byte[] AudioData { get; private set; }
    public WaveFormat WaveFormat { get; private set; }
    public CachedSound(string audioFileName)
    {
        using (var audioFileReader = new AudioFileReader(audioFileName))
        {
            // TODO: could add resampling in here if required
            WaveFormat = audioFileReader.WaveFormat;
            var wholeFile = new List<byte>((int)(audioFileReader.Length));
            var readBuffer = new byte[audioFileReader.WaveFormat.SampleRate * audioFileReader.WaveFormat.Channels*4];
            int samplesRead;
            while ((samplesRead = audioFileReader.Read(readBuffer, 0, readBuffer.Length)) > 0)
            {
                wholeFile.AddRange(readBuffer.Take(samplesRead));
            }
            AudioData = wholeFile.ToArray();
        }
        //Logger.Instance.LogMessage(TracingLevel.INFO, $"AudioData Length {AudioData.Length}");

    }
}
class CachedSoundSampleProvider : IWaveProvider
{
    private readonly CachedSound cachedSound;
    private long position;

    ~CachedSoundSampleProvider() {
        //Logger.Instance.LogMessage(TracingLevel.INFO, $"Cache destructor");
    }    

    public CachedSoundSampleProvider(CachedSound cachedSound)
    {
        this.cachedSound = cachedSound;
        position = 0;
    }

    public int Read(byte[] buffer, int offset, int count)
    {
        //Logger.Instance.LogMessage(TracingLevel.INFO, $"Read1 byte");
        var availableSamples = cachedSound.AudioData.Length - position;
        var samplesToCopy = Math.Min(availableSamples, count);
        try
        {
            //Logger.Instance.LogMessage(TracingLevel.INFO, $"{cachedSound.AudioData.GetType()} {buffer.GetType()}");
            Array.Copy(cachedSound.AudioData, position, buffer, offset, samplesToCopy);
        }
        catch (Exception ex)
        {
            //Logger.Instance.LogMessage(TracingLevel.INFO, $"{ex.ToString()}");
        }
        //Logger.Instance.LogMessage(TracingLevel.INFO, $"Read3");
        position += samplesToCopy;
        //Logger.Instance.LogMessage(TracingLevel.INFO, $"Sending {samplesToCopy} samples");
        return (int)samplesToCopy;
    }

    public WaveFormat WaveFormat => cachedSound.WaveFormat;
}

public class WavPlayer
{
    private static WavPlayer? instance;
    public static WavPlayer Instance
    {
        get
        {
            instance ??= new WavPlayer();
            return instance;
        }

    }
    public enum PlayMode
    {
        PlayOverlap,
        PlayStop
    }

    private readonly ConcurrentDictionary<string, List<Tuple<WaveOutEvent, IWaveProvider>>> _activePlayers;

    public WavPlayer()
    {
        _activePlayers = new ConcurrentDictionary<string, List<Tuple<WaveOutEvent, IWaveProvider>>>();
    }

    public void Play(string filePath, string id, double volume, PlayMode mode)
    {
        if (string.IsNullOrWhiteSpace(filePath))
            throw new ArgumentException("File path cannot be null or empty.", nameof(filePath));

        if (mode == PlayMode.PlayOverlap)
        {
            PlayWithOverlap(filePath, id, volume);
        }
        else if (mode == PlayMode.PlayStop)
        {
            PlayWithStop(filePath, id, volume);
        }
        else
        {
            throw new ArgumentOutOfRangeException(nameof(mode), "Invalid play mode specified.");
        }
    }

    private void PlayWithOverlap(string filePath, string id, double volume)
    {

        try
        {
            //Logger.Instance.LogMessage(TracingLevel.INFO, "Play overlap");
            var player = CreatePlayer(filePath, id);

            if (!_activePlayers.ContainsKey(filePath))
            {
                _activePlayers[filePath] = new List<Tuple<WaveOutEvent, IWaveProvider>>();
            }

            _activePlayers[filePath].Add(player);
            player.Item1.Volume = (float)volume;
            player.Item1.Play();
        }
        catch(Exception ex) 
        {
            //Logger.Instance.LogMessage(TracingLevel.INFO, ex.ToString());
        }
       
        //var playersToDispose = _activePlayers[filePath].Where(x => x.Item1.PlaybackState == PlaybackState.Stopped).ToList();
        //foreach (var p in playersToDispose)
        //{
        //    p.Item1.Stop();
        //    p.Item1.Dispose();
        //}
        //_activePlayers[filePath].RemoveAll(x => x.Item1.PlaybackState == PlaybackState.Stopped);
    }

    private void PlayWithStop(string filePath, string id, double volume)
    {
        if (_activePlayers.TryGetValue(filePath, out var players))
        {

            // Stop and dispose all current players for this file
            if (players.Any(x => x.Item1.PlaybackState == PlaybackState.Playing))
            {
                var playersToDispose = players.ToList();
                foreach (var player in playersToDispose)
                {
                    player.Item1.Stop();
                    player.Item1.Dispose();
                }
            }
            else
            {
                PlayWithOverlap(filePath, id, volume);
            }

        }
        else
        {
            // Start a new player
            PlayWithOverlap(filePath, id, volume);
        }

        _activePlayers[filePath].RemoveAll(x => x.Item1.PlaybackState == PlaybackState.Stopped);
    }

    private Tuple<WaveOutEvent, IWaveProvider> CreatePlayer(string filePath, string name)
    {
        var reader = new CachedSoundSampleProvider(new CachedSound(filePath));
        //var reader = new AudioFileReader(filePath);
        int number = -1;
        for (int i = 0; i < WaveOut.DeviceCount; ++i)
        {
            if (WaveOut.GetCapabilities(i).ProductName == name)
            {
                number = i;
            }
        }
        var player = new WaveOutEvent() { DeviceNumber = number };
        player.Init(reader);
        return new Tuple<WaveOutEvent, IWaveProvider>(player, reader);
    }

    private void CleanupPlayer(string filePath)
    {
        if (_activePlayers.TryGetValue(filePath, out var players))
        {
            var playersToDispose = players.ToList();
            foreach (var p in playersToDispose)
            {
                p.Item1.Stop();
                p.Item1.Dispose();
            }
        }
        _activePlayers[filePath].RemoveAll(x => x.Item1.PlaybackState == PlaybackState.Stopped);

    }

    public void StopAll()
    {
        foreach (var players in _activePlayers.Values)
        {
            var playersToDispose = players.ToList();
            foreach (var player in playersToDispose)
            {
                player.Item1.Stop();
                player.Item1.Dispose();
            }
            players.Clear();
        }

        _activePlayers.Clear();
    }
}