using Amphora;
using System;
using System.Runtime.InteropServices;

namespace Susurrus.XAudio2
{
    /// <summary>
    /// A voice that plays queued buffers of samples in one fixed format.
    /// </summary>
    public class SourceVoice : XAudio2Voice
    {
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate int FlaggedCall(IntPtr self, uint flags, uint operationSet);

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate int SubmitCall(IntPtr self, ref XAudio2Buffer buffer, IntPtr bufferWma);

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate int NoArgumentCall(IntPtr self);

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void GetStateCall(IntPtr self, out XAudio2VoiceState state, uint flags);

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate int SetVolumeCall(IntPtr self, float volume, uint operationSet);

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate int SetSampleRateCall(IntPtr self, uint sampleRate);

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate int SetFrequencyRatioCall(IntPtr self, float ratio, uint operationSet);

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void GetFrequencyRatioCall(IntPtr self, out float ratio);

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate int SetOutputMatrixCall(
            IntPtr self, IntPtr destination, uint sourceChannels, uint destinationChannels, float[] levels,
            uint operationSet);

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void GetOutputMatrixCall(
            IntPtr self, IntPtr destination, uint sourceChannels, uint destinationChannels, float[] levels);

        private readonly FlaggedCall start;
        private readonly FlaggedCall stop;
        private readonly SubmitCall submit;
        private readonly NoArgumentCall flush;
        private readonly GetStateCall getState;
        private readonly SetVolumeCall setVolume;
        private readonly SetSampleRateCall setSampleRate;
        private readonly SetFrequencyRatioCall setFrequencyRatio;
        private readonly GetFrequencyRatioCall getFrequencyRatio;
        private readonly SetOutputMatrixCall setOutputMatrix;
        private readonly GetOutputMatrixCall getOutputMatrix;

        public SourceVoice(IntPtr handle) : base(handle)
        {
            this.setFrequencyRatio = Vtable.Bind<SetFrequencyRatioCall>(handle, VoiceSlots.SetFrequencyRatio);
            this.getFrequencyRatio = Vtable.Bind<GetFrequencyRatioCall>(handle, VoiceSlots.GetFrequencyRatio);
            this.setOutputMatrix = Vtable.Bind<SetOutputMatrixCall>(handle, VoiceSlots.SetOutputMatrix);
            this.getOutputMatrix = Vtable.Bind<GetOutputMatrixCall>(handle, VoiceSlots.GetOutputMatrix);
            this.start = Vtable.Bind<FlaggedCall>(handle, VoiceSlots.Start);
            this.stop = Vtable.Bind<FlaggedCall>(handle, VoiceSlots.Stop);
            this.submit = Vtable.Bind<SubmitCall>(handle, VoiceSlots.SubmitSourceBuffer);
            this.flush = Vtable.Bind<NoArgumentCall>(handle, VoiceSlots.FlushSourceBuffers);
            this.getState = Vtable.Bind<GetStateCall>(handle, VoiceSlots.GetState);
            this.setVolume = Vtable.Bind<SetVolumeCall>(handle, VoiceSlots.SetVolume);
            this.setSampleRate = Vtable.Bind<SetSampleRateCall>(handle, VoiceSlots.SetSourceSampleRate);
        }

        private static Status Check(int hresult, string call)
        {
            if (hresult < 0)
            {
                return XAudio2Failures.CallFailed.Fail(call, hresult);
            }

            return Status.Ok;
        }

        public Status Start()
        {
            ThrowIfDestroyed();
            return Check(start(Handle, flags: 0, operationSet: 0), "IXAudio2SourceVoice::Start");
        }

        public Status Stop()
        {
            ThrowIfDestroyed();
            return Check(stop(Handle, flags: 0, operationSet: 0), "IXAudio2SourceVoice::Stop");
        }

        /// <summary>
        /// Queues <paramref name="buffer"/> to play after the buffers already queued.  Its samples have to stay pinned
        /// until the voice has played it or been flushed.
        /// </summary>
        public Status Submit(in XAudio2Buffer buffer)
        {
            ThrowIfDestroyed();
            XAudio2Buffer copy = buffer;
            return Check(submit(Handle, ref copy, bufferWma: IntPtr.Zero), "IXAudio2SourceVoice::SubmitSourceBuffer");
        }

