/* -*-c++-*- $Id$ */
/**
 * OsgAL - OpenSceneGraph Audio Library
 * Copyright (C) 2004 VRlab, Ume University
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */




#ifndef __OAL_SoundManager_h__
#define __OAL_SoundManager_h__

#include <string>
#include <map>
#include <queue>
#include <functional>
#include <stack>

#include <osg/ref_ptr>

#include "osg/Timer"
#include "osg/Matrix"

#include "osgAL/Export"
#include "osgAL/SoundState"

#include "openalpp/alpp.h"
#include "openalpp/filestream.h"


namespace osgAL 
{


/// A SoundManager handles the sound system.
/*!
  This class initialises the Sound system. It also keeps track of loaded sound samples.
  It is based on the Singleton Design pattern.
  To manage a limited resource of Sound sources (which is usually around 32)
  a schema has to be set up.

  This class initially initializes sound sources and places them into a pool of available sources.
  Whenever someone calls allocateSource() the sound manager tries to free a source
  and return a pointer to it. If there are no sources available it goes through the 
  active sources and tries to find one with a lower priority. If it still fails, an exception is
  thrown.
  Otherwise the found source is returned.

  The allocateSource() has an argument indicating that if the source should be placed in the
  list of active sources. If this argument is false, the caller is responsible to
  call releaseSource() when finished using the source.

  SoundManager also handles SoundStates.
  Whenever pushSoundEvent() is called, a FlyWeight set of SoundStates is inquired for a free SoundState.
  The argument of pushSoundEvent() is copied to the free SoundState and that SoundState
  is then pushed to the queue of waiting SoundStates.
  
    When SoundManager::update() is called, the queue of waiting SoundStates is inquired and for each
    SoundState a Source is allocated.
    When the SoundManager realizes that a SoundState is not playing anymore, it is removed from
    the list of active SoundStates and put back in to the FlyWeight set of available SoundStates.
*/
class OSGAL_EXPORT SoundManager : public osg::Referenced
{
public:

   
  /// Return the singleton object
  static SoundManager* instance( void );

  /*! Deallocates any allocated memory, this method have to be called prior to the end of main()
      OpenAL doesnt like destruction of sources outside the main() function.
  */
  virtual void shutdown();

    /// Return a pointer to the singleton object

  /// Returns true if the SoundManager is initalized
  bool initialized() { return m_initialized; }

  
  /*!
    Push a SoundState to the queue of waiting SoundStates
    When the update method later on is called, this queue is inquired and each
    waiting SoundEvent will be put in the active state and put to a list of active 
    SoundStates with a Source allocated.
    \param state - The state that will be pushed to the waiting queue
    \param priority - The priority of the state, 0 lowest
  */
  bool pushSoundEvent(SoundState *state, unsigned int priority=0);

  /*! 
    Return a pointer to a Sample.
    Each Sample will be stored in a cache with its associated path (if add_to_cache is true)
    Each call to getSample will first look in the cache and try to find the
    path there. If it can be found, it will return to that Sample.
    Otherwise it will be loaded from disk.
  */
  openalpp::Sample* getSample( const std::string& path, bool add_to_cache=true );

  /*! 
    Clear the sample cache with all loaded samples.
  */
  void clearSampleCache(void) {  m_sample_cache.clear(); }


  /*! 
    Return a pointer to a Stream
    Each Stream will be stored in a cache with its associated path.
    Each call to getStream will first look in the cache and try to find the
    path there. If it can be found, it will return to that Stream.
    Otherwise it will be loaded from disk.
  */
  openalpp::Stream* getStream( const std::string& path, bool add_to_cache=true );

  /*! 
    Clear the Stream cache with all loaded streams.
  */
  void clearStreamCache(void) {  m_stream_cache.clear(); }


  /*!
    Return a pointer to the SoundState with the name id.
    \return Null if no matching SoundState can be found.
  */
  SoundState *findSoundState(const std::string& id);
 
  /*!
    Puts the source into the list of available sound sources
  */
  void releaseSource(openalpp::Source *source);

  /// Initializes the SoundManager
  void init(unsigned int num_soundsources, float sound_velocity=343);

  /*!
  */
  void update();

  /// Return a pointer to the listener
  openalpp::Listener *getListener();

  /// Return a pointer to the Sound environment
  openalpp::AudioEnvironment *getEnvironment();

