Engine.StreamPlaylist

//==============================================================================
//	Created on: 10/12/2003
//	A user-configured list of streaming music files.
//
//	Written by Ron Prestenback
//	© 2003, Epic Games, Inc.  All Rights Reserved
//==============================================================================
class StreamPlaylist extends StreamBase
	PerObjectConfig
	Config(UPlaylists);

var() protected config int           Current;
var() protected config array<string> Playlist;
var() protected string               Title;

var() protected config bool          bNeedSave;
var() editinline editconst noexport private   editconstarray transient array<int>    RandomPool;
var() editinline editconst noexport protected StreamInterface                        FileManager;
var() editinline editconst noexport protected editconstarray           array<Stream> Songs;

delegate OnPlaylistChanged();

function bool InitializePlaylist( StreamInterface InManager )
{
	if ( InManager == None || IsInitialized() )
		return false;

	FileManager = InManager;
	LoadPlaylist();
	return true;
}

function bool LoadPlaylist()
{
	local int i;

	ClearPlaylist();
	for ( i = 0; i < Playlist.Length; i++ )
	{
		if ( !FileManager.ValidFile(Playlist[i]) )
		{
			log("Removing file from playlist '"$GetTitle()$"' - file not found",'MusicPlayer');
			Playlist.Remove(i--,1);
			continue;
		}

		AddSong(Playlist[i]);
	}

	ResetRandomPool();
	bNeedSave = False;
	return true;
}

function Stream CreateStream( string FileName )
{
	if ( FileName == "" )
		return None;

	return FileManager.CreateStream( FileName );
}

function int AddSong( string SongFileName, optional bool bSkipNotification )
{
	local Stream NewStream;
	local EFileType Type;
	local int i;

	if ( SongFileName == "" )
		return -1;

	Type = ConvertToFileType(SongFileName);
	if ( Type == FILE_Stream )
	{
		NewStream = CreateStream(SongFileName);
		if ( NewStream == None )
			return -1;

		i = AddStream(GetPlaylistLength(), NewStream, bSkipNotification);
		bNeedSave = bNeedSave || ValidStreamIndex(i);

		return i;
	}

	return -1;
}

function int AddStream( int Index, Stream NewStream, optional bool bSkipNotification )
{
	local int i;
	local string Str;

	if ( NewStream == None )
		return -1;

	Str = NewStream.GetFileName();
	if ( Str == "" )
		return -1;

	i = FindIndexByName( Str );
	if ( !ValidStreamIndex(i) )
	{
		if ( !ValidStreamIndex(Index) )
			Index = GetPlaylistLength();

		Songs.Insert( Index, 1 );
		Songs[Index] = NewStream;
		RandomPool[RandomPool.Length] = Index;

		if ( !bSkipNotification )
			OnPlaylistChanged();
		return Index;
	}

	return i;
}

function int InsertSong( int idx, string Path, optional bool bSkipNotification )
{
	local Stream NewStream;
	local EFileType Type;
	local int i;

	if ( !ValidStreamIndex(idx) )
		return AddSong(Path,bSkipNotification);

	if ( Path == "" )
		return -1;

	Type = ConvertToFileType(Path);
	if ( Type == FILE_Stream )
	{
		NewStream = CreateStream(Path);
		if ( NewStream == None )
			return -1;

		i = AddStream(idx, NewStream, bSkipNotification);
		bNeedSave = bNeedSave || ValidStreamIndex(i);
		return i;
	}

	return -1;

}

function bool RemoveSong( string SongFileName, optional bool bSkipNotification )
{
	return RemoveSongAt(FindIndexByName(SongFileName), bSkipNotification);
}

function bool RemoveSongAt( int idx, optional bool bSkipNotification )
{
	local int i;

	if ( !ValidStreamIndex(idx) )
		return false;

	Songs.Remove(idx,1);

	// Remove the last index from the random pool
	for ( i = 0; i < RandomPool.Length; i++ )
		if ( RandomPool[i] == Songs.Length )
		{
			RandomPool.Remove(i,1);
			break;
		}

	// If this was the current song, attempt to set the current to the previous song, so that the playlist will
	// select the next song correctly
	if ( idx == Current && !SetCurrent(idx-1) )
		SetCurrent(0);

	bNeedSave = True;

	if ( !bSkipNotification )
		OnPlaylistChanged();
	return true;
}

function string NextSong( bool bMayRepeat )
{
	local int i;

	i = GetCurrent() + 1;
	if ( !ValidStreamIndex(i) && bMayRepeat )
		i = 0;

	if ( SetCurrent(i) )
		return Songs[Current].GetPath();

	return "";
}

function string PrevSong( bool bMayRepeat )
{
	local int i;

	i = GetCurrent() - 1;
	if ( !ValidStreamIndex(i) && bMayRepeat )
		i = GetPlaylistLength() - 1;

	if ( SetCurrent(i) )
		return Songs[Current].GetPath();

	return "";
}

function ReplaceWith( StreamPlaylist Other )
{
	if ( Other == None )
		return;

	FileManager = Other.FileManager;
	Other.GetSongs(Songs);
	ResetRandomPool();

	SetCurrent( Other.GetCurrent() );
	bNeedSave = True;
}

function bool ClearPlaylist()
{
	bNeedSave = bNeedSave || Songs.Length > 0;
	Songs.Remove( 0, Songs.Length );
	RandomPool.Remove(0, RandomPool.Length);

	return true;
}