        /// <summary>
        /// Drops the queued buffers.  The mixing thread does it, so <see cref="GetBuffersQueued"/> reaches zero a
        /// moment later.
        /// </summary>
        public Status Flush()
        {
            ThrowIfDestroyed();
            return Check(flush(Handle), "IXAudio2SourceVoice::FlushSourceBuffers");
        }

        public XAudio2VoiceState GetState()
        {
            ThrowIfDestroyed();
            getState(Handle, out XAudio2VoiceState state, flags: 0);
            return state;
        }

        /// <summary>
        /// Returns how many buffers are queued, including the one playing.  Cheaper than <see cref="GetState"/>,
        /// which also counts the samples played.
        /// </summary>
        public int GetBuffersQueued()
        {
            ThrowIfDestroyed();
            getState(Handle, out XAudio2VoiceState state, XAudio2VoiceState.NoSamplesPlayed);
            return (int)state.BuffersQueued;
        }

        /// <summary>
        /// Sets the linear gain, where one leaves the samples as they are.
        /// </summary>
        public Status SetVolume(float volume)
        {
            ThrowIfDestroyed();
            Volume.Check(volume, nameof(volume));
            return Check(setVolume(Handle, volume, operationSet: 0), "IXAudio2Voice::SetVolume");
        }

        /// <summary>
        /// Changes the rate the voice reads its samples at, which pitches the sound without changing the format.
        /// </summary>
        public Status SetSampleRate(int sampleRate)
        {
            ThrowIfDestroyed();

            if (sampleRate <= 0)
            {
                throw new ArgumentOutOfRangeException(
                    nameof(sampleRate), sampleRate, "A sample rate must be positive.");
            }

            return Check(setSampleRate(Handle, (uint)sampleRate), "IXAudio2SourceVoice::SetSourceSampleRate");
        }

        /// <summary>
        /// Sets the ratio the voice reads its samples at, on top of its sample rate.  A ratio of one leaves the pitch
        /// alone.  The voice was made with a highest ratio it can take.
        /// </summary>
        public Status SetFrequencyRatio(float ratio)
        {
            ThrowIfDestroyed();
            Pitch.Check(ratio, nameof(ratio));
            return Check(setFrequencyRatio(Handle, ratio, operationSet: 0), "IXAudio2SourceVoice::SetFrequencyRatio");
        }

        public float GetFrequencyRatio()
        {
            ThrowIfDestroyed();
            getFrequencyRatio(Handle, out float ratio);
            return ratio;
        }

        /// <summary>
        /// Sets how much of each channel of the voice goes to each channel of the mastering voice, as a row of levels
        /// for every destination channel and a column for every source channel.
        /// </summary>
        public Status SetOutputMatrix(int sourceChannels, int destinationChannels, float[] levels)
        {
            ThrowIfDestroyed();
            CheckMatrix(sourceChannels, destinationChannels, levels);
            return Check(setOutputMatrix(Handle, IntPtr.Zero, (uint)sourceChannels, (uint)destinationChannels, levels,
                operationSet: 0), "IXAudio2Voice::SetOutputMatrix");
        }

        /// <summary>
        /// Reads back the levels the voice sends to the mastering voice, into the start of <paramref name="levels"/>.
        /// </summary>
        public void GetOutputMatrix(int sourceChannels, int destinationChannels, float[] levels)
        {
            ThrowIfDestroyed();
            CheckMatrix(sourceChannels, destinationChannels, levels);
            getOutputMatrix(Handle, IntPtr.Zero, (uint)sourceChannels, (uint)destinationChannels, levels);
        }

        private static void CheckMatrix(int sourceChannels, int destinationChannels, float[] levels)
        {
            if (levels == null)
            {
                throw new ArgumentNullException(nameof(levels));
            }

            if (sourceChannels < 1 || destinationChannels < 1 || levels.Length < sourceChannels * destinationChannels)
            {
                throw new ArgumentException(
                    "The levels need a place for every source channel to every destination channel.", nameof(levels));
            }
        }
    }
}