/*
	pclinkscan v0.5 by Paul Halloran (paul@paulhalloran.com)

	This program produces a nodesfile.txt file which can be used in conjunction with Nathan Peterson's pclink.pl
	to create make your MP3s accessable on your Philips Streamium.
	
	Makes use of code from:
	
	Jason Motylinski's id3v2.1 application	

	This code is released under the GPL.  Please read the GPL readme file provided with this code.

	Thanks to:
		Dominic Weiß
		James Tewkesbury
*/

using System;
using System.IO;
using System.Collections;
using System.Text;
using System.Xml;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Diagnostics;
using System.Reflection;

[assembly: AssemblyTitle("pclinkscan")]
[assembly: AssemblyDescription("Utility to produce a nodesfile.txt to be used with pclink.pl")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("GPL")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]		
[assembly: AssemblyVersion("0.5.1")]


namespace PCLinkScan
{
	/// <summary>
	/// PCLinkScan scans a directory of MP3 and M3U files and will produce a nodesfile.txt file to be used with pclink.pl
	/// See www.paulhalloran.com/streamium for details
	/// </summary>
	class Class1
	{
		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		[STAThread]
		static void Main(string[] args)
		{
			int parammarker=0;
			StringBuilder options = new StringBuilder();
			for (int i=0;i<args.Length;i++)
			{
				if (args[i].Substring(0,1)!="-") 
				{
					parammarker=i;
					break;
				} 
				else 
				{
					options.Append(args[i].Substring(1));
				}
			}

			bool bCatalogue;
			if (options.ToString().IndexOf("S")!=-1||options.ToString().IndexOf("A")!=-1||options.ToString().IndexOf("L")!=-1||options.ToString().IndexOf("R")!=-1||options.ToString().IndexOf("P")!=-1||options.ToString().IndexOf("T")!=-1)
				bCatalogue=true;
			else
				bCatalogue=false;
			

			if (args.Length<parammarker+2) 
			{
				Assembly a = Assembly.GetExecutingAssembly();
				AssemblyName an = a.GetName();
				Version thisVer = an.Version;
				Console.WriteLine("pclinkscan v"+thisVer.ToString());
				Console.WriteLine("===================");
				Console.WriteLine("Usage: pclinkscan [options] directory url [streamfile]");
				Console.WriteLine("");
				Console.WriteLine("directory\tPath to mp3 files");
				Console.WriteLine("url\t\tUrl of path to mp3 files");
				Console.WriteLine("streamfile\tPath of streams xml file");
				Console.WriteLine("");
				Console.WriteLine("Options:");
				Console.WriteLine("-k\tKill single track albums");
				Console.WriteLine("-l\tCalculate length of file.  (will not work with VBR MP3s)");
				Console.WriteLine("-r\tRescan.  Scans all MP3s.  (Default action is to scan for new files only)");
				Console.WriteLine("-SALRPT\tCatalogue by/order:");
				Console.WriteLine("\tS\tStream (requires a stream file to be passed in)");
				Console.WriteLine("\tA\tArtist");
				Console.WriteLine("\tL\tAlbum");
				Console.WriteLine("\tR\tArtist/Album");
				Console.WriteLine("\tP\tPlaylist");
				Console.WriteLine("\tT\tTitle");
				Console.WriteLine("\tDefault is SALRPT");
				return;
			}
			//Streamium seems to use iso-8859-1 (Latin1) charset.  It doesn't like Unicode!
			StreamWriter sw;
			try 
			{
				sw = new StreamWriter("nodesfile.txt",false,Encoding.GetEncoding("iso-8859-1"));
			}
			catch
			{
				Console.WriteLine("Fatal error: Could not write to nodesfile.txt.  Check permissions.");
				return;
			}
			
			string sURL=args[parammarker+1];
			string sPath=Path.GetFullPath(args[parammarker]);
			string sStreamsPath="";
			if (args.Length>parammarker+2)
			{
				sStreamsPath=args[parammarker+2];
			}


			ID3 thisMP3;
			ArrayList arFiles;
			ArrayList arPlayLists;
			ScanDir(sPath,out arFiles,out arPlayLists);
			if (arFiles==null) {
				Console.Write("No files found");	
				return;
			}
			ArrayList arNodeFile = new ArrayList();
			arNodeFile.Add("#");
			arNodeFile.Add("1;Streams;");
			arNodeFile.Add("#");
			arNodeFile.Add("#");
			arNodeFile.Add("#");
			arNodeFile.Add("#");
			arNodeFile.Add("#");
			
			int streamsNode=1;
			int artistNode=2;
			int artistalbumNode=3;
			int albumNode=4;
			int playlistNode=5;
			int trackNode=6;
			int nodePointer=7;
			bool bInserted;


			string lengthString="";
			ArrayList arMP3s = new ArrayList();

			if (options.ToString().IndexOf("r")==-1) 
			{
				if (File.Exists(sPath+Path.DirectorySeparatorChar+".pclinkscan.tmp")) 
				{
					try {
						FileStream s = File.OpenRead(sPath+Path.DirectorySeparatorChar+".pclinkscan.tmp");
						BinaryFormatter b = new BinaryFormatter();
						arMP3s = (ArrayList) b.Deserialize(s);
						s.Close();
						Console.WriteLine("Skipping "+arMP3s.Count+" tracks indexed in previous run. Use -r option to override this.");
					}
					catch
					{
						arMP3s=new ArrayList();
					}
				}
			}

			string thisFileName;
			bool dup;
			for (int j=0;j<arFiles.Count;j++) 
			{
				dup=false;
				FileInfo fFileInfo = new FileInfo(arFiles[j].ToString());
				thisFileName=fFileInfo.Name;
				for (int i=0;i<arMP3s.Count;i++)
				{
					if (thisFileName==((ID3)arMP3s[i]).fileName) 
					{
						dup=true;
						break;
					}
				}
				if (!dup) 
				{
					thisMP3  = new ID3(fFileInfo.DirectoryName, fFileInfo.Name);
					Tools.readTag (ref thisMP3, (options.ToString().IndexOf("l")!=-1));
					if (thisMP3.hasTag)
						if (thisMP3.songTitle!=null&&thisMP3.songTitle.Trim()!="")
						{	
							bInserted=false;
							for (int i=0;i<arMP3s.Count;i++)
							{
								if (String.Compare(thisMP3.songTitle.ToUpper(),((ID3)arMP3s[i]).songTitle.ToUpper())<=0)
								{
									arMP3s.Insert(i,thisMP3);
									bInserted=true;
									break;
								}
							}
							if (!bInserted)
							{
								arMP3s.Add(thisMP3);
							}
						} 
						else 
						{
							Console.WriteLine("MP3 file "+arFiles[j].ToString()+" has no title in ID3 tag. Ignoring.");
						}
					else
						Console.WriteLine("MP3 file "+arFiles[j].ToString()+" has no ID3 tag. Ignoring.");
				}
			}

			ArrayList TrackIndexer = new ArrayList();
			getIndexer(ref TrackIndexer);
			int trackindexPointer=0;
			int tracks=-1;
			StringBuilder trackList = null;

			//Write out the details of the actual MP3s.
			for (int j=0;j<arMP3s.Count;j++) 
			{
				tracks++;
				thisMP3=(ID3)arMP3s[j];
				thisMP3.id=nodePointer;
				arMP3s[j]=thisMP3;
				if (thisMP3.songLength!=0)
					lengthString=",length("+((int)(thisMP3.songLength/1000)).ToString()+")";
				else
					lengthString="";
				arNodeFile.Add(nodePointer.ToString()+";"+thisMP3.songTitle+";"+sURL+(thisMP3.pathToFile.Replace(sPath,"")).Replace(Path.DirectorySeparatorChar.ToString(),"/")+"/"+thisMP3.fileName+",artist("+thisMP3.Artist.Replace(")","").Replace("(","")+")"+lengthString);
				indexThis(ref TrackIndexer, ref trackindexPointer, thisMP3.songTitle, tracks);
				if (trackList==null)
				{
					trackList=new StringBuilder(trackNode+";Tracks;"+nodePointer.ToString());
				} 
				else
				{
					trackList.Append(","+nodePointer.ToString());
				}
				nodePointer++;
			}
			trackList.Append(";"+indexFinish(ref TrackIndexer, ref trackindexPointer, tracks));
			arNodeFile[trackNode]=trackList.ToString();

			//MP3 Artists sort
			ArrayList arMP3sByArtist = new ArrayList();
			arMP3sByArtist.Add( new Artist( ((ID3)arMP3s[0]).Artist,((ID3)arMP3s[0]).songTitle, ((ID3)arMP3s[0]).id ) );
			for (int j=1;j<arMP3s.Count;j++)
			{
				if ( ((ID3)arMP3s[0]).Artist.Trim()!=null && ((ID3)arMP3s[0]).Artist.Trim()!="") 
				{
					bInserted=false;
					for (int k=0;k<arMP3sByArtist.Count;k++)
					{
						if (String.Compare(((ID3)arMP3s[j]).Artist.ToUpper(),((Artist)arMP3sByArtist[k]).artist.ToUpper())<0) 
						{
							arMP3sByArtist.Insert(k,new Artist( ((ID3)arMP3s[j]).Artist,((ID3)arMP3s[j]).songTitle,((ID3)arMP3s[j]).id ) );
							bInserted=true;
							break;
						}
					}
					if (!bInserted)
					{
						arMP3sByArtist.Add(new Artist( ((ID3)arMP3s[j]).Artist,((ID3)arMP3s[j]).songTitle,((ID3)arMP3s[j]).id ) );
					}
				}			
			}

			ArrayList ArtistIndexer = new ArrayList();
			TrackIndexer = new ArrayList();
			getIndexer(ref TrackIndexer);
			getIndexer(ref ArtistIndexer);
			int indexPointer=0;
			trackindexPointer=0;
			tracks=0;
			int artists = 0;
			string thisArtist="";
			StringBuilder currentNode = new StringBuilder();
			StringBuilder artistList = null;

			//Write out artists
			for (int i=0;i<arMP3sByArtist.Count;i++)
			{
				if ( ((Artist)arMP3sByArtist[i]).artist==thisArtist)
				{
					currentNode.Append(","+((Artist)arMP3sByArtist[i]).id.ToString());
					tracks++;
					indexThis(ref TrackIndexer, ref trackindexPointer, ((Artist)arMP3sByArtist[i]).title, tracks);
				} 
				else 
				{
					if (thisArtist!="") 
					{
						currentNode.Append(";"+indexFinish(ref TrackIndexer,ref trackindexPointer, tracks));
						arNodeFile.Add(currentNode);
						nodePointer++;
					}
					thisArtist=((Artist)arMP3sByArtist[i]).artist;
					indexThis(ref ArtistIndexer, ref indexPointer, ((Artist)arMP3sByArtist[i]).artist, artists);
					artists++;
					if (artistList==null)
						artistList=new StringBuilder(artistNode+";Artists;"+nodePointer.ToString());
					else
						artistList.Append(","+nodePointer.ToString());
					currentNode = new StringBuilder(nodePointer.ToString()+";"+thisArtist+";"+((Artist)arMP3sByArtist[i]).id.ToString());
					TrackIndexer = new ArrayList();
					getIndexer(ref TrackIndexer);
					trackindexPointer=0;
					tracks=0;
					indexThis(ref TrackIndexer, ref trackindexPointer, ((Artist)arMP3sByArtist[i]).title, tracks);
				}
			}
			currentNode.Append(";"+indexFinish(ref TrackIndexer,ref trackindexPointer, tracks));
			arNodeFile.Add(currentNode);
			artistList.Append(";"+indexFinish(ref ArtistIndexer,ref indexPointer,artists));
			arNodeFile[artistNode]=artistList.ToString();
			nodePointer++;
		
			//Albums sort		
			ArrayList arMP3sByAlbum = new ArrayList();
			for (int j=0;j<arMP3s.Count;j++)
			{
				bInserted=false;
				if (((ID3)arMP3s[j]).Album!=null&&((ID3)arMP3s[j]).Album.Trim()!="") 
				{
					for (int k=0;k<arMP3sByAlbum.Count;k++)
					{
						if (String.Compare(((ID3)arMP3s[j]).Album.ToUpper(),((Album)arMP3sByAlbum[k]).album.ToUpper())<=0) 
						{
							if (String.Compare(((ID3)arMP3s[j]).Album.ToUpper(),((Album)arMP3sByAlbum[k]).album.ToUpper())==0)
							{
								for (int l=k;l<arMP3sByAlbum.Count;l++)
								{
									if ( ((ID3)arMP3s[j]).trackNo<((Album)arMP3sByAlbum[l]).trackno || ((ID3)arMP3s[j]).Album!=((Album)arMP3sByAlbum[l]).album)
									{
										arMP3sByAlbum.Insert(l,new Album( ((ID3)arMP3s[j]).Album, ((ID3)arMP3s[j]).Artist,((ID3)arMP3s[j]).id, ((ID3)arMP3s[j]).trackNo ) );
										bInserted=true;
										break;
									}
								}
								if (!bInserted)
									arMP3sByAlbum.Add(new Album( ((ID3)arMP3s[j]).Album, ((ID3)arMP3s[j]).Artist,((ID3)arMP3s[j]).id, ((ID3)arMP3s[j]).trackNo ) );

							} 
							else
								arMP3sByAlbum.Insert(k,new Album( ((ID3)arMP3s[j]).Album, ((ID3)arMP3s[j]).Artist,((ID3)arMP3s[j]).id, ((ID3)arMP3s[j]).trackNo ) );
							bInserted=true;
							break;
						}
					}
					if (!bInserted)
					{
						arMP3sByAlbum.Add(new Album( ((ID3)arMP3s[j]).Album,((ID3)arMP3s[j]).Artist,((ID3)arMP3s[j]).id, ((ID3)arMP3s[j]).trackNo ) );
					}
				}
			}
			
			string thisAlbum="";
			bool singleTrackAlbum;
			string lastAlbum="";
			int v;
			
			//Kill single track albums
			if (options.ToString().IndexOf("k")!=-1)
			{
					singleTrackAlbum=true;
					for (int k=1;k<arMP3sByAlbum.Count;k++)
					{
						v=k-1;
						thisAlbum=((Album)arMP3sByAlbum[k]).album;
						lastAlbum=((Album)arMP3sByAlbum[v]).album;
						if (thisAlbum==lastAlbum)
						{
							singleTrackAlbum=false;
						}
						else	
						{
							if (singleTrackAlbum)
							{
								arMP3sByAlbum.RemoveAt(v);
								k=v;
							}
							singleTrackAlbum=true;
						} 
					}
				if (arMP3sByAlbum.Count==1)
				{
					arMP3sByAlbum.RemoveAt(0);
				} 
				else 
				{
					thisAlbum=((Album)arMP3sByAlbum[arMP3sByAlbum.Count-1]).album;
					lastAlbum=((Album)arMP3sByAlbum[arMP3sByAlbum.Count-2]).album;
					if (thisAlbum!=lastAlbum)
						arMP3sByAlbum.RemoveAt(arMP3sByAlbum.Count-1);
				}
			}

			if (arMP3sByAlbum.Count>0) 
			{
				ArrayList AlbumIndexer = new ArrayList();
				getIndexer(ref AlbumIndexer);
				indexPointer=0;
				int albums=0;
				Album tmpAlbum;
				thisAlbum="";
				StringBuilder albumsList = null;

				//Write albums to nodesfile
				for (int i=0;i<arMP3sByAlbum.Count;i++)
				{
					if ( ((Album)arMP3sByAlbum[i]).album==thisAlbum)
					{
						currentNode.Append(","+((Album)arMP3sByAlbum[i]).id.ToString());
						tmpAlbum=new Album( ((Album)arMP3sByAlbum[i]).album, ((Album)arMP3sByAlbum[i]).artist, ((Album)arMP3sByAlbum[i]).id, ((Album)arMP3sByAlbum[i]).trackno );
						tmpAlbum.albumnodeid=nodePointer;
						arMP3sByAlbum[i]=tmpAlbum;
					} 
					else 
					{
						if (thisAlbum!="") 
						{
							arNodeFile.Add(currentNode.ToString()+";num()");
							nodePointer++;
							albums++;
						}
						thisAlbum=((Album)arMP3sByAlbum[i]).album;
						indexThis(ref AlbumIndexer, ref indexPointer, thisAlbum, albums);
						tmpAlbum=new Album( ((Album)arMP3sByAlbum[i]).album, ((Album)arMP3sByAlbum[i]).artist, ((Album)arMP3sByAlbum[i]).id, ((Album)arMP3sByAlbum[i]).trackno);
						tmpAlbum.albumnodeid=nodePointer;
						arMP3sByAlbum[i]=tmpAlbum;
						if (albumsList==null)
							albumsList=new StringBuilder(albumNode+";Albums;"+nodePointer.ToString());
						else
							albumsList.Append(","+nodePointer.ToString());
						currentNode = new StringBuilder(nodePointer.ToString()+";"+thisAlbum+";"+((Album)arMP3sByAlbum[i]).id.ToString());
					}
				}
				arNodeFile.Add(currentNode+";num()");
				albumsList.Append(";"+indexFinish(ref AlbumIndexer,ref indexPointer, albums));
				arNodeFile[albumNode]=albumsList.ToString();
				nodePointer++;

				//Artist-Albums sort			
				ArrayList arMP3sByArtistAlbum = new ArrayList();
				for (int j=0;j<arMP3sByAlbum.Count;j++)
				{
					bInserted=false;
					if (((Album)arMP3sByAlbum[j]).artist!=null&&((Album)arMP3sByAlbum[j]).artist.Trim()!="") 
					{
						for (int k=0;k<arMP3sByArtistAlbum.Count;k++)
						{
							if (String.Compare(((Album)arMP3sByAlbum[j]).artist.Trim().ToUpper(),((Album)arMP3sByArtistAlbum[k]).artist.Trim().ToUpper())<0) 
							{
								tmpAlbum=new Album( ((Album)arMP3sByAlbum[j]).album, ((Album)arMP3sByAlbum[j]).artist,((Album)arMP3sByAlbum[j]).id, ((Album)arMP3sByAlbum[j]).trackno );
								tmpAlbum.albumnodeid=((Album)arMP3sByAlbum[j]).albumnodeid;
								arMP3sByArtistAlbum.Insert(k,tmpAlbum );
								bInserted=true;
								break;
							}
						}
						if (!bInserted)
						{
							tmpAlbum=new Album( ((Album)arMP3sByAlbum[j]).album, ((Album)arMP3sByAlbum[j]).artist,((Album)arMP3sByAlbum[j]).id,((Album)arMP3sByAlbum[j]).trackno );
							tmpAlbum.albumnodeid=((Album)arMP3sByAlbum[j]).albumnodeid;
							arMP3sByArtistAlbum.Add(tmpAlbum);
						}
					}
				}

				ArtistIndexer=new ArrayList();
				getIndexer(ref ArtistIndexer);
				indexPointer=0;

				//Write ArtistAlbums
				thisArtist="";
				thisAlbum="";
				int artistNodePointer=nodePointer;
				int artistalbums=0;
				currentNode = new StringBuilder();
				StringBuilder artistAlbumList = null;

				for (int i=0;i<arMP3sByArtistAlbum.Count;i++)
				{
					if ( ((Album)arMP3sByArtistAlbum[i]).album!=thisAlbum )
						if ( ((Album)arMP3sByArtistAlbum[i]).artist!=thisArtist )
						{
							if (thisArtist!="") 
							{
								arNodeFile.Add(currentNode.ToString()+";"+indexFinish(ref TrackIndexer, ref trackindexPointer, tracks));
								nodePointer++;
								artistalbums++;
							}
							thisAlbum=((Album)arMP3sByArtistAlbum[i]).album;
							thisArtist=((Album)arMP3sByArtistAlbum[i]).artist;
							indexThis(ref ArtistIndexer,ref indexPointer, thisArtist, artistalbums);
							if (artistAlbumList==null)
								artistAlbumList=new StringBuilder(artistalbumNode+";ArtistAlbums;"+nodePointer.ToString());
							else
								artistAlbumList.Append(","+nodePointer.ToString());
							currentNode=new StringBuilder(nodePointer.ToString()+";"+thisArtist+";"+((Album)arMP3sByArtistAlbum[i]).albumnodeid);

							TrackIndexer = new ArrayList();
							getIndexer(ref TrackIndexer);
							trackindexPointer=0;
							tracks=0;
							indexThis(ref TrackIndexer, ref trackindexPointer, ((Album)arMP3sByArtistAlbum[i]).album, tracks);
						} 
						else 
						{
							thisAlbum=((Album)arMP3sByArtistAlbum[i]).album;
							currentNode.Append(","+((Album)arMP3sByArtistAlbum[i]).albumnodeid.ToString());
							tracks++;
							indexThis(ref TrackIndexer, ref trackindexPointer, ((Album)arMP3sByArtistAlbum[i]).album, tracks);
						} 
				}
				arNodeFile.Add(currentNode.ToString()+";"+indexFinish(ref TrackIndexer, ref trackindexPointer, tracks));
				artistAlbumList.Append(";"+indexFinish(ref ArtistIndexer, ref indexPointer, artistalbums));
				arNodeFile[artistalbumNode]=artistAlbumList.ToString();
				nodePointer++;
			}

			//Get our internet radio stations from the streams file
			bool bStreamsExist=false;
			if (sStreamsPath!=""&&(!bCatalogue||options.ToString().IndexOf("S")!=-1))
			{
				if (File.Exists(sStreamsPath))
				{
					XmlTextReader reader = new XmlTextReader(sStreamsPath);
					XmlDocument xmlStreams = new XmlDocument();
					try 
					{
						xmlStreams.Load(reader);
						XmlNode subNode = xmlStreams.SelectNodes("/streams").Item(0);
						arNodeFile[streamsNode]=streamsNode.ToString()+scanstreams (subNode, ref nodePointer, ref arNodeFile);
						bStreamsExist=true;
					}
					catch
					{
						Console.WriteLine("Error in streams file, ignoring.  Is it a valid XML document?");
					}
					reader.Close();
				} 
				else 
					Console.WriteLine("Streams file not found.  Ignoring");
			}


			//Playlists
			if (arPlayLists.Count>0) 
			{
				StreamReader sr;
				String searchFile;
				String input;
				String listName;
				StringBuilder playList;
				bool foundItem=false;
				bool fileEnd; 
				string zeroChar=((char)0).ToString();
				ArrayList PlaylistIndexer = new ArrayList();
				getIndexer(ref PlaylistIndexer);
				trackindexPointer=0;
				tracks=-1;
				for (int i=0;i<arPlayLists.Count;i++)
				{
					tracks++;
					sr = new StreamReader(arPlayLists[i].ToString(),Encoding.GetEncoding("iso-8859-1"));
					listName=arPlayLists[i].ToString().Substring(arPlayLists[i].ToString().LastIndexOf(Path.DirectorySeparatorChar)+1).Replace(".m3u","");
					playList=new StringBuilder();
					fileEnd=false;
					indexThis(ref PlaylistIndexer, ref trackindexPointer, listName, tracks);
					while (!fileEnd)
					{
						try 
						{
							input=sr.ReadLine();
							if (input!=null) 
							{
								if (input.Substring(0,1)!="#"&&input!="")
								{
									foundItem=false;
									searchFile=input.Replace(zeroChar,"").Trim();
									if (searchFile.IndexOf("\\")!=-1)
										searchFile=searchFile.Substring(input.LastIndexOf("\\")+1);
									if (searchFile.IndexOf("/")!=-1)
										searchFile=searchFile.Substring(searchFile.LastIndexOf("/")+1);
									for (int j=0;j<arMP3s.Count;j++)
									{
										if (((ID3)arMP3s[j]).fileName.ToUpper()==searchFile.ToUpper())
										{
											if (playList.Length==0)
												playList.Append(((ID3)arMP3s[j]).id.ToString());
											else
												playList.Append(","+((ID3)arMP3s[j]).id.ToString());
											foundItem=true;
											break;
										}
									}
									if (!foundItem)
									{
										Console.WriteLine("Warning:  Couldn't find mp3 '"+searchFile+"' in playlist "+listName+".m3u.  Ignoring.");
									}
								}
							} 
							else {fileEnd=true;}
						} 
						catch { Console.WriteLine("Unknown error accessing playlist {0} - Playlist may contain illegal characters",listName+".m3u");}
					}
					arNodeFile.Add(nodePointer.ToString()+";"+listName+";"+playList.ToString()+";num()");
					if (arNodeFile[playlistNode].ToString()=="#")
						arNodeFile[playlistNode]=playlistNode.ToString()+";Playlists;"+nodePointer.ToString();
					else
						arNodeFile[playlistNode]=arNodeFile[playlistNode]+","+nodePointer.ToString();
					nodePointer++;
					sr.Close();
				}
				arNodeFile[playlistNode]=arNodeFile[playlistNode]+";"+indexFinish(ref PlaylistIndexer, ref trackindexPointer, tracks);
			}

			//Check catalogue order
			if (bCatalogue)
			{
				StringBuilder topIndex = null;
				for (int iLoopOptions=0;iLoopOptions<options.Length;iLoopOptions++)
				{
					switch (options[iLoopOptions].ToString())
					{
						case "S":
							if (bStreamsExist)
								if (topIndex==null)
									topIndex = new StringBuilder("0;Top;"+streamsNode.ToString());
								else
									topIndex.Append(","+streamsNode.ToString());
							break;
						case "A":
							if (topIndex==null)
								topIndex = new StringBuilder("0;Top;"+artistNode.ToString());
							else
								topIndex.Append(","+artistNode.ToString());
							break;
						case "L":
							if (topIndex==null)
								topIndex = new StringBuilder("0;Top;"+albumNode.ToString());
							else
								topIndex.Append(","+albumNode.ToString());
							break;
						case "R":
							if (topIndex==null)
								topIndex = new StringBuilder("0;Top;"+artistalbumNode.ToString());
							else
								topIndex.Append(","+artistalbumNode.ToString());
							break;
						case "P":
							if (arPlayLists.Count>0) 
							{
								if (topIndex==null)
									topIndex = new StringBuilder("0;Top;"+playlistNode.ToString());
								else
									topIndex.Append(","+playlistNode.ToString());
							}
							break;
						case "T":
							if (topIndex==null)
								topIndex = new StringBuilder("0;Top;"+trackNode.ToString());
							else
								topIndex.Append(","+trackNode.ToString());
							break;
					}
				}
				arNodeFile[0]=topIndex.ToString();
			} 
			else 
			{
				string topNode="0;Top;1,2,3,4,5,6";
				if (!bStreamsExist)
					topNode=topNode.Replace("1,","");
				if (arPlayLists.Count==0)
					topNode=topNode.Replace(",5","");
				arNodeFile[0]=topNode;
			}

			
			//Streamium seems to use iso-8859-1 (Latin1) charset.  It doesn't like Unicode!
			try 
			{
				for (int k=0;k<arNodeFile.Count;k++)
				{
					sw.WriteLine(arNodeFile[k]);
				}
				sw.Close();
			}
			catch
			{
				Console.WriteLine("Unknown fatal error writing nodesfile.txt.");
				return;
			}

			//Attempt to write temp file to mp3 dir containing details of mp3s
			try 
			{
				FileStream s = File.Create(sPath+Path.DirectorySeparatorChar+".pclinkscan.tmp");
				BinaryFormatter b = new BinaryFormatter();
				b.Serialize(s,arMP3s);
				s.Close();
			}
			catch
			{
				Console.WriteLine("Warning:  Could not write mp3 index temp file "+sPath+Path.DirectorySeparatorChar+".pclinkscan.tmp");
			}
		}