  /*!
    Add a SoundState to the list of existing sound states
  */
  void addSoundState(osgAL::SoundState *state) { m_sound_states[state->getName()] = state; }
  
  /// Removes the sound state from the list of existing soundstates
  bool removeSoundState(const std::string& id);

  /*!
    Removes the sound state from the list of existing soundstates
  */
  bool removeSoundState(osgAL::SoundState *state);


  /*!
    To make it possible to flip left and right ear for the listner this vector specified
    will be multiplied with the up vector everytime the orientation of the listener is calculated
    The default value is (1, 1, 1). Make sure not to set anyone to zero, this will be caught
    and an exception will be thrown.
  */
  void setListenerDirection(const osg::Vec3& dir); 

  const osg::Vec3& getListenerDirection() const { return m_listener_direction; }
  
  /// Set the transformation matrix for the listener
  void setListenerMatrix( const osg::Matrix& matrix);

  /// Return the current listener matrix
  const osg::Matrix &getListenerMatrix( ) const { return m_listener_matrix; }
  
  /*!
    Tries to find an available sound Source
    \param if mutual_use then the source is registrated in the soundmanager as a source that can be
    reused by a call to getSource with higher priority.
    If on the other hand mutual_use is false, then it is allocated 
    \return Pointer to an available sound Source
  */
  openalpp::Source *allocateSource(unsigned int priority, bool mutual_use=true) { return getSource(priority, mutual_use); }


  /// Set the maximum velocity used in doppler calculation
  void setMaxVelocity(float vel) { m_max_velocity = (float)fabs(vel); }

  /// Returns the maximum velocity used in doppler calculation
  float getMaxVelocity() const { return m_max_velocity; }
  
  /*!
    Returns the number of free and available SoundSoures for allocation.
    Should be between 0 .. getNumSources()
  */
  unsigned int getNumAvailableSources() { return m_available_soundsources.size(); }
  
  /*!
    Returns the number of initialized SoundSources.
    Should be between 0..
  */
  unsigned int getNumSources() { return m_soundsources.size(); }
  
  /*!
    Returns the number of SoundSources currently in use.
    Should be between 0..getNumSources()
  */
  unsigned int getNumActiveSources() { return m_active_soundsources.size(); }
  
  /// Set if the velocity is clamped (using the MaxVelocity attribute)
  void setClampVelocity(bool c) { m_clamp_velocity = c; }

  /// Get true if the velocity is clamped (using the MaxVelocity attribute)
  bool getClampVelocity() { return m_clamp_velocity; }

  /// Get const true if the velocity is clamped (using the MaxVelocity attribute)
  const bool getClampVelocity() const { return m_clamp_velocity; }
 
  /// Set the update frequency for both sources and listener, to update pos, dir and occlusions
  void setUpdateFrequency( float frequency ) { 
	if(frequency < 0) m_update_frequency = 1/100.0;
	else m_update_frequency = frequency;
  }
 
  /// Get the update frequency for both sources and listener, to update pos, dir and occlusions
  float getUpdateFrequency() { return m_update_frequency; }

  /// Get const the update frequency for both sources and listener, to update pos, dir and occlusions
  const float getUpdateFrequency() const { return m_update_frequency; }  

private:
  openalpp::Source *getSource(unsigned int priority, bool registrate_as_active=true, int depth=0);

  /// Destructor
	~SoundManager();

  /// Default Constructor
  SoundManager( void );


  /// Class that handles all the soundstates. See FlyWeight Design pattern
  class SoundStateFlyWeight : public osg::Referenced {
  public:
    SoundStateFlyWeight(unsigned int no_states);
    virtual ~SoundStateFlyWeight();

    SoundState *getSoundState(SoundState *state);
    void releaseSoundState(SoundState *state);
	void clean() { m_sound_states.resize(0); }
  private:

    std::vector< osg::ref_ptr<SoundState> > m_sound_states;
    std::stack< SoundState *> m_available_states;
  };

  osg::ref_ptr<SoundStateFlyWeight> m_sound_state_FlyWeight;

  void resetSource(openalpp::Source *source);

  typedef std::map<std::string, openalpp::ref_ptr<openalpp::Sample> > SampleMap;
  typedef SampleMap::iterator SampleMapIterator;
  typedef SampleMap::value_type SampleMapValType;

  SampleMap m_sample_cache;

