#include "system.h"
#include "stratdef.h"
#include "bh_snds.h"
#include "psndplat.h"
#include "bh_types.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>

void SoundBehaveInit(void* bhdata, STRATEGYBLOCK* sbptr)
{
	SOUND_TOOLS_TEMPLATE * stt = (SOUND_TOOLS_TEMPLATE *)bhdata;

	assert (sbptr && stt);

	SOUND_BEHAV_BLOCK * sbb = malloc (sizeof (SOUND_BEHAV_BLOCK));

	if(NULL != sbb)
	{
		sbptr->dataptr = sbb;
		sbb->sound_number = stt->sound_number;
		sbb->position = stt->position;
		sbb->inner_range = stt->inner_range;
		sbb->outer_range = stt->outer_range;
		sbb->max_volume = stt->max_volume;
		sbb->pitch = stt->pitch;

		sbb->sound_not_started = 1;

		sbb->wav_name = malloc (strlen (stt->sound_name) + 1);
		if(NULL == sbb->wav_name)
		{
			RemoveBehaviourStrategy(sbptr);
			return;
		}

		strcpy (sbb->wav_name, stt->sound_name);
		sbb->playing=stt->playing;
		sbb->loop = stt->loop;
		sbb->activ_no = SOUND_NOACTIVEINDEX;
	}
	else
	{
		RemoveBehaviourStrategy(sbptr);
	}
}

void SoundBehaveFun (STRATEGYBLOCK * sbptr)
{
	SOUND_BEHAV_BLOCK * sbb = (SOUND_BEHAV_BLOCK*)sbptr->dataptr;

	if(SID_NOSOUND == sbb->sound_number)
		return;

	int dist = VectorDistance(&PlayerStatus.DisplayBlock->ObWorld, &sbb->position);

	if (sbb->sound_not_started && PlayerStatus.DisplayBlock)
	{
		SOUND3DDATA s3d;

		if(sbb->playing)
		{
			//start playing the sound , but only if it is close enough

			if(dist <= sbb->outer_range)
			{
				s3d.position = sbb->position;
				s3d.inner_range = sbb->inner_range;
				s3d.outer_range = sbb->outer_range;
				s3d.velocity.vx = s3d.velocity.vy = s3d.velocity.vz = 0;

				Sound_Play ((SOUNDINDEX)sbb->sound_number, (sbb->loop ? "nelh" : "neh"), &s3d, &sbb->activ_no);

				if (sbb->activ_no != SOUND_NOACTIVEINDEX)
				{
					Sound_ChangeVolume (sbb->activ_no, sbb->max_volume);
					Sound_ChangePitch (sbb->activ_no, sbb->pitch);
				}
			}
		}

		sbb->sound_not_started = 0;
	}

	/* KJL 14:15:39 12/8/97 - kill any objects that are too far away */
	if(sbb->playing)
	{
		if(dist > sbb->outer_range)
		{
			//stop sound if it is playing

			if (sbb->activ_no != SOUND_NOACTIVEINDEX)
				Sound_Stop (sbb->activ_no);

			//not much point in restarting a non-looping sound, since it won't restart at the right place
			if(!sbb->loop && sbb->playing)
				sbb->playing = 0;

		return;
		}
	}

	if (sbb->activ_no == SOUND_NOACTIVEINDEX && (SID_NOSOUND != sbb->sound_number) && sbb->playing)
	{
		if(sbb->loop)
		{
			SOUND3DDATA s3d;

			s3d.position = sbb->position;
			s3d.inner_range = sbb->inner_range;
			s3d.outer_range = sbb->outer_range;
			s3d.velocity.vx = s3d.velocity.vy = s3d.velocity.vz = 0;

			Sound_Play((SOUNDINDEX)sbb->sound_number, (sbb->loop ? "nelh" : "neh"), &s3d, &sbb->activ_no);

			if (sbb->activ_no != SOUND_NOACTIVEINDEX)
			{
				Sound_ChangeVolume (sbb->activ_no, sbb->max_volume);
				Sound_ChangePitch (sbb->activ_no, sbb->pitch);
			}
		}
		else //sound has finished playing
		{
			sbb->playing = 0;
		}
	}
}

