/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "hsTypes.h"
#include "hsUtils.h"
#include "hsResMgr.h"
#include "hsTimer.h"
#include "hsGeometry3.h"
#include "hsColorRGBA.h"
#include "plProfile.h"
#include "plgDispatch.h"

#include "plAudioSystem.h"
#include "plSound.h"
#include "plWin32Sound.h"

#include "../plAudioCore/plSoundBuffer.h"
#include "../plDrawable/plDrawableGenerator.h"
#include "../pnMessage/plRefMsg.h"
#include "../pnMessage/plTimeMsg.h"
#include "../pnMessage/plAudioSysMsg.h"
#include "../pnMessage/plSoundMsg.h"
#include "../plMessage/plListenerMsg.h"
#include "../plIntersect/plSoftVolume.h"
#include "../plStatusLog/plStatusLog.h"
#include "../plPipeline/plPlates.h"
#include "../pnKeyedObject/plKey.h"
#include "../pnNetCommon/plSDLTypes.h"
#include "../plAvatar/plScalarChannel.h"
#include "../plAvatar/plAGModifier.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../pnSceneObject/plAudioInterface.h"

plProfile_CreateCounterNoReset( "Loaded", "Sound", SoundNumLoaded );
plProfile_CreateCounterNoReset( "Waiting to Die", "Sound", WaitingToDie );
plProfile_CreateAsynchTimer( "Sound Load Time", "Sound", SoundLoadTime );

plGraphPlate	*plSound::fDebugPlate = nil;
plSound			*plSound::fCurrDebugPlateSound = nil;
hsBool			plSound::fLoadOnDemandFlag = true;
hsBool			plSound::fLoadFromDiskOnDemand = true;
unsigned		plSound::fIncidentalsPlaying = 0;

plSound::plSound() :
fPlaying(false),
fActive(false),
fTime(0),
fMaxFalloff(0),
fMinFalloff(0),
fCurrVolume(0.f),
fOuterVol(0),
fOuterCone(360),
fInnerCone(360),
fLength(0.0f),
fDesiredVol(0.f),
fFading(false),
fRegisteredForTime(false),
fMuted(true),
fFadedVolume(0.f),
fSoftRegion(nil),
fSoftOcclusionRegion(nil),
fSoftVolume(0.f),
fCurrFadeParams(nil),
fRegistered(false),
fDistAttenuation(0.f),
fProperties(0),
fNotHighEnoughPriority(false),
fVirtualStartTime(0),
fOwningSceneObject(nil),
fPriority(0),
fType(plSound::kSoundFX),
fQueued(false),
fLoading(false),
fSynchedStartTimeSec(0),
fMaxVolume(0),
fFreeData(false)
{
	plProfile_Inc( SoundNumLoaded );
	f3DPosition.Set( 0.f, 0.f, 0.f );
	f3DVelocity.Set( 0.f, 0.f, 0.f );
	fDataBuffer = nil;
	fDataBufferKey = nil;
	fPlayOnReactivate = false;
	fDataBufferLoaded = false;
}

plSound::~plSound()
{
	IStopFade( true );
	plProfile_Dec( SoundNumLoaded );
}

void plSound::IPrintDbgMessage( const char *msg, hsBool isError )
{
	static plStatusLog	*ourLog = nil;

	// Print to our log file (create it if necessary)
	if( ourLog == nil )
	{
//		ourLog = plStatusLogMgr::GetInstance().CreateStatusLog( 15, 
//				"audio.log", plStatusLog::kFilledBackground | plStatusLog::kDeleteForMe | plStatusLog::kAlignToTop );
	}

	if( isError )
//		ourLog->AddLineF( plStatusLog::kRed, "ERROR: %s (%s)", msg, GetKey() ? GetKeyName() : "unkeyed" );
		ourLog->AddLineS( "audio.log", plStatusLog::kRed, "ERROR: %s (%s)", msg, GetKey() ? GetKeyName() : "unkeyed" );
	else
//		ourLog->AddLineF( "%s (%s)", msg, GetKey() ? GetKeyName() : "unkeyed" );
		ourLog->AddLineS( "audio.log", "%s (%s)", msg, GetKey() ? GetKeyName() : "unkeyed" );
}

///////////////////////////////////////////////////////////
//	Called to send more values to the debug plate, assuming this is the right
//	sound. Should be called every time any of the values change, which means
//	the best place is inside ISetActualVolume(). Since that's a pure virtual,
//	it makes the placement of the call a bit annoying, but oh well.
void plSound::IUpdateDebugPlate( void )
{
	if( this == fCurrDebugPlateSound )
	{
		if( fDebugPlate == nil )
		{
			plPlateManager::Instance().CreateGraphPlate( &fDebugPlate );
			fDebugPlate->SetSize( 0.50, 0.25 );
			fDebugPlate->SetPosition( -0.5, 0 );
			fDebugPlate->SetDataRange( 0, 100, 100 );
			fDebugPlate->SetColors( 0x80202000 );
			fDebugPlate->SetTitle( (char *)GetKeyName() );		// Bleah
			fDebugPlate->SetLabelText( "Desired", "Curr", "Soft", "Dist" );
		}

		fDebugPlate->SetVisible( true );
		fDebugPlate->AddData( (Int32)( fDesiredVol * 100.f ), 
							  (Int32)( fCurrVolume * 100.f ),
							  (Int32)( fSoftVolume * 100.f ),
							  (Int32)( fDistAttenuation * 100.f ) );
	}
}

void plSound::SetCurrDebugPlate( const plKey soundKey )
{
	if( soundKey == nil )
	{
		fCurrDebugPlateSound = nil;
		if( fDebugPlate != nil )
			fDebugPlate->SetVisible( false );
	}
	else
	{
		fCurrDebugPlateSound = plSound::ConvertNoRef( soundKey->GetObjectPtr() );
		if( fDebugPlate != nil )
		{
			fDebugPlate->ClearData();
			fDebugPlate->SetVisible( true );
			fDebugPlate->SetTitle( (char *)fCurrDebugPlateSound->GetKeyName() );		// Bleah
		}
	}
}