		public static void indexThis(ref ArrayList Indexer, ref int indexPointer,string indexString, int index )
		{
			Index tmpIndex;
			if (indexString!="")
			{
				while (indexPointer<Indexer.Count&&String.Compare(indexString.Substring(0,1).ToUpper(),((Index)Indexer[indexPointer]).index)>=0)
				{
					tmpIndex=new Index(((Index)Indexer[indexPointer]).index);
					tmpIndex.id=index;
					Indexer[indexPointer]=tmpIndex;
					indexPointer++;
				}
			}		
		}

		public static string indexFinish(ref ArrayList Indexer, ref int indexPointer, int finalIndex)
		{
			Index tmpIndex;
			for (int j=indexPointer;j<Indexer.Count;j++)
			{
				tmpIndex=new Index(((Index)Indexer[j]).index);
				tmpIndex.id=finalIndex;
				Indexer[j]=tmpIndex;
			}
			StringBuilder indexString = new StringBuilder();
			for (int j=0;j<Indexer.Count;j++)
			{
				if (indexString.Length!=0)
					indexString.Append(",");
				indexString.Append("idx("+((Index)Indexer[j]).index+((Index)Indexer[j]).id+")");
			}
			return indexString.ToString();
		}

		public static void getIndexer(ref ArrayList arIndexer)
		{
			//These are the only indexer characters supported by the Streamium's superscroll
			arIndexer.Add(new Index("0"));
			arIndexer.Add(new Index("1"));
			arIndexer.Add(new Index("2"));
			arIndexer.Add(new Index("3"));
			arIndexer.Add(new Index("4"));
			arIndexer.Add(new Index("5"));
			arIndexer.Add(new Index("6"));
			arIndexer.Add(new Index("7"));
			arIndexer.Add(new Index("8"));
			arIndexer.Add(new Index("9"));
			arIndexer.Add(new Index("A"));
			arIndexer.Add(new Index("B"));
			arIndexer.Add(new Index("C"));
			arIndexer.Add(new Index("D"));
			arIndexer.Add(new Index("E"));
			arIndexer.Add(new Index("F"));
			arIndexer.Add(new Index("G"));
			arIndexer.Add(new Index("H"));
			arIndexer.Add(new Index("I"));
			arIndexer.Add(new Index("J"));
			arIndexer.Add(new Index("K"));
			arIndexer.Add(new Index("L"));
			arIndexer.Add(new Index("M"));
			arIndexer.Add(new Index("N"));
			arIndexer.Add(new Index("O"));
			arIndexer.Add(new Index("P"));
			arIndexer.Add(new Index("Q"));
			arIndexer.Add(new Index("R"));
			arIndexer.Add(new Index("S"));
			arIndexer.Add(new Index("T"));
			arIndexer.Add(new Index("U"));
			arIndexer.Add(new Index("V"));
			arIndexer.Add(new Index("W"));
			arIndexer.Add(new Index("X"));
			arIndexer.Add(new Index("Y"));
			arIndexer.Add(new Index("Z"));
		}

