#include "iaudio.h"
#include "tier0/lib.h"
#include "tier1/utlvector.h"
#include "tier1/utlstring.h"
#define MINIAUDIO_IMPLEMENTATION
#include "miniaudio.h"

class CMiniAudio;
class CMiniAudioManager;

class CMiniAudioPlayer: public IAudioPlayer
{
public:
	virtual void StartAt( double fTime ) override;
	virtual double GetPlayTime() override;
	virtual double Stop() override;
	virtual void Continue() override;
	virtual bool BIsPlaying() override;

	virtual void SetIs3D( bool b ) override;
	virtual void SetIsLooping( bool b ) override;
	virtual void SetDirection( Vector v ) override;
	virtual void SetTimeScale( float fValue ) override;
	virtual void SetVolume( float fValue ) override;
	virtual void SetPitch( float fValue ) override;

	ma_sound m_sound;
	CMiniAudio *m_pAudio;

	bool m_bIsPlaying;
};

class CMiniAudio: public IAudio
{
public:
	virtual IAudioPlayer *SpawnPlayer() override;
	
	CMiniAudioManager *m_pManager;
	CUtlString m_szName;
	ma_sound m_sound;
	CUtlVector<CMiniAudioPlayer*> m_players;
};

class CMiniAudioManager: public IAudioManager
{
public:
	virtual void Init() override;
	virtual void Shutdown() override;
	virtual void Frame() override;
	virtual IAudio *CreateAudio( const char *szFile ) override;
	virtual void DestroyAudio( IAudio *pAudio ) override;
	
	ma_engine m_engine;
	CUtlVector<CMiniAudio*> m_audios;
};

void CMiniAudioPlayer::StartAt( double fTime )
{
	ma_sound_seek_to_second(&m_sound, -fTime*1000);
	ma_sound_start(&m_sound);

}

double CMiniAudioPlayer::GetPlayTime()
{
	return ma_sound_get_time_in_milliseconds(&m_sound)/1000.0;

}

double CMiniAudioPlayer::Stop()
{
	ma_sound_stop(&m_sound);
	return GetPlayTime();
}

void CMiniAudioPlayer::Continue()
{
	ma_sound_start(&m_sound);
}

bool CMiniAudioPlayer::BIsPlaying()
{
	return ma_sound_is_playing(&m_sound);
}

void CMiniAudioPlayer::SetIs3D( bool b )
{
	ma_sound_set_spatialization_enabled(&m_sound, b);
}

void CMiniAudioPlayer::SetIsLooping( bool b )
{
	ma_sound_set_looping(&m_sound, b);
}

void CMiniAudioPlayer::SetDirection( Vector v )
{
	ma_sound_set_position(&m_sound, v.x, v.y, v.z);
}


void CMiniAudioPlayer::SetTimeScale( float fValue )
{

}

void CMiniAudioPlayer::SetVolume( float fValue )
{
	ma_sound_set_volume(&m_sound, fValue);

}

void CMiniAudioPlayer::SetPitch( float fValue )
{
	ma_sound_set_pitch(&m_sound, fValue);
}


IAudioPlayer *CMiniAudio::SpawnPlayer()
{
	CMiniAudioPlayer *pPlayer;
	ma_result r;

	pPlayer = new CMiniAudioPlayer;
	r = ma_sound_init_from_file(&m_pManager->m_engine, m_szName, MA_SOUND_FLAG_DECODE | MA_SOUND_FLAG_WAIT_INIT, NULL, NULL, &pPlayer->m_sound);
	if (r != MA_SUCCESS)
	{
		delete pPlayer;
		return NULL;
	}
	m_players.AppendTail(pPlayer);
	return pPlayer;
}

void CMiniAudioManager::Init()
{
	ma_device_config config;
	ma_result r;

	r = ma_engine_init(NULL, &m_engine);
	if ( r != MA_SUCCESS )
	{
		V_printf("ma_engine_init failed\n");
	}
	r = ma_engine_start(&m_engine);
	ma_engine_listener_set_position(&m_engine, 0, 0, 0, 0);
	if ( r != MA_SUCCESS )
	{
		V_printf("ma_engine_start failed\n");
	}
}

void CMiniAudioManager::Shutdown()
{

}

void CMiniAudioManager::Frame()
{

}


IAudio *CMiniAudioManager::CreateAudio( const char *szFile )
{

	ma_result r;
	CMiniAudio *pAudio;

	pAudio = new CMiniAudio;
	r = ma_sound_init_from_file(&m_engine, szFile, MA_SOUND_FLAG_DECODE | MA_SOUND_FLAG_ASYNC, NULL, NULL, &pAudio->m_sound);
	if (r != MA_SUCCESS)
	{
		delete pAudio;
		return NULL;
	}

	pAudio->m_pManager = this;
	pAudio->m_szName = szFile;
	m_audios.AppendTail(pAudio);
	return pAudio;
}

void CMiniAudioManager::DestroyAudio( IAudio *pAudio )
{

}

EXPOSE_INTERFACE(CMiniAudioManager, IAudioManager, AUDIO_MANAGER_INTERFACE_VERSION);