namespace DarkWynterEngine.Audio
{
    #region Using Statements
    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Audio;
    using Microsoft.Xna.Framework.Content;
    using Microsoft.Xna.Framework.Graphics;
    using Microsoft.Xna.Framework.Input;
    using Microsoft.Xna.Framework.Storage;
    using System.Xml;
    #endregion

    using Globals;
    using Physics;
    using GameObjects;


    public static class AudioMixer
    {
        /// <summary>
        /// Background Music
        /// </summary>
        static WaveBank music;
        /// <summary>
        /// Sound Effects
        /// </summary>
        static WaveBank effects;
        /// <summary>
        /// Provides access to WaveBank entries
        /// </summary>
        static SoundBank soundBank;

        
        public struct AudioBackground
        {
            /// <summary>
            /// Earth Attack sound.
            /// </summary>
            public static List<AudioCue> background;
        }

        public struct Audio3D
        {
            /// <summary>
            /// Earth Attack sound.
            /// </summary>
            public static AudioCue earthAttack;
            /// <summary>
            /// Water Attack sound.
            /// </summary>
            public static AudioCue waterAttack;
            /// <summary>
            /// Air Attack sound.
            /// </summary>
            public static AudioCue airAttack;

            /// <summary>
            /// 3D Cue used with jump sound.
            /// </summary>
            public static AudioCue jump;
            /// <summary>
            /// 3D Cue used with hit sound.
            /// </summary>
            public static AudioCue smackDownHit;
            /// <summary>
            /// 3D Cue used with walk sound.
            /// </summary>
            public static AudioCue walking;
            /// <summary>
            /// 3D Cue used with terrainMod sound.
            /// </summary>
            public static AudioCue terrainMod;
            /// <summary>
            /// 3D Cue used with fire attack sound.
            /// </summary
            public static AudioCue fireAttack;

        }

        public struct Audio2D
        {
            /// <summary>
            /// Sound played when player finds a Key.
            /// </summary>
            public static AudioCue KeyFound;
            /// <summary>
            /// Sound played when Start button is pressed in menu system.
            /// </summary>
            public static AudioCue MenuStart;
            /// <summary>
            /// Sound played when Back button is pressed in menu system.
            /// </summary>
            public static AudioCue MenuBack;
            /// <summary>
            /// Sound played when Up button is pressed in menu system.
            /// </summary>
            public static AudioCue MenuUp;
            /// <summary>
            /// Sound played when Down button is pressed in menu system.
            /// </summary>
            public static AudioCue MenuDown;
            /// <summary>
            /// Sound played when Left button is pressed in menu system.
            /// </summary>
            public static AudioCue MenuLeft;
            /// <summary>
            /// Sound played when Right button is pressed in menu system.
            /// </summary>
            public static AudioCue MenuRight;
            /// <summary>
            /// Sound played when Player selection is changed in menu system.
            /// </summary>
            public static AudioCue MenuShuffleRight;
            /// <summary>
            /// Sound played when Player selection is changed in menu system.
            /// </summary>
            public static AudioCue MenuShuffleLeft;
            /// <summary>
            /// Sound played when Dpad button is pressed in Game.
            /// </summary>
            public static AudioCue MenuDPad();
        }



    }

    /// <summary>
    /// Supports 2D and 3D audio in the form of an AudioCue.
    /// Functions are named after the effect they use in simple functions that
    /// wrap the audio file name, making it easy to change sounds that are 
    /// scattered throughout the engine by changing a single reference.
    /// </summary>
    public static class AudioProcessor
    {
        /// <summary>
        /// XNA audio engine API
        /// </summary>
        static AudioEngine audioEngine;


        /// <summary>
        /// Keeps metranome synchronous time
        /// </summary>
        public static Stopwatch currentGameTime;
        /// <summary>
        /// Delay before playing another walk cue.
        /// Used to stop too many sounds from being played at once.
        /// </summary>
        public Stopwatch walkingSoundTimer;
        /// <summary>
        /// Delay before playing another terrainMod cue.
        /// Used to stop too many sounds from being played at once.
        /// </summary>
        public Stopwatch terrainModSoundTimer;

        
        /// <summary>
        /// Background music queue. 
        /// Effects don't have cues b/c the sound isn't looped.
        /// </summary>
        static List<AudioCue> cues;                              
        /// <summary>
        /// True if background music is playing.
        /// </summary>
        
        
        /// <summary>
        /// Used for 3D sound.. don't play if out of range.. wastes proccesses
        /// </summary>
        public static float SOUND_CUTOFF_DISTANCE = 1500;