		public static string scanstreams (XmlNode xmlNode, ref int nodePointer, ref ArrayList nodesfile)
		{
			//Scan's out streams file for internet radio stations. Recursive.
			int myNode;
			bool topNode=false;
			StringBuilder nodeIDString = new StringBuilder();

			myNode=nodePointer;
			if (xmlNode.Name=="streams") 
				topNode=true;
			
			if (!topNode)
			{
				nodesfile.Add("#");
				nodePointer++;
			}

			foreach (XmlNode subNode in xmlNode)
			{
				if ((subNode.Name)=="url") 
				{
					nodesfile.Add(nodePointer+";"+subNode.Attributes["name"].Value+";"+subNode.InnerText);
					if (nodeIDString.Length!=0)
						nodeIDString.Append(",");
					nodeIDString.Append(nodePointer.ToString());
					nodePointer++;
				}
				if ((subNode.Name)=="group")
				{
					if (nodeIDString.Length!=0)
						nodeIDString.Append(","+nodePointer.ToString());
					else
						nodeIDString.Append(nodePointer.ToString());
					scanstreams (subNode, ref nodePointer, ref nodesfile);
				}
			}
			if (!topNode)
				nodesfile[myNode]=myNode.ToString()+";"+xmlNode.Attributes["name"].Value+";"+nodeIDString.ToString();
			return ";"+xmlNode.Attributes["name"].Value+";"+nodeIDString.ToString();
		}