/////////////////////////////////////////////////////////////////////
//	We don't keep track of the current time we should be at, but rather the
//	time we started at. Since we're calling SetTime(), we should adjust the
//	start time to be accurate for the time we want to be at now. Note: we
//	don't actually move the buffer position unless it's loaded, since we
//	don't want to force a load on a buffer just from a SetTime() call.
void plSound::SetTime( double t )
{
	fVirtualStartTime = hsTimer::GetSysSeconds() - t;

	if( IActuallyLoaded() )
		ISetActualTime( t );
}

// Support for Fast forward responder
void plSound::FastForwardPlay()
{
	if(fProperties & kPropLooping)
	{
		Play();
	}
}

void plSound::FastForwardToggle()
{
	if(fPlaying == true)
	{
		Stop();
		return;
	}
	FastForwardPlay();
}

////////////////////////////////////////////////////////////////////////
//	Our basic play function. Marks the sound as playing, and if we're actually
//	allowed to play, will actually start the sound playing as well.
void plSound::Play()
{	
	if(fLoading)	// if we are loading there is no reason to do this. Play will be called, by Update(), once the data is loaded and this floag is set to false
		return;

	if( !fActive )
	{
		// We're not active, so we can't play, but mark to make sure we'll play once we do get activated
		fPlayOnReactivate = true;
		return;
	}

	fPlaying = true;

	if(IPreLoadBuffer(true) == plSoundBuffer::kPending)
	{
		return;
	}

	fVirtualStartTime = hsTimer::GetSysSeconds();	// When we "started", even if we really don't start

	// if the sound system is not active do a fake play so callbacks get sent
	if(!plgAudioSys::Active())
	{
		// Do the (fake) actual play
		IActuallyPlay();
	}
	if( IWillBeAbleToPlay() )
	{
		IRefreshParams();

		if( fFadeInParams.fLengthInSecs > 0 )
		{
			IStartFade( &fFadeInParams);
		}
		else
		{
			// we're NOT fading!!!!
			if( fFading )
				IStopFade();
			 SetVolume( fDesiredVol );
		}

		// Do the actual play
		IActuallyPlay();
	}
}

void plSound::SynchedPlay(unsigned bytes )
{
	if( fFading )
		IStopFade();
	if(fLoading)	// the sound is loading, it will be played when loading is finished
		return;

	if( !fActive )
	{
		// We're not active, so we can't play, but mark to make sure we'll play once we do get activated
		fPlayOnReactivate = true;
		return;
	}

	// Mark as playing, since we'll be calling ITryPlay() directly
	fPlaying = true;
	fPlayOnReactivate = false;

	if( IWillBeAbleToPlay() )
	{
		SetStartPos(bytes);
		Play();
	}
}

/////////////////////////////////////////////////////////////////
//	Used for synching play state. The state only knows that we're playing
//	and what time we started at, so we use that to compute what time we should
//	be at and update. Note that we also set our virtual start time to what
//	we're given, NOT the current time, 'cause, well, duh, that should be our
//	start time!
//	So think of it as "Play() but act as if you started at *this* time"...
void plSound::SynchedPlay( hsScalar virtualStartTime )
{
	if( fFading )
		IStopFade();

	ISynchedPlay( virtualStartTime );
}

////////////////////////////////////////////////////////////////
//	Only want to do the fade hack when somebody outside synch()s us.
void plSound::ISynchedPlay( double virtualStartTime )
{	
	if(fLoading)	// the sound is loading, it will be played when loading is finished
		return;

	// Store our start time
	fVirtualStartTime = virtualStartTime;

	if( !fActive )
	{
		// We're not active, so we can't play, but mark to make sure we'll play once we do get activated
		fPlayOnReactivate = true;
		return;
	}

	// Mark as playing, since we'll be calling ITryPlay() directly
	fPlaying = true;
	fPlayOnReactivate = false;

	// Do da synch, which will start us playing
	if( IWillBeAbleToPlay() )
	{
		ISynchToStartTime();
	}
}

///////////////////////////////////////////////////////////
//	Takes the virtual start time and sets us to the real time we should be at,
//	then starts us playing via ITryPlay().
void plSound::ISynchToStartTime( void )
{
	if( !plgAudioSys::Active() )
		return;

	// We don't want to do this until we're actually loaded, since that's when we'll know our
	// REAL length (thanks to the inaccuracies of WMA compression)
//	LoadSound( IsPropertySet( kPropIs3DSound ) );
	// Haha, the GetLength() call will do this for us

	// Calculate what time we should be at
	double deltaTime = hsTimer::GetSysSeconds() - fVirtualStartTime;
	double length = GetLength();

	if( deltaTime > length || deltaTime < 0 )
	{
		// Hmm, our time went past the length of sound, so handle that
		if( IsPropertySet( kPropLooping ) )	
		{
			if( length <= 0 )
				deltaTime = 0;		// Error, attempt to recover
			else if( deltaTime < 0 )
			{
				int numWholeParts = (int)( -deltaTime / length );
				deltaTime += length * ( numWholeParts + 1 );
			}
			else
			{
				int numWholeParts = (int)( deltaTime / length );
				deltaTime -= length * (double)numWholeParts;
			}

			//ISetActualTime( deltaTime );
			Play();
		}
		else
			// We already played and stopped virtually, so really mark us as stopped
			Stop();
	}
	else
	{
		// Easy 'nuf...
		//ISetActualTime( deltaTime );
		Play();
	}
} 

void plSound::SetPosition(const hsPoint3 pos)
{
	f3DPosition = pos;
}

void plSound::SetVelocity(const hsVector3 vel)
{
	f3DVelocity = vel;
}

hsPoint3 plSound::GetPosition( void ) const
{
	return f3DPosition;
}

hsVector3 plSound::GetVelocity( void ) const
{
	return f3DVelocity;
}

void plSound::SetMin(const int m)
{
	fMinFalloff = m;
}

void plSound::SetMax(const int m)
{
	fMaxFalloff = m;
}

