using System;
using UnitTestSharp;

namespace Susurrus.XAudio2.UnitTests
{
    public class MasteringVoiceTests : TestFixture
    {
        public class AttachLimiterTests : TestFixture
        {
            public void WithEnabledTrue_StartsLimiting()
            {
                using (TestDevice device = TestDevice.Open())
                {
                    if (device == null)
                    {
                        return;
                    }

                    CheckTrue(device.Master.AttachLimiter(enabled: true).IsOk);
                    CheckTrue(device.Master.HasLimiter);
                    CheckTrue(device.Master.IsLimiting);
                }
            }

            public void WithEnabledFalse_HoldsTheLimiterOff()
            {
                using (TestDevice device = TestDevice.Open())
                {
                    if (device == null)
                    {
                        return;
                    }

                    CheckTrue(device.Master.AttachLimiter(enabled: false).IsOk);
                    CheckTrue(device.Master.HasLimiter);
                    CheckFalse(device.Master.IsLimiting);
                }
            }

            public void ASecondLimiter_Throws()
            {
                using (TestDevice device = TestDevice.Open())
                {
                    if (device == null)
                    {
                        return;
                    }

                    device.Master.AttachLimiter(enabled: true);

                    CheckThrow(typeof(InvalidOperationException));
                    device.Master.AttachLimiter(enabled: true);
                }
            }

            public void AfterDestroy_Throws()
            {
                using (TestDevice device = TestDevice.Open())
                {
                    if (device == null)
                    {
                        return;
                    }

                    device.Master.Destroy();

                    CheckThrow(typeof(ObjectDisposedException));
                    device.Master.AttachLimiter(enabled: true);
                }
            }
        }

        public class SetLimiterEnabledTests : TestFixture
        {
            public void TurnsAnAttachedLimiterOffAndOn()
            {
                using (TestDevice device = TestDevice.Open())
                {
                    if (device == null)
                    {
                        return;
                    }

                    device.Master.AttachLimiter(enabled: true);

                    CheckTrue(device.Master.SetLimiterEnabled(false).IsOk);
                    CheckFalse(device.Master.IsLimiting);
                    CheckTrue(device.Master.SetLimiterEnabled(true).IsOk);
                    CheckTrue(device.Master.IsLimiting);
                }
            }

            public void WithoutALimiter_SucceedsAndStaysOff()
            {
                using (TestDevice device = TestDevice.Open())
                {
                    if (device == null)
                    {
                        return;
                    }

                    CheckTrue(device.Master.SetLimiterEnabled(true).IsOk);
                    CheckFalse(device.Master.IsLimiting);
                }
            }

            public void AfterDestroy_Throws()
            {
                using (TestDevice device = TestDevice.Open())
                {
                    if (device == null)
                    {
                        return;
                    }

                    device.Master.Destroy();

                    CheckThrow(typeof(ObjectDisposedException));
                    device.Master.SetLimiterEnabled(true);
                }
            }
        }

        public class GetChannelCountTests : TestFixture
        {
            public void IsAtLeastOne()
            {
                using (TestDevice device = TestDevice.Open())
                {
                    if (device == null)
                    {
                        return;
                    }

                    CheckGreater(device.Master.GetChannelCount(), 0);
                }
            }

            public void AfterDestroy_Throws()
            {
                using (TestDevice device = TestDevice.Open())
                {
                    if (device == null)
                    {
                        return;
                    }

                    device.Master.Destroy();

                    CheckThrow(typeof(ObjectDisposedException));
                    device.Master.GetChannelCount();
                }
            }
        }
    }
}