		public static void ScanDir (string sPath, out ArrayList mp3Files, out ArrayList m3uFiles)
		{
			//Scan's dir for mp3 and m3u files.  Recursive.
			ArrayList tempMp3Arr;
			ArrayList tempM3uArr;
			ArrayList retArrMp3 = new ArrayList();
			ArrayList retArrM3u = new ArrayList();

			string[] sMp3Files;
			string[] sM3uFiles;
			try 
			{
				sMp3Files=Directory.GetFiles(sPath,"*.mp3");
				sM3uFiles=Directory.GetFiles(sPath,"*.m3u");
			}
			catch (Exception e)
			{
				Console.WriteLine("Path not found: "+sPath);
				Console.WriteLine(e.Message);
				mp3Files=new ArrayList();
				m3uFiles=new ArrayList();
				return;
			}
			for (int i=0;i<sMp3Files.Length;i++)
				retArrMp3.Add(sMp3Files[i]);
			for (int i=0;i<sM3uFiles.Length;i++)
				retArrM3u.Add(sM3uFiles[i]);
			string[] sDirectories=Directory.GetDirectories(sPath);
			for (int i=0;i<sDirectories.Length;i++) 
			{
				ScanDir(sDirectories[i],out tempMp3Arr,out tempM3uArr);
				for (int j=0;j<tempMp3Arr.Count;j++)
					retArrMp3.Add(tempMp3Arr[j]);
				for (int j=0;j<tempM3uArr.Count;j++)
					retArrM3u.Add(tempM3uArr[j]);
			}
			mp3Files=retArrMp3;
			m3uFiles=retArrM3u;
		}
	}