void plSound::SetOuterVolume(const int v)
{
	fOuterVol = v;
}

void plSound::SetConeOrientation( hsScalar x, hsScalar y, hsScalar z )
{
	fConeOrientation.Set( x, y, z );
}

void plSound::SetConeAngles( int inner, int outer )
{
	fOuterCone = outer;
	fInnerCone = inner;
}

int plSound::GetMin() const
{
	return fMinFalloff;
}

int plSound::GetMax() const
{
	return fMaxFalloff;
}

void plSound::SetVolume(const float v)
{
	fDesiredVol = v;

	if( !fMuted && !fFading )
		fCurrVolume = fDesiredVol;

	RefreshVolume();
}

void plSound::RefreshVolume( void )
{
	this->ISetActualVolume( fCurrVolume );
}

void plSound::SetMuted( hsBool muted )
{
	if( muted != fMuted )
	{
		fMuted = muted;
		if( fMuted )
			fCurrVolume = 0.f;
		else if( !fFading )
			fCurrVolume = fDesiredVol;

		RefreshVolume();
	}
}

void plSound::IRefreshParams( void )
{
	SetMax( fMaxFalloff );
	SetMin( fMinFalloff );
	SetOuterVolume( fOuterVol );
	SetConeAngles( fInnerCone, fOuterCone );
	SetConeOrientation( fConeOrientation.fX, fConeOrientation.fY, fConeOrientation.fZ);
	SetPosition( f3DPosition );
	SetVelocity( f3DVelocity );
}

////////////////////////////////////////////////////////////////////////
//	The public interface to stopping, which also synchs the state with the
//	server.
void plSound::Stop( void )
{
	fPlaying = false;

	// if the audio data is loading while stop is called we need to make sure the sounds doesn't play, and the data is unloaded.
	fPlayOnReactivate = false;	
	fFreeData = true;
	
	// Do we have an ending fade?
	if( fFadeOutParams.fLengthInSecs > 0 && !plgAudioSys::IsRestarting() )
	{
		IStartFade( &fFadeOutParams );
	}
	else
	{
		if( fFading )
			IStopFade();

		fCurrVolume = 0.f;
		ISetActualVolume( fCurrVolume );
		IActuallyStop();
	}
	if(fPlayWhenLoaded)
	{
		fPlayWhenLoaded = false;
	}
}

void plSound::IActuallyStop( void )
{
	if( fLoadOnDemandFlag && !IsPropertySet( kPropDisableLOD ) && !IsPropertySet( kPropLoadOnlyOnCall ) )
	{
		// If we're loading on demand, we want to unload on stop
		IFreeBuffers();
	}
}

void plSound::Update() 
{
	if(fLoading)
	{		
		plSoundBuffer::ELoadReturnVal retVal = IPreLoadBuffer(fPlayWhenLoaded);
		
		if(retVal == plSoundBuffer::kError)
		{
			fLoading = false;
			fPlayWhenLoaded = false;
		}
		if(retVal == plSoundBuffer::kSuccess)
		{
			fLoading = false;
			if(fPlayWhenLoaded)
				Play();
			fPlayWhenLoaded = false;

			// ensure the sound data is released if the sound object was stopped while the audio data was being loaded.
			if(fFreeData)
			{
				fFreeData = false;
				FreeSoundData();
			}
		}
	}
}

hsScalar plSound::IGetChannelVolume( void ) const
{
	hsScalar channelVol = plgAudioSys::GetChannelVolume( (plgAudioSys::ASChannel)fType );

	// if not using hardware acceleration then apply 2D/3D bias to non 3D sounds
	if( !plgAudioSys::Hardware() && !IsPropertySet( kPropIs3DSound ) )
		channelVol *= plgAudioSys::Get2D3Dbias();

	if( IsPropertySet( kPropDontFade ) )
		return channelVol;
	
	return channelVol * plgAudioSys::GetGlobalFadeVolume();
}

void plSound::IStartFade( plFadeParams *params, hsScalar offsetIntoFade )
{
	fFading = true;

	if( params == &fFadeOutParams )
	{
		fFadeOutParams.fVolStart = fCurrVolume;
		fFadeOutParams.fVolEnd = fFadedVolume;
		fCurrFadeParams = &fFadeOutParams;
	}
	else if( params == &fFadeInParams )
	{
		fFadeInParams.fVolStart = fCurrVolume;	// Hopefully, we got to fFadedVolume, but maybe not
		fFadeInParams.fVolEnd = fDesiredVol;
		fCurrFadeParams = &fFadeInParams;
		plStatusLog::AddLineS("audio.log", "Fading in %s", GetKeyName());
	}
	else
		fCurrFadeParams = params;

	fCurrFadeParams->fCurrTime = offsetIntoFade;
	ISetActualVolume( fCurrFadeParams->InterpValue() );

	if( !fRegisteredForTime )
	{
		plgDispatch::Dispatch()->RegisterForExactType( plTimeMsg::Index(), GetKey() );
		fRegisteredForTime = true;
	}
}

void plSound::IStopFade( hsBool shuttingDown, hsBool SetVolEnd)
{
	if( fCurrFadeParams != nil )
	{
		if( fCurrFadeParams == &fCoolSoftVolumeTrickParams )
		{
			plProfile_Dec( WaitingToDie );
		}

		// This can cause problems if we've exited a soft region and are doing a soft volume fade.
		// If the camera pops back into the region of this particular sound this will cause the soft volume to be zero, 
		// therefore not allowing the sound to play until the listener moves again(triggering another softsound update).
		// So if this function is called from UpdateSoftSounds this will not be performed
		if(SetVolEnd)
		{
			if( fCurrFadeParams->fFadeSoftVol )
				fSoftVolume = fCurrFadeParams->fVolEnd;
			else
				fCurrVolume = fCurrFadeParams->fVolEnd;
		}

		if( !shuttingDown )
			ISetActualVolume( fCurrVolume );

		fCurrFadeParams->fCurrTime = -1.f;
	}

	fFading = false;
	fCurrFadeParams = nil;

	// Fade done, unregister for time message
	if( fRegisteredForTime )
	{
		plgDispatch::Dispatch()->UnRegisterForExactType( plTimeMsg::Index(), GetKey() );
		fRegisteredForTime = false;
	}
}