        /// <summary>
        /// Loads audioEngine, soundBank, music waveBank, and effects waveBank.
        /// Hand out instruments to the musicians.
        /// </summary>
        public static void Initialize(XmlNode node)
        {            
            
            // Clear music cue list
            cues = new List<Cue>();

            // Used to measure track elapsed time.
            currentGameTime = new Stopwatch();
            currentGameTime.Start();
 

            // Load Audio xml file and associate with engine sounds            
            if (node.Name == "AudioConfig")
            {
                try
                {

                    // Load Audio Engine Files
                    audioEngine = new AudioEngine("Content/_audio/Elemental.xgs");
                    soundBank = new SoundBank(audioEngine, "Content/_audio/Sound Bank.xsb");

                    music = new WaveBank(audioEngine, "Content/_audio/Music.xwb");
                    effects = new WaveBank(audioEngine, "Content/_audio/Effects.xwb");


                    // Load Background Sounds
                    if (node.ChildNodes[i].Name() == "Background")
                    {
                        for (int i = 0; i < node.ChildNodes; i++)
                        {
                            // Get Child Nodes and replace strings GetCue methods
                            if (node.ChildNodes[i].Name() == "EarthAttack")
                            {
                                AudioBackground.background = new AudioCue(node.ChildNodes[i].Value);
                            }
                        }
                    }

                    // Load Menu Sounds
                    if (node.ChildNodes[i].Name() == "Menu")
                    {
                        for (int i = 0; i < node.ChildNodes; i++)
                        {
                            // ABSTRACT = CREATE ABSTRACT ENGINE SOUND CLASS
                            // ALLOW GAME OVERRIDE OF SINGLE IF STATEMENT LIKE ONE BELOW

                            // Get Child Nodes and replace strings GetCue methods
                            if (node.ChildNodes[i].Name() == "MenuStart")
                            {
                                Audio2D.MenuStart = new AudioCue(node.ChildNodes[i].Value);
                            }

                            // Get Child Nodes and replace strings GetCue methods
                            if (node.ChildNodes[i].Name() == "MenuBack")
                            {
                                Audio2D.MenuBack = new AudioCue(node.ChildNodes[i].Value);
                            }
                            // Get Child Nodes and replace strings GetCue methods
                            if (node.ChildNodes[i].Name() == "MenuShuffleRight")
                            {
                                Audio2D.MenuShuffleRight = new AudioCue(node.ChildNodes[i].Value);
                            }
                            // Get Child Nodes and replace strings GetCue methods
                            if (node.ChildNodes[i].Name() == "MenuShuffleLeft")
                            {
                                Audio2D.MenuShuffleLeft = new AudioCue(node.ChildNodes[i].Value);
                            }
                            // Get Child Nodes and replace strings GetCue methods
                            if (node.ChildNodes[i].Name() == "MenuUp")
                            {
                                Audio2D.MenuUp = new AudioCue(node.ChildNodes[i].Value);
                            }
                            // Get Child Nodes and replace strings GetCue methods
                            if (node.ChildNodes[i].Name() == "MenuDown")
                            {
                                Audio2D.MenuDown = new AudioCue(node.ChildNodes[i].Value);
                            }
                            // Get Child Nodes and replace strings GetCue methods
                            if (node.ChildNodes[i].Name() == "MenuLeft")
                            {
                                Audio2D.MenuLeft = new AudioCue(node.ChildNodes[i].Value);
                            }
                            // Get Child Nodes and replace strings GetCue methods
                            if (node.ChildNodes[i].Name() == "MenuRight")
                            {
                                Audio2D.MenuRight = new AudioCue(node.ChildNodes[i].Value);
                            }
                        }
                    }

                    // Load Engine Sounds
                    if (node.ChildNodes[i].Name() == "Engine")
                    {
                        for (int i = 0; i < node.ChildNodes; i++)
                        {

                            if (node.ChildNodes[i].Name() == "EarthAttack")
                            {
                                Audio3D.earthAttack.cue = new AudioCue(node.ChildNodes[i].Value);
                            }
                            if (node.ChildNodes[i].Name() == "Jump")
                            {
                                Audio3D.jump.cue = new AudioCue(node.ChildNodes[i].Value);
                            }
                            if (node.ChildNodes[i].Name() == "Hit")
                            {
                                Audio3D.smackDownHit.cue = new AudioCue(node.ChildNodes[i].Value);
                            }
                            if (node.ChildNodes[i].Name() == "Walking")
                            {
                                Audio3D.walking.cue = new AudioCue(node.ChildNodes[i].Value);
                            }
                            if (node.ChildNodes[i].Name() == "TerrainMod")
                            {
                                Audio3D.terrainMod.cue = new AudioCue(node.ChildNodes[i].Value);
                            }
                            if (node.ChildNodes[i].Name() == "FireBurst")
                            {
                                Audio3D.fireAttack.cue = new AudioCue(node.ChildNodes[i].Value);
                            }
                            if (node.ChildNodes[i].Name() == "WaterBurst")
                            {
                                Audio3D.waterAttack.cue = new AudioCue(node.ChildNodes[i].Value);
                            }
                            if (node.ChildNodes[i].Name() == "AirBurst")
                            {
                                Audio3D.airAttack.cue = new AudioCue(node.ChildNodes[i].Value);
                            }

                            walkingSoundTimer.Start();
                            terrainModSoundTimer.Start();

                            /// Play's level song.
                            PlayLevelSong(orchestration.Attributes["background"].Value);
                        }
                    }


                }
                catch
                {
                    System.Diagnostics.Debug.WriteLine("Error reading music filename");
                    return;
                }

            }

        }



