using System;
using System.Diagnostics;
using System.Threading;

namespace Susurrus.XAudio2.UnitTests
{
    /// <summary>
    /// A loaded module, which needs a machine that has XAudio2 and an audio device.
    /// </summary>
    public class TestModule : IDisposable
    {
        public XAudio2Module Module { get; }

        private TestModule(XAudio2Module module)
        {
            this.Module = module;
        }

        /// <summary>
        /// Returns the loaded module, or null on a machine that can't play sound.
        /// </summary>
        public static TestModule Open(int monoVoiceCount = 4, int stereoVoiceCount = 4)
        {
            XAudio2Module module = new XAudio2Module(monoVoiceCount, stereoVoiceCount);

            if (!module.IsSupported)
            {
                return null;
            }

            module.Load();
            return new TestModule(module);
        }

        /// <summary>
        /// Calls Update until <paramref name="done"/> is true, and returns false if it never is.
        /// </summary>
        public bool UpdateUntil(Func<bool> done)
        {
            Stopwatch clock = Stopwatch.StartNew();

            while (!done())
            {
                if (clock.ElapsedMilliseconds > 5000)
                {
                    return false;
                }

                Thread.Sleep(1);
                Module.Update();
            }

            return true;
        }

        /// <summary>
        /// Calls Update until <paramref name="voice"/> has stopped playing, and returns false if it never does.
        /// </summary>
        public bool UpdateUntilFinished(Voice voice)
        {
            return UpdateUntil(() => !Module.IsPlaying(voice));
        }

        /// <summary>
        /// Calls Update until the engine plays <paramref name="voice"/> at <paramref name="pitch"/>, which it takes up
        /// a moment after the call that sets it.  Returns false if it never does.
        /// </summary>
        public bool UpdateUntilPitch(Voice voice, float pitch)
        {
            return UpdateUntil(() => Module.PitchOf(voice) == pitch);
        }

        /// <summary>
        /// Calls Update until a sound can start again, and returns None if it never can.
        /// </summary>
        public Voice UpdateUntilPlayable(Sound sound)
        {
            Stopwatch clock = Stopwatch.StartNew();

            while (clock.ElapsedMilliseconds < 5000)
            {
                Module.Update();
                Voice voice = Module.Play(sound, volume: 0f);

                if (!voice.IsNone)
                {
                    return voice;
                }

                Thread.Sleep(1);
            }

            return Voice.None;
        }

        public void Dispose()
        {
            Module.Unload();
        }
    }
}