hsBool plSound::MsgReceive( plMessage* pMsg )
{
	plTimeMsg	*time = plTimeMsg::ConvertNoRef( pMsg );
	if( time != nil )
	{
		/// Time message for handling fade ins/outs
		if( fCurrFadeParams == nil )
			return true;

		fCurrFadeParams->fCurrTime += time->DelSeconds();

		if( fCurrFadeParams->fCurrTime >= fCurrFadeParams->fLengthInSecs )
		{
			if( fCurrFadeParams->fFadeSoftVol )
				fSoftVolume = fCurrFadeParams->fVolEnd;
			else
				fCurrVolume = fCurrFadeParams->fVolEnd;
			ISetActualVolume( fCurrVolume );
			fCurrFadeParams->fCurrTime = -1.f;
						
			// Fade done, unregister for time message
			if( fRegisteredForTime )
			{
				plgDispatch::Dispatch()->UnRegisterForExactType( plTimeMsg::Index(), GetKey() );
				fRegisteredForTime = false;
			}

			// Note: if we're done, and we were fading out, we need to STOP
			if( fCurrFadeParams->fStopWhenDone )
			{
				// REALLY STOP
				IActuallyStop();
			}

			if( fCurrFadeParams == &fCoolSoftVolumeTrickParams )
			{
				plProfile_Dec( WaitingToDie );
			}

			// Done with this one!
			fCurrFadeParams = nil;
			fFading = false;
		}	
		else
		{
			// Gotta interp
			if( fCurrFadeParams->fFadeSoftVol )
				fSoftVolume = fCurrFadeParams->InterpValue();
			else
				fCurrVolume = fCurrFadeParams->InterpValue();
						
			ISetActualVolume( fCurrVolume );
		}

		return true;
	}

	plGenRefMsg* refMsg = plGenRefMsg::ConvertNoRef( pMsg );
	if( refMsg )
	{
		if( refMsg->fType == kRefSoftVolume )
		{
			if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
			{
				ISetSoftRegion( plSoftVolume::ConvertNoRef(refMsg->GetRef()) );
				return true;
			}
			else if( refMsg->GetContext() & (plRefMsg::kOnRemove | plRefMsg::kOnDestroy) )
			{
				ISetSoftRegion( nil );
				return true;
			}
		}
		else if( refMsg->fType == kRefSoftOcclusionRegion )
		{
			if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
			{
				ISetSoftOcclusionRegion( plSoftVolume::ConvertNoRef( refMsg->GetRef() ) );
				return true;
			}
			else if( refMsg->GetContext() & (plRefMsg::kOnRemove | plRefMsg::kOnDestroy) )
			{
				ISetSoftOcclusionRegion( nil );
				return true;
			}
		}
		else if( refMsg->fType == kRefDataBuffer )
		{
			if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
			{
				fDataBuffer = plSoundBuffer::ConvertNoRef( refMsg->GetRef() );
				SetLength( fDataBuffer->GetDataLengthInSecs() );
			}
			else
				fDataBuffer = nil;

			return true;
		}
		else if( refMsg->fType == kRefParentSceneObject )
		{
			if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
				fOwningSceneObject = plSceneObject::ConvertNoRef( refMsg->GetRef() );
			else
				fOwningSceneObject = nil;

			return true;
		}
	}

	plSoundMsg *pSoundMsg = plSoundMsg::ConvertNoRef( pMsg );
	if( pSoundMsg != nil )
	{	
		if( pSoundMsg->Cmd( plSoundMsg::kAddCallbacks ) )
		{
			AddCallbacks( pSoundMsg );
			return true;
		}
		else if( pSoundMsg->Cmd( plSoundMsg::kRemoveCallbacks ) )
		{
			RemoveCallbacks( pSoundMsg );
			return true;
		}
		return false;
	}

	plListenerMsg *listenMsg = plListenerMsg::ConvertNoRef( pMsg );
	if( listenMsg != nil )
	{
		if( fSoftOcclusionRegion != nil )
		{
			// The EAX settings have 0 as the start value and 1 as the end, and since start
			// translates to "inside the soft region", it's reversed of what the region gives us
			fEAXSettings.SetOcclusionSoftValue( 1.f - fSoftOcclusionRegion->GetListenerStrength() );
			IRefreshEAXSettings();
		}
		return true;
	}

	return plSynchedObject::MsgReceive( pMsg );
}

void plSound::ForceLoad()
{
	if( !IsPropertySet( kPropLoadOnlyOnCall ) )
		return;

	LoadSound( IsPropertySet( kPropIs3DSound ) );
}

void plSound::ForceUnload( void )
{
	if( !IsPropertySet( kPropLoadOnlyOnCall ) )
		return;

	Stop();
	IFreeBuffers();
}

bool plSound::ILoadDataBuffer( void )
{
	if(!fDataBufferLoaded)
	{
		plSoundBuffer *buffer = (plSoundBuffer *)fDataBufferKey->RefObject();
		if(!buffer)
		{
			hsAssert(false, "unable to load sound buffer");
			plStatusLog::AddLineS("audio.log", "Unable to load sound buffer: %s", GetKeyName());
			return false;
		}
		SetLength( buffer->GetDataLengthInSecs() );
		fDataBufferLoaded = true;
	}
	return true;
}

void plSound::FreeSoundData() 
{
	if(!fDataBufferKey) return;	// for plugins
	plSoundBuffer *buffer = (plSoundBuffer *) fDataBufferKey->ObjectIsLoaded();
	if(buffer)
	{
		buffer->UnLoad();
	}
}

void plSound::IUnloadDataBuffer( void )
{
	if(fDataBufferLoaded)
	{
		fDataBufferLoaded = false;
		fDataBufferKey->UnRefObject();
	}
}