	class Tools 
	{
		public static int[] getBitRates(string ver) 
		{
			switch (ver)
			{
				case "1I":
					return new int[16] { -1,32,64,96,128,160,192,224,256,288,320,352,384,416,448,-1 };
				case "1II":
					return new int[16] { -1,32,48,56,64,80,96,112,128,160,192,224,256,320,384,-1 };
				case "1III":
					return new int[16] { -1,32,40,48,56,64,80,96,112,128,160,192,224,256,320,-1};
				case "2I":
					return new int[16] { -1,32,48,56,64,80,96,112,128,144,160,176,192,224,256,-1};
				case "2II":
				case "2III":
					return new int[16] { -1,8,16,24,32,40,48,56,64,80,96,112,128,144,160,-1};
			}
			return new int[16] {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 };
		}

		public static void readTag (ref ID3 thisTag, bool calcLength) 
		{
			FileStream oFS;
			try 
			{
				oFS = new FileStream(thisTag.fullPath , FileMode.Open, FileAccess.Read, FileShare.Read);
			}
			catch
			{
				Console.WriteLine("Read error on file:"+thisTag.fullPath+".  Ignoring.");
				thisTag.hasTag      = false;
				thisTag.songTitle       = "";
				thisTag.Artist      = "";
				thisTag.Album       = "";
				thisTag.trackNo = 0;
				thisTag.Genre       = 0;
				return;
			}

			thisTag.hasTag=false;
			thisTag.songTitle="";
			thisTag.Artist="";
			thisTag.Album="";
			thisTag.trackNo=0;
			thisTag.Genre=0;
			
			string zeroChar=((char)0).ToString();
			Encoding  instEncoding = new ASCIIEncoding();
			byte [] Buffer;
			
			//check for id3v1 tag
			Buffer = new byte[128];
			oFS.Seek(-128, SeekOrigin.End);
			oFS.Read(Buffer,0, 128);
  
			string tag = instEncoding.GetString(Buffer);
  
			if (tag .Substring(0,3) == "TAG") 
			{
				thisTag.hasTag=true;
				thisTag.songTitle=tag.Substring(  3, 30).Replace(zeroChar,"").Trim();
				thisTag.Artist=tag.Substring( 33, 30).Replace(zeroChar,"").Trim();
				thisTag.Album=tag.Substring( 63, 30).Replace(zeroChar,"").Trim();
				thisTag.Genre = Buffer[127];
				if (tag[125]==0)
					thisTag.trackNo = Buffer[126];
				else
					thisTag.trackNo = 0;
			}

			//Check for id3v2 tag
			Buffer = new byte[4];
			int[] nb = new int[4];
			oFS.Seek(0, SeekOrigin.Begin);
			oFS.Read(Buffer,0,3);
			string filetype = instEncoding.GetString(Buffer);
			string tagName;
			StringBuilder data;
			long FrameSize=1;
			try
			{
				if(filetype.StartsWith("ID3"))
				{
					thisTag.hasTag=true;
					oFS.Seek(6, SeekOrigin.Begin);
					oFS.Read(Buffer,0,4);

					nb[3] = Buffer[3] | ((Buffer[2] & 1) << 7) ;
					nb[2] = ((Buffer[2] >> 1) & 63) | ((Buffer[1] & 3) << 6) ;
					nb[1] = ((Buffer[1] >> 2) & 31) | ((Buffer[0] & 7) << 5) ;
					nb[0] = ((Buffer[0] >> 3) & 15) ;

					FrameSize = 10 + (long)nb[3] | ((long)nb[2] << 8)  |	((long)nb[1] << 16) | ((long) nb[0] << 24) ;
					long i=0;
					long fs=1;
					string thisData="";
					while(i<FrameSize && fs>0)
					{	
						data = new StringBuilder();
						i+=10;
						oFS.Seek(i, SeekOrigin.Begin);
						oFS.Read(Buffer,0,4);
						tagName=instEncoding.GetString(Buffer).Substring(0,4);

						oFS.Seek(i+4, SeekOrigin.Begin);
						oFS.Read(Buffer,0,4);
					
						fs = ((long)Buffer[0] << 24) + ((long)Buffer[1] << 16) +((long)Buffer[2] << 8) + ((long)Buffer[3]);
					
						if (tagName=="TIT2"||tagName=="TPE1"||tagName=="TALB"||tagName=="TRCK"||tagName=="TLEN") 
						{
							byte[] s = new byte[fs];
							oFS.Seek(i+10, SeekOrigin.Begin);
							oFS.Read(s,0,(int)fs);
							Decoder d = Encoding.UTF7.GetDecoder();
				
							char[] chars = new Char[d.GetCharCount(s,0,(int)fs)];
							int charLen = d.GetChars(s, 0,s.Length, chars, 0);

							for(int j=0;j<chars.Length;j++)
							{
								if (chars[j].ToString()!="\0")
								{
									data.Append(chars[j].ToString());
								}
							}
							thisData=data.ToString().Trim().Replace(zeroChar,"");
							switch (tagName) 
							{
								case "TLEN":
									try 
									{
										thisTag.songLength=int.Parse(thisData);
									}
									catch
									{
										thisTag.songLength=0;
									}
									break;
								case "TIT2":
									if (thisData!="")
										thisTag.songTitle = thisData;
									break;
								case "TPE1":
									if (thisData!="")
										thisTag.Artist = thisData;
									break;
								case "TALB":
									if (thisData!="")
										thisTag.Album=thisData;
									break;
								case "TRCK":
									string trck=thisData;
									if (trck.IndexOf("/")!=-1)
									{
										trck=trck.Substring(0,trck.IndexOf("/"));
									}
									if (trck!="") 
									{
										try 
										{
											thisTag.trackNo=byte.Parse(trck);
										}
										catch
										{
										}
									}
									break;
							}
						}
						i+=fs;
					}
				}
				else
					Debug.WriteLine(filetype.StartsWith("ID3"));
			}
			catch (Exception e)
			{
				Console.WriteLine("An unexpected error occurred while getting the ID3v2 tag for "+thisTag.fullPath);
				Console.WriteLine("Error: "+e.Message);
				thisTag.hasTag=false;
			}

			//Scan for length?
			int bitrate=0;
			if (calcLength&&thisTag.songLength==0&&thisTag.hasTag) 
			{
				Buffer = new byte[1024];
				int identifier = 0;
				string ver="";
				int protect;
				int length;
				int iOffset=0;
				do
				{
					oFS.Seek(FrameSize-1+iOffset,SeekOrigin.Begin);
					oFS.Read(Buffer,0,Buffer.Length);
					for (int i=0;i<Buffer.Length-4;i++)
					{
						if (Buffer[i]==255)
						{
							if ((Buffer[i+1] & 224)==224)
							{
								//this looks like an mpeg frame header
								identifier = (Buffer[i+1] & 16) + (Buffer[i+1] & 8);
								switch (identifier)
								{
									case 0:
										ver="2.5";
										break;
									case 8:
										//reserved
										ver="";
										break;
									case 16:
										ver="2";
										break;
									case 24:
										ver="1";
										break;
								}
								identifier = ((Buffer[i+1] & 4) + (Buffer[i+1] & 2));
								switch (identifier)
								{
									case 0:
										//reserved
										ver=ver+"";
										break;
									case 2:
										ver=ver+"III";
										break;
									case 4:
										ver=ver+"II";
										break;
									case 6:
										ver=ver+"I";
										break;
								}
								protect =  (Buffer[i+1] & 1);
								identifier = ((Buffer[i+2] & 240));
								bitrate=getBitRates(ver)[identifier/16];
								length=(int)(oFS.Length/(bitrate*125));
								if (length>0) 
								{
									thisTag.songLength=length*1000;
									break;
								}
							}
						}
					}
					iOffset=iOffset+1024;
				} while (iOffset<oFS.Length&&thisTag.songLength<=0);
				if (thisTag.songLength==0)
					Console.WriteLine("Couldn't get length of file {0}.",thisTag.fileName);
			}

			oFS.Close();
		}
	}
  