  typedef std::map<std::string, openalpp::ref_ptr<openalpp::FileStream> > StreamMap;
  typedef StreamMap::iterator StreamMapIterator;
  typedef StreamMap::value_type StreamMapValType;

  StreamMap m_stream_cache;

  openalpp::ref_ptr<openalpp::Listener> m_listener;
  openalpp::ref_ptr<openalpp::AudioEnvironment> m_sound_environment;


  typedef std::vector<openalpp::ref_ptr<openalpp::Source> > SourceVector;
  typedef std::vector<std::pair< unsigned int, openalpp::ref_ptr<openalpp::Source> > > ActiveSourceVector;
  ActiveSourceVector m_active_soundsources; 
  SourceVector m_soundsources; 

  // A matrix containing the position and orientation of the listener
  osg::Matrix m_listener_matrix;  
  
  SourceVector m_available_soundsources; 
  
  typedef std::map<std::string, osg::ref_ptr<SoundState> > SoundStateMap;
  SoundStateMap m_sound_states;

  class SoundStateQueueItem {
  public:
    SoundStateQueueItem(unsigned int prio, SoundState *state) : m_prio(prio), m_state(state) {}
    bool operator <(const SoundStateQueueItem& item) const { return  m_prio <  item.m_prio; }
    bool operator ==(const SoundStateQueueItem& item) { return  m_prio == item.m_prio; }
    SoundState *getState() const { return m_state; }
    unsigned int getPriority() { return m_prio; }
  private:
    unsigned int m_prio;
    SoundState *m_state;
  };
  
  typedef std::priority_queue<SoundStateQueueItem> SoundStateQueue;
  SoundStateQueue m_sound_state_queue;
 
  typedef std::vector<osg::ref_ptr<SoundState> > SoundStateVector;
  SoundStateVector m_active_sound_states;

  bool m_initialized;

  osg::Vec3 m_last_pos;
  float m_max_velocity;
  osg::Timer m_timer;
  osg::Timer_t m_last_tick;
  bool m_first_run;
  bool m_clamp_velocity;
  float m_update_frequency;
  osg::Vec3 m_listener_direction;

};


inline openalpp::Listener *SoundManager::getListener()
{ 
  if (!m_initialized) {
    throw std::runtime_error("SoundManager::getListener(): No sound system inialized");
    return 0L;
  }
    return m_listener.get(); 
}

inline openalpp::AudioEnvironment *SoundManager::getEnvironment() 
{ 
  if (!m_initialized) {
    throw std::runtime_error("SoundManager::getListener(): Soundsystem is not inialized");
    return 0L;
  }
  return m_sound_environment.get(); 
}

} // namespace osgAL

#define g_SoundManager osgAL::SoundManager::instance()
#endif


/*------------------------------------------
* $Source$
* $Revision$ 
* $Date$
* $Author$ 
  $Locker$

  Author: Anders Backman
  VRlab, Ume University, 2004
 
* $Log$
* Revision 1.2  2006/07/24 15:31:10  loic
* autotools
*
* Revision 1.1.1.3  2005/09/07 16:11:36  loic
* upstream update
*
* Revision 1.7  2005/05/27 07:21:35  vr-anders
*   Alberto Jaspe (videaLAB / University of La Corua)
*   - Several miscelaneus bugfixes.
*   - Added support for reading/writing from/to osg files.
*   - Important bugfixes in doppler issues.
*   - Using just one update frequency for listener and sources, in SoundManager.
*   - Using a state for clamp function for max velocites in both listener and sources,
*     disabled by default.
*   - Replaced the FilePath Manager for the osgDB support.
*   - Added a new example called osgalviewer, that acts like osgviewer, but with some
*     features oriented to treat with Sound Nodes.
*   - Compiled and tested with OSG 0.9.9.
*
* Revision 1.6  2005/01/31 10:49:53  vrlab
* *** empty log message ***
*
* Revision 1.5  2004/11/11 07:47:35  andersb
* Added a simple occlude method for occluding soundsources against geometry
*
* Revision 1.4  2004/04/20 12:26:03  andersb
* Added SoundRoot
*
* Revision 1.3  2004/03/05 09:42:30  andersb
* *** empty log message ***
*
* Revision 1.2  2004/03/03 07:50:49  andersb
* *** empty log message ***
*
* Revision 1.1.1.1  2004/03/02 07:20:58  andersb
* Initial Version of the osgAL library
*
*
--------------------------------------------*/