/////////////////////////////////////////////////////////////////////////
// calling preload will cause the sound to play once loaded
plSoundBuffer::ELoadReturnVal plSound::IPreLoadBuffer( hsBool playWhenLoaded, hsBool isIncidental /* = false */ )
{
	if(!ILoadDataBuffer())
	{
		return plSoundBuffer::kError;
	}

	plSoundBuffer *buffer = (plSoundBuffer *)fDataBufferKey->ObjectIsLoaded();

	if(buffer && buffer->IsValid() )
	{
		plProfile_BeginTiming( SoundLoadTime );
		plSoundBuffer::ELoadReturnVal retVal = buffer->AsyncLoad(buffer->HasFlag(plSoundBuffer::kStreamCompressed) ? plAudioFileReader::kStreamNative : plAudioFileReader::kStreamWAV);
		if(retVal == plSoundBuffer::kPending)
		{
			fPlayWhenLoaded = playWhenLoaded;
			fLoading = true;
		}
		
		plProfile_EndTiming( SoundLoadTime );
	
		return retVal;
	}
	else
	{
		return plSoundBuffer::kError;
	}
}

const char *plSound::GetFileName( void ) const
{
	if(fDataBufferKey->ObjectIsLoaded())
	{
		return ((plSoundBuffer *)fDataBufferKey->ObjectIsLoaded())->GetFileName();
	}

	return nil;
}

/////////////////////////////////////////////////////////////////////////
//	WARNING: to do this right, we have to load the data buffer in, which could
//	force an early load of the sound if you're just calling this on a whim. So
//	it's best to call this right before you're going to load it anyway (or
//	when it's already loaded).
//	Note that if we already set the length (like at export time), we never need
//	to load the sound, so the optimization at export time is all ready to plug-
//	and-play...
double plSound::GetLength( void )
{
	if( ( (double)fLength == 0.f ) )
		ILoadDataBuffer();

	return fLength;
}

void plSound::ISetSoftRegion( plSoftVolume *region )
{
	/// We're either registering or unregistering
	if( fSoftRegion == nil && region != nil )
		RegisterOnAudioSys();
	else if( fSoftRegion != nil && region == nil )
		UnregisterOnAudioSys();

	fSoftRegion = region;
	fSoftVolume = 0.f;		// Set to zero until we can get our processing call
}

void plSound::ISetSoftOcclusionRegion( plSoftVolume *region )
{
	/// We're either registering or unregistering for listener messages
	if( fSoftOcclusionRegion == nil && region != nil )
	{
		plgDispatch::Dispatch()->RegisterForExactType( plListenerMsg::Index(), GetKey() );
	}
	else if( fSoftOcclusionRegion != nil && region == nil )
	{
		plgDispatch::Dispatch()->UnRegisterForExactType( plListenerMsg::Index(), GetKey() );
	}

	fSoftOcclusionRegion = region;
}

/////////////////////////////////////////////////////////////////////////
//	This function calculates our new softVolume value. Used both to update the
//	said value and so the audio system can rank us in importance.
hsScalar plSound::CalcSoftVolume( hsBool enable, hsScalar distToListenerSquared )
{
	// Do distance-based attenuation ourselves
#if MCN_HACK_OUR_ATTEN
	if( IsPropertySet( kPropIs3DSound ) )
	{
		hsScalar	minDist = (hsScalar)GetMin();
		if( distToListenerSquared <= minDist * minDist )
		{
			fDistAttenuation = 1.f;
		}
		else
		{
			hsScalar	maxDist = (hsScalar)GetMax();
			if( distToListenerSquared >= maxDist * maxDist )
			{
				fDistAttenuation = 0.f;
			}
			else
			{
				hsScalar d = (hsScalar)sqrt( distToListenerSquared );
				fDistAttenuation = minDist / d;

				// The following line ramps it to 0 at the maxDistance. Kinda klunky, but good for now I guess...
//				fDistAttenuation *= 1.f - ( 1.f / ( maxDist - minDist ) ) * ( d - minDist );
			}
		}
	}
	else
		fDistAttenuation = 1.f;
#endif
	// At the last 50% of our distance attenuation (squared, so it really is farther than that), 
	// ramp down to 0 so we don't get annoying popping when we stop stuff
	if( IsPropertySet( kPropIs3DSound ) )
	{
		hsScalar	maxDistSquared = (hsScalar)( GetMax() * GetMax() );
		hsScalar	distToStartSquared = (hsScalar)(maxDistSquared * 0.50);

		if( maxDistSquared < 0.f )	// Happens when the max distance is REALLY big
		{
			maxDistSquared = distToListenerSquared + 1.f;	// :)
			distToStartSquared = maxDistSquared;
		}

		if( distToListenerSquared > maxDistSquared )
			fDistAttenuation = 0.f;
		else if( distToListenerSquared > distToStartSquared )
			fDistAttenuation = ( maxDistSquared - distToListenerSquared ) / ( maxDistSquared - distToStartSquared );
		else
			fDistAttenuation = 1.f;

		fDistToListenerSquared = distToListenerSquared;
	}
	else
	{
		fDistAttenuation = 1.f;
		fDistToListenerSquared = 0.f;
	}

	// Attenuate based on our soft region, if we have one
	if( !enable )
		// We apparently don't know jack. Let the audioSystem's decision rule
		fSoftVolume = 0.f;
	else if( fSoftRegion != nil )
		fSoftVolume = fSoftRegion->GetListenerStrength();
	else
		fSoftVolume = 1.f;

	return fSoftVolume;
}

/////////////////////////////////////////////////////////////////////////
//	Wee function for the audio system. This basically returns the effective
//	current volume of this sound. Useful for doing things like ranking all
//	sounds based on volume.
hsScalar plSound::GetVolumeRank( void )
{
	if( !IsPlaying() && !this->IActuallyPlaying() )
		return 0.f;

	hsScalar	rank = fSoftVolume * fDesiredVol;

	if( IsPropertySet( kPropIs3DSound ) )
	{
		hsScalar minDistSquared = (hsScalar)( GetMin() * GetMin() );
		hsScalar maxDistSquared = (hsScalar) (GetMax() * GetMax());
		hsPoint3 listenerPos = plgAudioSys::Sys()->GetCurrListenerPos();
		if( fDistToListenerSquared > minDistSquared )
		{
			hsScalar diff = maxDistSquared - minDistSquared;
			rank *= fabs((fDistToListenerSquared - maxDistSquared)) / diff;  
		}
	}

	return rank;
}