        /// <summary>
        /// Update XNA audio engine.
        /// See if user has requested to mute or unmute music.
        /// </summary>
        public static void Update()
        {

            // 
            if (Statics.SystemSettings.music && !musicPlaying)
            {
                for (int i = 0; i < cues.Count; i++)
                {
                    cues[i].Resume();
                    musicPlaying = true;
                }

            }
            else if (!Statics.SystemSettings.music && musicPlaying)
            {
                for (int i = 0; i < cues.Count; i++)
                {
                    cues[i].Pause();
                    musicPlaying = false;
                }
            }
            audioEngine.Update();
        }

        #region 3D Sounds
        
        /// <summary>
        /// Sound used in Fire attacks.
        /// Not based on particles, unlike Attack.
        /// </summary>
        /// <param name="pSound">Class containing cues for Player-based sounds.</param>
        /// <param name="emitterPosition">Location of the Attacker.</param>
        /// <param name="listenerPosition">Location of the Listener.</param>
        public static void PlayAudio(AudioCue audioCue)
        {

            //check the distance first!
            if (Vector3.Distance(audioCue.emitterPosition, audioCue.listenerPosition) > SOUND_CUTOFF_DISTANCE)
            {
                return;
            }

            pSound.fireAttack.cue.Apply3D(audioCue.emitterPosition, audioCue.listenerPosition);

            if (!pSound.fireAttack.cue.IsPlaying)
            {
                pSound.fireAttack.cue = AudioProcessor.soundBank.GetCue("FireBurst");
                pSound.fireAttack.cue.Apply3D(pSound.fireAttack.listener, pSound.fireAttack.emitter);
                pSound.fireAttack.cue.Play();
            }

            if (pSound.terrainModSoundTimer.ElapsedMilliseconds > 900)
            {
                pSound.terrainMod.cue = soundBank.GetCue("TerrainMod");
                pSound.terrainMod.cue.Apply3D(pSound.terrainMod.listener, pSound.terrainMod.emitter);
                pSound.terrainMod.cue.Play();

                pSound.terrainModSoundTimer = Stopwatch.StartNew();
            }

        }      


        #endregion



        /// <summary>
        /// Kills all Attack sounds.
        /// </summary>
        /// <param name="pSound">Wrapper contatining attack cues.</param>
        public static void StopAttack(EngineSounds pSound)
        {
            // Stop Sound
            if (pSound.earthAttack.cue != null)
            {
                pSound.earthAttack.cue.Stop(AudioStopOptions.Immediate);
            }
            if (pSound.waterAttack.cue != null)
            {
                pSound.waterAttack.cue.Stop(AudioStopOptions.Immediate);
            }
            if (pSound.airAttack.cue != null)
            {
                pSound.airAttack.cue.Stop(AudioStopOptions.Immediate);
            }
        }




        /// <summary>
        /// Play's a song in the background.
        /// </summary>
        /// <param name="songName">Song Name contained in the loaded SoundBank.</param>
        public static void PlayLevelSong(string songName)
        {
            // Kill everthing
            for (int i = 0; i < cues.Count; i++)
            {
                cues[i].Stop(AudioStopOptions.Immediate);
            }

            // Unload all the cues
            cues.Clear();

            // Start new theme
            Cue playCue = soundBank.GetCue(songName);
            musicPlaying = true;
            cues.Add(playCue);

            if (Statics.SystemSettings.music)
            {
                playCue.Play();
            }
        }

        #region 2D Sounds

        /// <summary>
        /// Base function called by all 2D sounds.
        /// </summary>
        /// <param name="cueName">Name of cue to play</param>
        public static void PlayCue2D(string cueName)
        {
            if (Statics.SystemSettings.soundFX)
            {
                soundBank.PlayCue(cueName);
            }
        }

        #endregion

    }




    #region Audio Cue
    /// <summary>
    /// Contains the neccessary information for 2D and 3D sound processing.
    /// </summary>
    public class AudioCue
    {
        int length;
        int starttime;

        Enums.AudioType audioType;



        // 3D components
        /// <summary>
        /// Cue contatining sound used in 3D audio.
        /// </summary>
        public Cue cue;
        /// <summary>
        /// A sound generator.
        /// </summary>
        public AudioEmitter emitter;
        /// <summary>
        /// A sound receiver.
        /// </summary>
        public AudioListener listener;

        // Create a 2D sound
        public AudioCue(int TrackLength, string TrackName, Enums.AudioType type)
        {

            cue = AudioProcessor.soundBank.GetCue(TrackName);
            length = TrackLength;
            audioType = type;
        }

        // Create a 3D sound
        public AudioCue(int TrackLength, string TrackName, Enums.AudioType type,
            AudioEmitter EmitterObject, AudioListener ListenerObject)
        {
            cue = AudioProcessor.soundBank.GetCue(TrackName);
            length = TrackLength;
            emitter = EmitterObject;
            listener = ListenerObject;
        }


    }

    #endregion
}