void StartPlacedSoundPlaying(STRATEGYBLOCK* sbptr)
{
	assert(sbptr);
	assert(sbptr->type == I_BehaviourPlacedSound);
	SOUND_BEHAV_BLOCK * sbb = (SOUND_BEHAV_BLOCK*)sbptr->dataptr;

	if(SID_NOSOUND == sbb->sound_number)
		return;

	if(!sbb->playing)
	{
		//if sound is within range start it
		int dist = VectorDistance(&PlayerStatus.DisplayBlock->ObWorld, &sbb->position);

		if(dist < sbb->outer_range)
		{
			SOUND3DDATA s3d;

			s3d.position = sbb->position;
			s3d.inner_range = sbb->inner_range;
			s3d.outer_range = sbb->outer_range;
			s3d.velocity.vx = s3d.velocity.vy = s3d.velocity.vz = 0;

			Sound_Play ((SOUNDINDEX)sbb->sound_number, (sbb->loop ? "nelh" : "neh"), &s3d, &sbb->activ_no);

			if (sbb->activ_no != SOUND_NOACTIVEINDEX)
			{
				Sound_ChangeVolume (sbb->activ_no, sbb->max_volume);
				Sound_ChangePitch (sbb->activ_no, sbb->pitch);
			}
		}
		sbb->playing = 1;
	}
}

void StopPlacedSoundPlaying(STRATEGYBLOCK* sbptr)
{
	assert(sbptr);
	assert(sbptr->type == I_BehaviourPlacedSound);
	SOUND_BEHAV_BLOCK * sbb = (SOUND_BEHAV_BLOCK*)sbptr->dataptr;

	if(SID_NOSOUND == sbb->sound_number)
		return;

	if(sbb->playing)
	{
		sbb->playing = 0;

		if (sbb->activ_no != SOUND_NOACTIVEINDEX)
			Sound_Stop (sbb->activ_no);
	}
}

/*--------------------**
** Loading and Saving **
**--------------------*/
#include "savegame.h"
typedef struct placed_sound_save_block
{
	SAVE_BLOCK_STRATEGY_HEADER header;

	int playing;

} PLACED_SOUND_SAVE_BLOCK;

//defines for load/save macros
#define SAVELOAD_BLOCK block
#define SAVELOAD_BEHAV sbb 

void LoadStrategy_PlacedSound(SAVE_BLOCK_STRATEGY_HEADER* header)
{
	PLACED_SOUND_SAVE_BLOCK* block = (PLACED_SOUND_SAVE_BLOCK*) header; 

	//check the size of the save block
	if(header->size != sizeof(*block))
		return;

	//find the existing strategy block
	STRATEGYBLOCK* sbPtr = FindSBWithName(header->SBname);

	if(!sbPtr)
		return;

	//make sure the strategy found is of the right type
	if(sbPtr->type != I_BehaviourPlacedSound)
		return;

	SOUND_BEHAV_BLOCK * sbb = (SOUND_BEHAV_BLOCK *)sbPtr->dataptr;

	//start copying stuff
	COPYELEMENT_LOAD(playing)

	sbb->sound_not_started = 0;
	Load_SoundState(&sbb->activ_no);
}

void SaveStrategy_PlacedSound(STRATEGYBLOCK* sbPtr)
{
	PLACED_SOUND_SAVE_BLOCK* block;
	SOUND_BEHAV_BLOCK * sbb = (SOUND_BEHAV_BLOCK *)sbPtr->dataptr;

	GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

	//start copying stuff
	COPYELEMENT_SAVE(playing)

	Save_SoundState(&sbb->activ_no);
}