/////////////////////////////////////////////////////////////////////////
//	Tests to see whether, if we try to play this sound now, it'll actually
//	be able to play. Takes into account whether the sound is within range
//	of the listener and the current soft region value.
hsBool plSound::IWillBeAbleToPlay( void )
{
	if( fSoftVolume == 0.f )
		return false;

	return IsWithinRange( plgAudioSys::Sys()->GetCurrListenerPos(), nil );
}

/////////////////////////////////////////////////////////////////////////
//	Tests to see whether this sound is within range of the position given,
//	ignoring soft volumes.
hsBool plSound::IsWithinRange( const hsPoint3 &listenerPos, hsScalar *distSquared )
{
	if( !IsPropertySet( plSound::kPropIs3DSound ) )
	{
		if( distSquared != nil )
			*distSquared = 1.f;
		return true;
	}

	hsVector3	distance;
	hsPoint3	soundPos = GetPosition();

	distance.Set( &listenerPos, &soundPos );

	if( distSquared != nil )
		*distSquared = distance.MagnitudeSquared();

	if( GetMax() == 1000000000 )
		return true;

	hsScalar	soundRadius = (hsScalar)( GetMax() * GetMax() );

	return ( distance.MagnitudeSquared() <= soundRadius ) ? true : false;
}


//// ////////////////////////////////////////////////////////
//	Once the soft volume is calculated and our rank is computed, we can 
//	decide whether to actually enable or not.
//	Note: we might have been "enabled" by our Calc call, but the ranking
//	still could have disabled us, so we have to specify again whether
//	we're enabled.
//	Note: if we KNOW we're disabling this sound (out of range), Calc() doesn't
//	have to be called at all, and we can simply call this function with
//	enable = false.
void plSound::UpdateSoftVolume( hsBool enable, hsBool firstTime )
{
	fNotHighEnoughPriority = !enable;

	// Don't do any of this special stuff that follows if we're not supposed to be playing
	if( IsPlaying() )
	{
		if( fSoftVolume * fDistAttenuation > 0.f && !fNotHighEnoughPriority )
		{
			if( fCurrFadeParams == &fCoolSoftVolumeTrickParams )
			{
				// Stop the fade, but since we are updating the softvolume with the intention of being audible
				// tell StopFade not to set the soft volume to zero.
				IStopFade(false, false);
			}
			if( !IActuallyPlaying() )
			{
				// Must've been stopped from being out of range. Start up again...

				// Synch up to our start time.
				// If this sound is auto starting and is background music, get the current time so we don't start 
				// with the play cursor already into the piece.
				if(IsPropertySet(kPropAutoStart) && fType == kBackgroundMusic) fVirtualStartTime = hsTimer::GetSysSeconds();
				ISynchedPlay( fVirtualStartTime );
			}
		}
		else if( fCurrFadeParams != &fCoolSoftVolumeTrickParams && IActuallyPlaying() )
		{
			// Start our special trick, courtesy of Brice. Basically, we don't 
			// stop the sound immediately, but rather let it get to the end of
			// the sound and loop once more. This way, if we go away and come back soon
			// enough, it will be continuing as we expect it to, but if we wait long enough,
			// it'll stop, saving processing time.

			// Note: we just do it as a fade because it makes it easier on us that way!
			fCoolSoftVolumeTrickParams.fCurrTime = 0.f;
			fCoolSoftVolumeTrickParams.fLengthInSecs = firstTime ? 0.f : (hsScalar)fLength + ( (hsScalar)fLength - (hsScalar)GetTime() );
			fCoolSoftVolumeTrickParams.fStopWhenDone = true;
			fCoolSoftVolumeTrickParams.fFadeSoftVol = true;
			fCoolSoftVolumeTrickParams.fType = plFadeParams::kLinear;
			fCoolSoftVolumeTrickParams.fVolStart = fSoftVolume;	// Don't actually change the volume this way
			fCoolSoftVolumeTrickParams.fVolEnd = 0.f;

			IStartFade( &fCoolSoftVolumeTrickParams );

			plProfile_Inc( WaitingToDie );
		}
	}

	RefreshVolume();
}

/////////////////////////////////////////////////////////////////////////
// Returns the current volume, attenuated
hsScalar plSound::QueryCurrVolume( void ) const
{
	return IAttenuateActualVolume( fCurrVolume ) * IGetChannelVolume();
}

/////////////////////////////////////////////////////////////////////////
//	Used by ISetActualVolume(). Does the final attenuation on a volume before
//	sending it to the sound processing. Only does soft regions for now.
hsScalar plSound::IAttenuateActualVolume( hsScalar volume ) const
{
	if( fNotHighEnoughPriority )
		return 0.f;
	
	volume *= fSoftVolume;

	if( IsPropertySet( kPropIs3DSound ) )
		volume *= fDistAttenuation;

	return volume;
}

void plSound::Activate(hsBool forcePlay)
{
	// Our actual state...
	fActive = true;

	// re-create the sound state here:
	if( forcePlay || fPlayOnReactivate )
	{
		ISynchedPlay( hsTimer::GetSysSeconds() );
		fPlayOnReactivate = false;
	}

	RegisterOnAudioSys();
	SetMuted(plgAudioSys::IsMuted());
}

void plSound::DeActivate( void )
{
	UnregisterOnAudioSys();

	if( fActive )
	{
		if( IsPlaying() )
		{
			Stop();
			fPlayOnReactivate = true;
		}
		else
			fPlayOnReactivate = false;
	}

	fActive = false;
}

/////////////////////////////////////////////////////////////////////////
//	Tell the audio system about ourselves.
void plSound::RegisterOnAudioSys( void )
{
	if( !fRegistered )
	{
		plgAudioSys::RegisterSoftSound(GetKey());
		fRegistered = true;
	}
}