function string GetRandomSong()
{
	local int idx;
	local Stream RandomStream;

	if ( RandomPool.Length == 0 )
		ResetRandomPool();

	if ( RandomPool.Length > 0 )
	{
		idx = Rand(RandomPool.Length - 1);
		if ( ValidStreamIndex(RandomPool[idx]) )
		{
			RandomStream = Songs[RandomPool[idx]];
			RandomPool.Remove(idx,1);
			return RandomStream.GetPath();
		}
	}

	return "";
}

function ResetRandomPool()
{
	local int i;

	RandomPool.Length = Songs.Length;
	for ( i = 0; i < Songs.Length; i++ )
		RandomPool[i] = i;
}

function bool SetTitle( string NewTitle )
{
	if ( NewTitle == "" )
		return false;

	Title = NewTitle;
	OnPlaylistChanged();
	Save();

	return true;
}

function bool SetCurrent( int Index )
{
	if ( !ValidStreamIndex(Index) )
		return false;

	Current = Index;
	bNeedSave = True;
	return true;
}

// DOES NOT perform notification!!
function bool SetSongs( array<Stream> NewSongs )
{
	Songs = NewSongs;
	ResetRandomPool();
	bNeedSave = True;
	return true;
}

// =====================================================================================================================
// =====================================================================================================================
// Query
// =====================================================================================================================
// =====================================================================================================================

function bool IsInitialized()
{
	return FileManager != None;
}

function string GetTitle()
{
	return Title;
}

function int GetCurrent()
{
	return Current;
}

function GetSongs( out array<Stream> SongArray )
{
	SongArray = Songs;
}

function Stream GetCurrentStream()
{
	return GetStreamAt(GetCurrent());
}

function Stream GetStream( string StreamName )
{
	local int i;

	i = FindIndexByName(StreamName);
	return GetStreamAt(i);
}

function Stream GetStreamAt( int Index )
{
	if (ValidStreamIndex(Index) )
		return Songs[Index];

	return None;
}

function int GetPlaylistLength()
{
	return Songs.Length;
}

function int FindIndexByName( string Test )
{
	local FilePath APath;

	if ( ParsePath(Test, APath) )
	{
		if ( APath.Extension != "" )
		{
			if ( APath.Directory != "" )
				return FindIndexByPath(APath.FullPath);
			else if ( APath.FileName != "" )
				return FindIndexByFullName( APath.FileName $ "." $ APath.Extension );
		}
		else return FindIndexByFileName(APath.FileName);
	}

	return -1;
}

function int FindIndexByPath( string Test )
{
	local int i;

	if ( Test == "" )
		return -1;

	for ( i = 0; i < Songs.Length; i++ )
		if ( Songs[i].GetPath() ~= Test )
			return i;

	return -1;
}

function int FindIndexByFullName( string Test )
{
	local int i, num;

	if ( Test == "" )
		return -1;

	num = GetPlaylistLength();
	for ( i = 0; i < num; i++ )
	{
		if ( Songs[i].GetFullName() ~= Test )
			return i;
	}

	return -1;
}

function int FindIndexByFileName( string Test )
{
	local int i, num;

	if ( Test == "" )
		return -1;

	num = GetPlaylistLength();
	for ( i = 0; i < num; i++ )
	{
		if ( Songs[i].GetFileName() ~= Test )
			return i;
	}

	return -1;
}

function bool ValidStreamName( string FileName )
{
	if ( FileName == "" )
		return false;

	return ValidStreamIndex( FindIndexByName(FileName) );
}

function bool ValidStreamIndex( int Index )
{
	return Index >= 0 && Index < Songs.Length;
}

// =====================================================================================================================
// =====================================================================================================================
//  Debug
// =====================================================================================================================
// =====================================================================================================================

function DebugInfo()
{
	local int i;

	log("   Playlist '"$GetTitle()$"', Length:"$GetPlaylistLength(),'MusicPlayer');
	for ( i = 0; i < GetPlaylistLength(); i++ )
		log("    "$i$")"@Songs[i].GetSongTitle(),'MusicPlayer');
}

function bool HandleDebugExec(string Command, string Param)
{
	local int i;

	if ( Super.HandleDebugExec(Command,Param) )
		return true;

	switch ( Locs(Command))
	{
	case "addsong":
		AddSong(Param);
		return true;

	case "dumptags":
		for ( i = 0; i < Songs.Length; i++ )
			Songs[i].DumpTags();
		return true;

	case "scripttags":
		for ( i = 0; i < Songs.Length; i++ )
			Songs[i].DumpScriptTag();

	case "showsongs":
		log("Playlist"@GetTitle()@"has"@Songs.Length@"songs",'MusicPlayer');
		for ( i = 0; i < Songs.Length; i++ )
			log("  "$i$")"@Songs[i].GetPath(),'MusicPlayer');

		return true;
	}

	return false;
}

function Save()
{
	local int i;

	if ( !bNeedSave )
		return;

	Playlist.Remove(0, Playlist.Length);
	for ( i = 0; i < Songs.Length; i++ )
		if ( Songs[i] != None )
			Playlist[i] = Songs[i].GetPath();

	bNeedSave = False;
	SaveConfig();
}


DefaultProperties
{
	bNeedSave=True
}