	class Album
	{
		public string album;
		public string artist;
		public int id;
		public int albumnodeid;
		public int trackno;

		public Album (string album, string artist, int id, int trackno)
		{
			this.artist=artist;
			this.album=album;
			this.id=id;
			this.albumnodeid=0;
			this.trackno=trackno;
		}
	}

	class Artist
	{
		public string artist;
		public string title;
		public int id;
		
		public Artist (string artist,string title, int id)
		{
			this.artist=artist;
			this.id=id;
			this.title=title;
		}
	}

	class Index
	{
		public string index;
		public int id;

		public Index (string index)
		{
			this.index=index;
			this.id=0;
		}
	}

	[Serializable]
	class ID3 : ISerializable
	{
		public int	   id;
		public bool    hasTag;
		public string  pathToFile;
		public string  fileName;
		public string  fullPath;
		public string  songTitle;
		public string  Artist;
		public string  Album;
		public int     trackNo;
		public byte    Genre; //Not using genre yet, but may do in later version
		public int	   songLength;
      
		public ID3(string path, string name) 
		{
			this.id=0;
			this.pathToFile     = path;
			this.fileName = name;
			this.fullPath = path + Path.DirectorySeparatorChar + name;
			this.hasTag    = false;
			this.songTitle   = "";
			this.Artist    = "";
			this.Album   = "";
			this.trackNo = 0;
			this.Genre   = 0;
			this.songLength=0;
		}

		internal ID3 (SerializationInfo si, StreamingContext context)
		{
			id=si.GetInt32("id");
			hasTag=si.GetBoolean("hasTag");
			pathToFile=si.GetString("pathToFile");
			fileName=si.GetString("fileName");
			fullPath=si.GetString("fullPath");
			songTitle=si.GetString("songTitle");
			Artist=si.GetString("Artist");
			Album=si.GetString("Album");
			trackNo=si.GetInt32("trackNo");
			Genre=si.GetByte("Genre");
			songLength=si.GetInt32("songLength");
		}

		public void GetObjectData(SerializationInfo si, StreamingContext context)
		{
			si.AddValue("id",id);
			si.AddValue("hasTag",hasTag);
			si.AddValue("pathToFile",pathToFile);
			si.AddValue("fileName",fileName);
			si.AddValue("fullPath",fullPath);
			si.AddValue("songTitle",songTitle);
			si.AddValue("Artist",Artist);
			si.AddValue("Album",Album);
			si.AddValue("trackNo",trackNo);
			si.AddValue("Genre",Genre);
			si.AddValue("songLength",songLength);
			Type t = this.GetType();
			si.AddValue("TypeObj",t);
		}
	} 

}