/////////////////////////////////////////////////////////////////////////
//	Tell the audio system to stop caring about us
void plSound::UnregisterOnAudioSys( void )
{
	if( fRegistered )
	{
		plgAudioSys::UnregisterSoftSound(GetKey());
		fRegistered = false;
	}
}

/////////////////////////////////////////////////////////////////////////
//	Called by the audio system when we've been booted off (audio system is
//	shutting down). Normally, we should already be shut down, but in case
//	we're not, this function makes sure everything is cleaned up before
//	the audio system itself shuts down.
void plSound::ForceUnregisterFromAudioSys( void )
{
	DeActivate();
	fRegistered = false;
}

void plSound::Read(hsStream* s, hsResMgr* mgr)
{
	plSynchedObject::Read(s, mgr);

	IRead( s, mgr );

	// If we're autostart, start playing
	if( IsPropertySet( kPropAutoStart ) )
		Play();

	// Make sure we synch or don't synch
	if( IsPropertySet( kPropLocalOnly ) )
		SetLocalOnly(true);

	// If we're not playing, but we're going to, and we're going to fade in,
	// then our current state is faded out, so set fFading
	if( fFadeInParams.fLengthInSecs > 0 && !fPlaying )
		fFading = true;
	else if( fFadeInParams.fLengthInSecs <= 0 && !fPlaying )
		fFading = false;

	ILoadDataBuffer();		// make sure our sound buffer is loaded

	// Force load on read
	if( !fLoadOnDemandFlag || IsPropertySet( kPropDisableLOD ) )
	{
		LoadSound( IsPropertySet( kPropIs3DSound ) );
	}
	else
	{
		// Loading on demand, but we still need the length. But that's ok, we'll get it when we get the fDataBuffer ref.
		// But we want to preload the data, so go ahead and do that
		if( !fLoadFromDiskOnDemand && !IsPropertySet( kPropLoadOnlyOnCall ) && fPriority <= plgAudioSys::GetPriorityCutoff())
		{			
			IPreLoadBuffer(false);			
		}
	}
}

void plSound::Write(hsStream* s, hsResMgr* mgr)
{
	plSynchedObject::Write(s, mgr);
	IWrite( s, mgr );
}

void plSound::IRead( hsStream *s, hsResMgr *mgr )
{
	fPlaying = s->ReadBool();
	fVirtualStartTime = hsTimer::GetSysSeconds();	// Need if we're autostart
	fTime = s->ReadSwapDouble();
	fMaxFalloff = s->ReadSwap32();
	fMinFalloff = s->ReadSwap32();
	s->ReadSwap( &fCurrVolume );
	s->ReadSwap( &fDesiredVol );

	/// mcn debugging - Thanks to some of my older sound code, it's possible that a few volumes
	/// will come in too large. This will only happen with scenes that were exported with that intermediate
	/// code, which should be limited to my test scenes locally. Otherwise, things should be fine. This
	/// is to compensate for those bogus files. (The fix is to reset the volume in MAX, since the bogusness
	///	is in the range of the volume slider itself).
	if( fDesiredVol > 1.f )
		fDesiredVol = 1.f;
	if( fCurrVolume > 1.f )
		fCurrVolume = 1.f;
	fMaxVolume = fDesiredVol;

	fOuterVol = s->ReadSwap32();
	fInnerCone = s->ReadSwap32();
	fOuterCone = s->ReadSwap32();
	s->ReadSwap( &fFadedVolume );
	s->ReadSwap( &fProperties );

	fType = s->ReadByte();
	fPriority = s->ReadByte();

	// HACK FOR OLDER EXPORTERS that thought Auto-start meant set fPlaying true
	if( fPlaying )
		SetProperty( kPropAutoStart, true );

	// Read in fade params
	fFadeInParams.Read( s );
	fFadeOutParams.Read( s );

	// Read in soft volume key
	mgr->ReadKeyNotifyMe( s, TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, 0, kRefSoftVolume ), plRefFlags::kActiveRef );

	// Read in the data buffer key
	fDataBufferKey = mgr->ReadKey( s );

	// EAX params
	fEAXSettings.Read( s );

	// EAX soft keys
	mgr->ReadKeyNotifyMe( s, TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, 0, kRefSoftOcclusionRegion ), plRefFlags::kActiveRef );
}

void plSound::IWrite( hsStream *s, hsResMgr *mgr )
{
	s->WriteBool(fPlaying);
	s->WriteSwapDouble(fTime);
	s->WriteSwap32(fMaxFalloff);
	s->WriteSwap32(fMinFalloff);
	s->WriteSwap( fCurrVolume );
	s->WriteSwap( fDesiredVol );
	s->WriteSwap32(fOuterVol);
	s->WriteSwap32(fInnerCone);
	s->WriteSwap32(fOuterCone);
	s->WriteSwap( fFadedVolume );
	s->WriteSwap( fProperties );
	s->WriteByte( fType );
	s->WriteByte( fPriority );
	
	// Write out fade params
	fFadeInParams.Write( s );
	fFadeOutParams.Write( s );

	// Write out soft volume key
	mgr->WriteKey( s, fSoftRegion );
	
	// Write out data buffer key
	if(fDataBuffer)
		mgr->WriteKey( s, fDataBuffer->GetKey() );
	else
		mgr->WriteKey( s, fDataBufferKey );

	// EAX params
	fEAXSettings.Write( s );

	// EAX Soft keys
	mgr->WriteKey( s, fSoftOcclusionRegion );
}

void plSound::plFadeParams::Read( hsStream *s )
{
	s->ReadSwap( &fLengthInSecs );
	s->ReadSwap( &fVolStart );
	s->ReadSwap( &fVolEnd );
	s->ReadSwap( &fType );
	s->ReadSwap( &fCurrTime );
	s->ReadSwap( &fStopWhenDone );
	s->ReadSwap( &fFadeSoftVol );
}

void plSound::plFadeParams::Write( hsStream *s )
{
	s->WriteSwap( fLengthInSecs );
	s->WriteSwap( fVolStart );
	s->WriteSwap( fVolEnd );
	s->WriteSwap( fType );
	s->WriteSwap( fCurrTime );
	s->WriteSwap( fStopWhenDone );
	s->WriteSwap( fFadeSoftVol );
}

hsScalar plSound::plFadeParams::InterpValue( void )
{
	hsScalar	val;

	switch( fType )
	{
		case kLinear:
			val = ( ( fCurrTime / fLengthInSecs ) * ( fVolEnd - fVolStart ) ) + fVolStart;
			break;
		case kLogarithmic:
			val = fCurrTime / fLengthInSecs;
			val = ( ( val * val ) * ( fVolEnd - fVolStart ) ) + fVolStart;
			break;
		case kExponential:
			val = fCurrTime / fLengthInSecs;
			val = ( (hsScalar)sqrt( val ) * ( fVolEnd - fVolStart ) ) + fVolStart;
			break;
		default:
			val = 0.f;
	}
	return val;
}

void plSound::SetFadeInEffect( plSound::plFadeParams::Type type, hsScalar length )
{
	fFadeInParams.fLengthInSecs = length;
	fFadeInParams.fType = type;
	fFadeInParams.fVolStart = 0.f;	// Will be set when activated
	fFadeInParams.fVolEnd = 1.f;	// Will be set when activated
	fFadeInParams.fCurrTime = -1.f;

	// If we're not playing, but we're going to, and we're going to fade in,
	// then our current state is faded out, so set fFading
	if( fFadeInParams.fLengthInSecs > 0 && !fPlaying )
		fFading = true;
	else if( fFadeInParams.fLengthInSecs <= 0 && !fPlaying )
		fFading = false;
}

void plSound::SetFadeOutEffect( plSound::plFadeParams::Type type, hsScalar length )
{
	fFadeOutParams.fLengthInSecs = length;
	fFadeOutParams.fType = type;
	fFadeOutParams.fVolStart = 1.f; // Will be set when activated
	fFadeOutParams.fVolEnd = 0.f;	// Will be set when activated
	fFadeOutParams.fCurrTime = -1.f;
	fFadeOutParams.fStopWhenDone = true;
}

plDrawableSpans* plSound::CreateProxy(const hsMatrix44& l2w, hsGMaterial* mat, hsTArray<UInt32>& idx, plDrawableSpans* addTo)
{
	plDrawableSpans* myDraw = addTo;

	if( fOuterCone < 360 )
	{
		hsScalar len = (hsScalar)GetMax();
		hsScalar halfAng = hsScalarDegToRad(hsScalar(fInnerCone) * 0.5f);
		hsScalar radius = len * tanf(halfAng);
		if( fInnerCone < 180 )
			len = -len;
		myDraw = plDrawableGenerator::GenerateConicalDrawable(
			radius, 
			len, 
			mat, 
			l2w, 
			true,
			&hsColorRGBA().Set(1.f, 0.5f, 0.5f, 1.f),
			&idx,
			myDraw);

		len = (hsScalar)GetMin();
		halfAng = hsScalarDegToRad(hsScalar(fOuterCone) * 0.5f);
		radius = len * tanf(halfAng);
		if( fOuterCone < 180 )
			len = -len;

		myDraw = plDrawableGenerator::GenerateConicalDrawable(
			radius, 
			len, 
			mat, 
			l2w, 
			true,
			&hsColorRGBA().Set(0.25f, 0.25f, 0.5f, 1.f),
			&idx,
			myDraw);
	}
	else
	{
		myDraw = plDrawableGenerator::GenerateSphericalDrawable(
			hsPoint3(0,0,0), 
			(hsScalar)GetMin(), 
			mat, 
			l2w, 
			true,
			&hsColorRGBA().Set(1.f, 0.5f, 0.5f, 1.f),
			&idx,
			myDraw);

		myDraw = plDrawableGenerator::GenerateSphericalDrawable(
			hsPoint3(0,0,0), 
			(hsScalar)GetMax(), 
			mat, 
			l2w, 
			true,
			&hsColorRGBA().Set(0.25f, 0.25f, 0.5f, 1.f),
			&idx,
			myDraw);
	}
	return myDraw;
}


// call when state has changed
hsBool plSound::DirtySynchState(const char* sdlName /* kSDLSound */, UInt32 sendFlags)
{
	/*
	if( sdlName == nil )
		sdlName = kSDLSound;

	if( fOwningSceneObject != nil )
		return fOwningSceneObject->DirtySynchState(sdlName, sendFlags);
*/
	return false;
}


//////////////////////////////////////////////////////////////////////////////
//// plSoundVolumeApplicator /////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

void plSoundVolumeApplicator::IApply( const plAGModifier *mod, double time )
{
	plScalarChannel *chan = plScalarChannel::ConvertNoRef( fChannel );
	if(chan)
	{
		hsScalar volume = chan->Value( time );

		hsScalar digitalVolume = (float)pow( 10.f, volume / 20.f );

		// Find the audio interface and thus the plSound from it
		plSceneObject *so = mod->GetTarget( 0 );
		if( so != nil )
		{
			const plAudioInterface *ai = so->GetAudioInterface();
			if( ai != nil && fIndex < ai->GetNumSounds() )
			{
				plSound *sound = ai->GetSound( fIndex );
				if( sound != nil )
				{
					sound->SetVolume( digitalVolume );
					return;
				}
			}
		}
	}
}

plAGApplicator *plSoundVolumeApplicator::CloneWithChannel( plAGChannel *channel )
{
	plSoundVolumeApplicator *clone = (plSoundVolumeApplicator *)plAGApplicator::CloneWithChannel( channel );
	clone->fIndex = fIndex;
	return clone;
}

void plSoundVolumeApplicator::Write( hsStream *stream, hsResMgr *mgr )
{
	plAGApplicator::Write( stream, mgr );
	stream->WriteSwap32( fIndex );
}

void plSoundVolumeApplicator::Read( hsStream *s, hsResMgr *mgr )
{
	plAGApplicator::Read( s, mgr );
	fIndex = s->ReadSwap32();
}