// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// Copyright (c) 2006 Alexander Olk
//
// Authors:
//
//  Alexander Olk	alex.olk@googlemail.com
//

using System;
using System.IO;
using System.Collections;
using System.Collections.Specialized;
using System.Text.RegularExpressions;
using System.Text;

// Usage:
// - for files:
//   string mimeType = Mime.GetMimeTypeForFile( string filename );
// - for byte array:
//   string mimeType = Mime.GetMimeTypeForData( byte[] data );
// - for string (maybe an email):
//   string mimeType = Mime.GetMimeTypeForString( string input );

// - get alias for mime type:
//   string alias = Mime.GetMimeAlias( string mimeType );
// - get subclass for mime type:
//   string subtype = Mime.GetMimeSubClass( string mimeType );
// - get all available mime types:
//   string[] available = Mime.AvailableMimeTypes;

// TODO:
// - optimize even more :)
// - async callback ?!?
// - freedesktop org file extensions can have regular expressions also, resolve them too
// - sort match collections by magic priority ( higher = first ) ?

// internal test:
// looking up the mime types 20 times for 2757 files in /usr/lib without caching (mime_file_cache)
// old version: Time: 00:00:32.3791220
// new version: Time: 00:00:16.9991810

namespace System.Windows.Forms
{
	internal class Mime
	{
		public static Mime Instance = new Mime();
		
		private string current_file_name;
		private string global_result = octet_stream;
		
		private FileStream file_stream;
		
		private byte[] buffer = null;
		
		private const string octet_stream = "application/octet-stream";
		private const string text_plain = "text/plain";
		private const string zero_file = "application/x-zerosize";
		
		private StringDictionary mime_file_cache = new StringDictionary();
		
		private const int mime_file_cache_max_size = 3000;
		
		private string search_string;
		
		private static object lock_object = new Object();
		
		private bool is_zero_file = false;
		
		private int bytes_read = 0;
		
		private bool mime_available = false;
		
		public static NameValueCollection Aliases;
		public static NameValueCollection SubClasses;
		
		public static NameValueCollection GlobalPatternsShort;
		public static NameValueCollection GlobalPatternsLong;
		public static NameValueCollection GlobalLiterals;
		public static NameValueCollection GlobalSufPref;
		
		public static ArrayList Matches80Plus;
		public static ArrayList MatchesBelow80;
		
		private Mime ()
		{
			Aliases = new NameValueCollection (StringComparer.CurrentCultureIgnoreCase);
			SubClasses = new NameValueCollection (StringComparer.CurrentCultureIgnoreCase);
			GlobalPatternsShort = new NameValueCollection (StringComparer.CurrentCultureIgnoreCase);
			GlobalPatternsLong = new NameValueCollection (StringComparer.CurrentCultureIgnoreCase);
			GlobalLiterals = new NameValueCollection (StringComparer.CurrentCultureIgnoreCase);
			GlobalSufPref = new NameValueCollection (StringComparer.CurrentCultureIgnoreCase);
			
			Matches80Plus = new ArrayList ();
			MatchesBelow80 = new ArrayList ();
			
			FDOMimeConfigReader fmcr = new FDOMimeConfigReader ();
			int buffer_length = fmcr.Init ();
			
			if (buffer_length >= 32) {
				buffer = new byte [buffer_length];
				mime_available = true;
			}
		}
		
		public static bool MimeAvailable {
			get {
				return Instance.mime_available;
			}
		}
		
		public static string GetMimeTypeForFile (string filename)
		{
			lock (lock_object) {
				Instance.StartByFileName (filename);
			}
			
			return Instance.global_result;
		}
		
		// not tested
		public static string GetMimeTypeForData (byte[] data)
		{
			lock (lock_object) {
				Instance.StartDataLookup (data);
			}
			
			return Instance.global_result;
		}
		
		public static string GetMimeTypeForString (string input)
		{
			lock (lock_object) {
				Instance.StartStringLookup (input);
			}
			
			return Instance.global_result;
		}
		
		public static string GetMimeAlias (string mimetype)
		{
			return Aliases [mimetype];
		}
		
		public static string GetMimeSubClass (string mimetype)
		{
			return SubClasses [mimetype];
		}
		
		public static void CleanFileCache ()
		{
			lock (lock_object) {
				Instance.mime_file_cache.Clear ();
			}
		}
		
		private void StartByFileName (string filename)
		{
			if (mime_file_cache.ContainsKey (filename)) {
				global_result = mime_file_cache [filename];
				return;
			}
			
			current_file_name = filename;
			is_zero_file = false;
			
			global_result = octet_stream;
			
			GoByFileName ();
			
			mime_file_cache.Add (current_file_name, global_result);
			
			if (mime_file_cache.Count > mime_file_cache_max_size) {
				IEnumerator enumerator = mime_file_cache.GetEnumerator ();
				
				int counter = mime_file_cache_max_size - 500;
				
				while (enumerator.MoveNext ()) {
					mime_file_cache.Remove (enumerator.Current.ToString ());
					counter--;
					
					if (counter == 0)
						break;
				}
			}
		}
		
		private void StartDataLookup (byte[] data)
		{
			global_result = octet_stream;
			
			System.Array.Clear (buffer, 0, buffer.Length);
			
			if (data.Length > buffer.Length) {
				System.Array.Copy (data, buffer, buffer.Length);
			} else {
				System.Array.Copy (data, buffer, data.Length);
			}
			
			if (CheckMatch80Plus ())
				return;
			
			if (CheckMatchBelow80 ())
				return;
			
			CheckForBinaryOrText ();
		}
		
		private void StartStringLookup (string input)
		{
			global_result = text_plain;
			
			search_string = input;
			
			if (CheckForContentTypeString ())
				return;
		}
		
		private void GoByFileName ()
		{
			// check if we can open the file
			if (!MimeAvailable || !OpenFile ()) {
				// couldn't open the file, check globals only
				CheckGlobalPatterns ();
				
				return;
			}
			
			if (!is_zero_file) {
				// check for matches with a priority >= 80
				if (CheckMatch80Plus ())
					return;
			}
			
			// check global patterns, aka file extensions...
			// this should be done for zero size files also,
			// for example zero size file trash.ccc~ should return
			// application/x-trash instead of application/x-zerosize
			if (CheckGlobalPatterns ())
				return;
			
			// if file size is zero, no other checks are needed
			if (is_zero_file)
				return;
			
			// ok, still nothing matches then try matches with a priority < 80
			if (CheckMatchBelow80 ())
				return;
			
			// wow, still nothing... return application/octet-stream for binary data, or text/plain for textual data
			CheckForBinaryOrText ();
		}
		
		private bool CheckMatch80Plus ()
		{
			foreach (Match match in Matches80Plus) {
				if (TestMatch (match)) {
					global_result = match.MimeType;
					
					return true;
				}
			}
			
			return false;
		}
		
		// this little helper method gives us a real speed improvement
		private bool FastEndsWidth (string input, string value)
		{
			if (value.Length > input.Length)
				return false;
			
			int z = input.Length - 1;
			
			for (int i = value.Length - 1; i > -1; i--) {
				if (value [i] != input [z])
					return false;
				
				z--;
			}
			
			return true;
		}
		
		private bool FastStartsWith (string input, string value)
		{
			if (value.Length > input.Length)
				return false;
			
			for (int i = 0; i < value.Length; i++)
				if (value [i] != input [i])
					return false;
			
			return true;
		}
		
		// start always with index = 0
		private int FastIndexOf (string input, char value)
		{
			if (input.Length == 0)
				return -1;
			
			for (int i = 0; i < input.Length; i++)
				if (input [i] == value)
					return i;
			
			return -1;
		}
		
		private int FastIndexOf (string input, string value)
		{
			if (input.Length == 0)
				return -1;
			
			for (int i = 0; i < input.Length - value.Length; i++) {
				if (input [i] == value [0]) {
					int counter = 0;
					for (int z = 1; z < value.Length; z++) {
						if (input [i + z] != value [z])
							break;
						
						counter++;
					}
					if (counter == value.Length - 1) {
						return i;
					}
				}
			}
			
			return -1;
		}
		
		private void CheckGlobalResult ()
		{
			int comma_index = FastIndexOf (global_result, ',');
			
			if (comma_index != -1) {
				global_result = global_result.Substring (0, comma_index);
			}
		}
		
		private bool CheckGlobalPatterns ()
		{
			string filename = Path.GetFileName (current_file_name);
			
			// first check for literals
			for (int i = 0; i < GlobalLiterals.Count; i++) {
				string key = GlobalLiterals.GetKey (i);
				
				// no regex char
				if (FastIndexOf (key, '[') == -1) {
					if (FastIndexOf (filename, key) != -1) {
						global_result = GlobalLiterals [i];
						CheckGlobalResult ();
						return true;
					}
				} else {
					if (Regex.IsMatch (filename, key)) {
						global_result = GlobalLiterals [i];
						CheckGlobalResult ();
						return true;
					}
				}
			}
			
			if (FastIndexOf (filename, '.') != -1) {
				// check for double extension like .tar.gz
				for (int i = 0; i < GlobalPatternsLong.Count; i++) {
					string key = GlobalPatternsLong.GetKey (i);
					
					if (FastEndsWidth (filename, key)) {
						global_result = GlobalPatternsLong [i];
						CheckGlobalResult ();
						return true;
					} else {
						if (FastEndsWidth (filename.ToLower (), key)) {
							global_result = GlobalPatternsLong [i];
							CheckGlobalResult ();
							return true;
						}
					}
				}
				
				// check normal extensions...
				string extension = Path.GetExtension (current_file_name);
				
				if (extension.Length != 0) {
					string global_result_tmp = GlobalPatternsShort [extension];
					
					if (global_result_tmp != null) {
						global_result = global_result_tmp;
						CheckGlobalResult ();
						return true;
					}
					
					global_result_tmp = GlobalPatternsShort [extension.ToLower ()];
					
					if (global_result_tmp != null) {
						global_result = global_result_tmp;
						CheckGlobalResult ();
						return true;
					}
				}
			}
			
			// finally check if a prefix or suffix matches
			for (int i = 0; i < GlobalSufPref.Count; i++) {
				string key = GlobalSufPref.GetKey (i);
				
				if (key [0] == '*') {
					if (FastEndsWidth (filename, key.Replace ("*", String.Empty))) {
						global_result = GlobalSufPref [i];
						CheckGlobalResult ();
						return true;
					}
				} else {
					if (FastStartsWith (filename, key.Replace ("*", String.Empty))) {
						global_result = GlobalSufPref [i];
						CheckGlobalResult ();
						return true;
					}
				}
			}
			
			return false;
		}
		
		private bool CheckMatchBelow80 ()
		{
			foreach (Match match in MatchesBelow80) {
				if (TestMatch (match)) {
					global_result = match.MimeType;
					
					return true;
				}
			}
			
			return false;
		}
		
		private void CheckForBinaryOrText ()
		{
			// check the first 32 bytes
			
			for (int i = 0; i < 32; i++) {
				char c = System.Convert.ToChar (buffer [i]);
				
				if (c != '\t' &&  c != '\n' && c != '\r' && c != 12 && c < 32) {
					global_result = octet_stream;
					return;
				}
			}
			
			global_result = text_plain;
		}
		
		private bool TestMatch (Match match)
		{
			foreach (Matchlet matchlet in match.Matchlets)
				if (TestMatchlet (matchlet))
					return true;
			
			return false;
		}
		
		private bool TestMatchlet (Matchlet matchlet)
		{
			//  using a simple brute force search algorithm
			// compare each (masked) value from the buffer with the (masked) value from the matchlet
			
			// no need to check if the offset + the bytevalue length exceed the # bytes read
			if (matchlet.Offset + matchlet.ByteValue.Length > bytes_read)
				return false;
			
			for (int offset_counter = 0; offset_counter < matchlet.OffsetLength; offset_counter++) {
				if (matchlet.Offset + offset_counter + matchlet.ByteValue.Length > bytes_read)
					return false;
				
				if (matchlet.Mask == null) {
					if (buffer [matchlet.Offset + offset_counter] == matchlet.ByteValue [0]) {
						if (matchlet.ByteValue.Length == 1) {
							if (matchlet.Matchlets.Count > 0) {
								foreach (Matchlet sub_matchlet in matchlet.Matchlets) {
									if (TestMatchlet (sub_matchlet))
										return true;
								}
							} else
								return true;
						}
						
						int minus = 0;
						// check if the last matchlet byte value is the same as the byte value in the buffer...
						if (matchlet.ByteValue.Length > 2) {
							if (buffer [matchlet.Offset + offset_counter + matchlet.ByteValue.Length - 1] != matchlet.ByteValue [matchlet.ByteValue.Length - 1])
								return false;
							
							minus = 1;
						}
						
						for (int i = 1; i < matchlet.ByteValue.Length - minus; i++) {
							if (buffer [matchlet.Offset + offset_counter + i] != matchlet.ByteValue [i])
								return false;
						}
						
						if (matchlet.Matchlets.Count > 0) {
							foreach (Matchlet sub_matchlets in matchlet.Matchlets) {
								if (TestMatchlet (sub_matchlets))
									return true;
							}
						} else
							return true;
					}
				} else {
					if ((buffer [matchlet.Offset + offset_counter] & matchlet.Mask [0])  ==
					    (matchlet.ByteValue [0] & matchlet.Mask [0])) {
						if (matchlet.ByteValue.Length == 1) {
							if (matchlet.Matchlets.Count > 0) {
								foreach (Matchlet sub_matchlets in matchlet.Matchlets) {
									if (TestMatchlet (sub_matchlets))
										return true;
								}
							} else
								return true;
						}
						
						int minus = 0;
						// check if the last matchlet byte value is the same as the byte value in the buffer...
						if (matchlet.ByteValue.Length > 2) {
							
							if ((buffer [matchlet.Offset + offset_counter + matchlet.ByteValue.Length - 1] & matchlet.Mask [matchlet.ByteValue.Length - 1])
							    != (matchlet.ByteValue [matchlet.ByteValue.Length - 1] & matchlet.Mask [matchlet.ByteValue.Length - 1]))
								return false;
							
							minus = 1;
						}
						
						for (int i = 1; i < matchlet.ByteValue.Length - minus; i++) {
							if ((buffer [matchlet.Offset + offset_counter + i]  & matchlet.Mask [i]) !=
							    (matchlet.ByteValue [i] & matchlet.Mask [i]))
								return false;
						}
						
						if (matchlet.Matchlets.Count > 0) {
							foreach (Matchlet sub_matchlets in matchlet.Matchlets) {
								if (TestMatchlet (sub_matchlets))
									return true;
							}
						} else
							return true;
					}
				}
			}
			
			return false;
		}
		
		private bool OpenFile ()
		{
			try {
				file_stream = new FileStream (current_file_name, FileMode.Open, FileAccess.Read); // FileShare ??? use BinaryReader ???
				
				if (file_stream.Length == 0) {
					global_result = zero_file;
					is_zero_file = true;
				} else {
					bytes_read = file_stream.Read (buffer, 0, buffer.Length);
					
					// do not clear the whole buffer everytime; clear only what's needed
					if (bytes_read < buffer.Length) {
						System.Array.Clear (buffer, bytes_read, buffer.Length - bytes_read);
					}
				}
				
				file_stream.Close ();
			} catch (Exception) {
				return false;
			}
			
			return true;
		}
		
		private bool CheckForContentTypeString ()
		{
			int index = search_string.IndexOf ("Content-type:");
			
			if (index != -1) {
				index += 13; // Length of string "Content-type:"
				
				global_result = String.Empty;
				
				while (search_string [index] != ';') {
					global_result += search_string [index++];
				}
				
				global_result.Trim ();
				
				return true;
			}
			
			// convert string to byte array
			byte[] string_byte = (new ASCIIEncoding ()).GetBytes (search_string);
			
			System.Array.Clear (buffer, 0, buffer.Length);
			
			if (string_byte.Length > buffer.Length) {
				System.Array.Copy (string_byte, buffer, buffer.Length);
			} else {
				System.Array.Copy (string_byte, buffer, string_byte.Length);
			}
			
			if (CheckMatch80Plus ())
				return true;
			
			if (CheckMatchBelow80 ())
				return true;
			
			return false;
		}
	}
	
	internal class FDOMimeConfigReader
	{
		bool fdo_mime_available = false;
		StringCollection shared_mime_paths = new StringCollection ();
		BinaryReader br;
		
		int max_offset_and_range = 0;
		
		public int Init ()
		{
			int p = (int) Environment.OSVersion.Platform;
			if ((p != 4) && (p != 6) && (p != 128))
				// Not running on Unix.
				return -1;

			CheckFDOMimePaths ();
			
			if (!fdo_mime_available)
				return -1;
			
			ReadMagicData ();
			
			ReadGlobsData ();
			
			ReadSubclasses ();
			
			ReadAliases ();
			
			shared_mime_paths = null;
			br = null;
			
			return max_offset_and_range;
		}
		
		private void CheckFDOMimePaths ()
		{
			if (Directory.Exists ("/usr/share/mime"))
				shared_mime_paths.Add ("/usr/share/mime/");
			else
			if (Directory.Exists ("/usr/local/share/mime"))
				shared_mime_paths.Add ("/usr/local/share/mime/");
			
			if (Directory.Exists (System.Environment.GetFolderPath (Environment.SpecialFolder.Personal) + "/.local/share/mime"))
				shared_mime_paths.Add (System.Environment.GetFolderPath (Environment.SpecialFolder.Personal) + "/.local/share/mime/");
			
			if (shared_mime_paths.Count == 0)
				return;
			
			fdo_mime_available = true;
		}
		
		private void ReadMagicData ()
		{
			foreach (string path in shared_mime_paths) {
				if (!File.Exists (path + "/magic"))
					continue;
				
				try {
					FileStream fs = File.OpenRead (path + "/magic");
					br = new BinaryReader (fs);
					
					if (CheckMagicHeader ()) {
						MakeMatches ();
					}
					
					br.Close ();
					fs.Close ();
				} catch (Exception ) {
				}
			}
		}
		
		private void MakeMatches ()
		{
			Matchlet[] matchlets = new Matchlet [30];
			
			while (br.PeekChar () != -1) {
				int priority = -1;
				string mime_type = ReadPriorityAndMimeType (ref priority);
				
				if (mime_type != null) {
					Match match = new Match ();
					match.Priority = priority;
					match.MimeType = mime_type;
					
					while (true) {
						int indent = 0;
						// indent
						char c;
						if (br.PeekChar () != '>') {
							StringBuilder indent_string = new StringBuilder ();
							//string indent_string = String.Empty;
							while (true) {
								if (br.PeekChar () == '>')
									break;
								
								c = br.ReadChar ();
								//indent_string += c;
								indent_string.Append (c);
							}
							indent = Convert.ToInt32 (indent_string.ToString ());
						}
						
						int offset = 0;
						
						// offset
						if (br.PeekChar () == '>') {
							br.ReadChar ();
							offset = ReadValue ();
						}
						
						int value_length = 0;
						byte[] value = null;
						// value length and value
						if (br.PeekChar () == '=') {
							br.ReadChar ();
							
							// read 2 bytes value length (always big endian)
							byte first = br.ReadByte ();
							byte second = br.ReadByte ();
							
							value_length = first * 256 + second;
							
							value = br.ReadBytes (value_length);
						}
						
						// mask
						byte[] mask = null;
						
						if (br.PeekChar () == '&') {
							br.ReadChar ();
							
							mask = br.ReadBytes (value_length);
						}
						
						// word_size
						int word_size = 1;
						if (br.PeekChar () == '~') {
							br.ReadChar ();
							
							c = br.ReadChar ();
							
							word_size = Convert.ToInt32 (c - 0x30);
							
							// data is stored in big endian format. 
							if (word_size > 1 && System.BitConverter.IsLittleEndian) {
								//convert the value and, if available, the mask data to little endian
								if (word_size == 2) {
									if (value != null) {
										for (int i = 0; i < value.Length; i += 2) {
											byte one = value [i];
											byte two = value [i + 1];
											value [i] = two;
											value [i + 1] = one;
										}
									}
									if (mask != null) {
										for (int i = 0; i < mask.Length; i += 2) {
											byte one = mask [i];
											byte two = mask [i + 1];
											mask [i] = two;
											mask [i + 1] = one;
										}
									}
								} else if (word_size == 4) {
									if (value != null) {
										for (int i = 0; i < value.Length; i += 4) {
											byte one = value [i];
											byte two = value [i + 1];
											byte three = value [i + 2];
											byte four = value [i + 3];
											value [i] = four;
											value [i + 1] = three;
											value [i + 2] = two;
											value [i + 3] = one;
										}
									}
									if (mask != null) {
										for (int i = 0; i < mask.Length; i += 4) {
											byte one = mask [i];
											byte two = mask [i + 1];
											byte three = mask [i + 2];
											byte four = mask [i + 3];
											mask [i] = four;
											mask [i + 1] = three;
											mask [i + 2] = two;
											mask [i + 3] = one;
											
										}
									}
								}
							}
						}
						
						// range length
						int range_length = 1;
						if (br.PeekChar () == '+') {
							br.ReadChar ();
							range_length = ReadValue ();
						}
						
						// read \n
						br.ReadChar ();
						
						// create the matchlet
						matchlets [indent] = new Matchlet ();
						matchlets [indent].Offset = offset;
						matchlets [indent].OffsetLength = range_length;
						matchlets [indent].ByteValue = value;
						if (mask != null)
							matchlets [indent].Mask = mask;
						
						if (indent == 0) {
							match.Matchlets.Add (matchlets [indent]);
						} else {
							matchlets [indent - 1].Matchlets.Add (matchlets [indent]);
						}
						
						if (max_offset_and_range < matchlets [indent].Offset + matchlets [indent].OffsetLength + matchlets [indent].ByteValue.Length + 1)
							max_offset_and_range = matchlets [indent].Offset + matchlets [indent].OffsetLength + matchlets [indent].ByteValue.Length  + 1;
						
						// if '[' move to next mime type
						if (br.PeekChar () == '[')
							break;
					}
					
					if (priority < 80)
						Mime.MatchesBelow80.Add (match);
					else
						Mime.Matches80Plus.Add (match);
				}
			}
		}
		
		private void ReadGlobsData ()
		{
			foreach (string path in shared_mime_paths) {
				if (!File.Exists (path + "/globs"))
					continue;
				
				try {
					StreamReader sr = new StreamReader (path + "/globs");
					
					while (sr.Peek () != -1) {
						string line = sr.ReadLine ().Trim ();
						
						if (line.StartsWith ("#"))
							continue;
						
						string[] split = line.Split (new char [] {':'});
						
						if (split [1].IndexOf ('*') > -1 && split [1].IndexOf ('.') == -1) {
							Mime.GlobalSufPref.Add (split [1], split [0]);
						} else if (split [1]. IndexOf ('*') == -1) {
							Mime.GlobalLiterals.Add (split [1], split [0]);
						} else {
							string[] split2 = split [1].Split (new char [] {'.'});
							
							if (split2.Length > 2) {
								// more than one dot
								Mime.GlobalPatternsLong.Add (split [1].Remove (0, 1), split [0]);
							} else {
								// normal
								Mime.GlobalPatternsShort.Add (split [1].Remove (0, 1), split [0]);
							}
						}
					}
					
					sr.Close ();
				} catch (Exception ) {
				}
			}
		}
		
		private void ReadSubclasses ()
		{
			foreach (string path in shared_mime_paths) {
				if (!File.Exists (path + "/subclasses"))
					continue;
				
				try {
					StreamReader sr = new StreamReader (path + "/subclasses");
					
					while (sr.Peek () != -1) {
						string line = sr.ReadLine ().Trim ();
						
						if (line.StartsWith ("#"))
							continue;
						
						string[] split = line.Split (new char [] {' '});
						
						Mime.SubClasses.Add (split [0], split [1]);
					}
					
					sr.Close ();
				} catch (Exception ) {
				}
			}
		}
		
		private void ReadAliases ()
		{
			foreach (string path in shared_mime_paths) {
				if (!File.Exists (path + "/aliases"))
					continue;
				
				try {
					StreamReader sr = new StreamReader (path + "/aliases");
					
					while (sr.Peek () != -1) {
						string line = sr.ReadLine ().Trim ();
						
						if (line.StartsWith ("#"))
							continue;
						
						string[] split = line.Split (new char [] {' '});
						
						Mime.Aliases.Add (split [0], split [1]);
					}
					
					sr.Close ();
				} catch (Exception ) {
				}
			}
		}
		
		private int ReadValue ()
		{
			StringBuilder result_string = new StringBuilder ();
			int result = 0;
			char c;
			
			while (true) {
				if (br.PeekChar () == '=' || br.PeekChar () == '\n')
					break;
				
				c = br.ReadChar ();
				result_string.Append (c);
			}
			
			result = Convert.ToInt32 (result_string.ToString ());
			
			return result;
		}
		
		private string ReadPriorityAndMimeType (ref int priority)
		{
			if (br.ReadChar () == '[') {
				StringBuilder priority_string = new StringBuilder ();
				while (true) {
					char c = br.ReadChar ();
					if (c == ':')
						break;
					priority_string.Append (c);
				}
				
				priority = System.Convert.ToInt32 (priority_string.ToString ());
				
				StringBuilder mime_type_result = new StringBuilder ();
				while (true) {
					char c = br.ReadChar ();
					if (c == ']')
						break;
					
					mime_type_result.Append (c);
				}
				
				if (br.ReadChar () == '\n')
					return mime_type_result.ToString ();
			}
			return null;
		}
		
		private bool CheckMagicHeader ()
		{
			char[] chars = br.ReadChars (10);
			string magic_header = new String (chars);
			
			if (magic_header != "MIME-Magic")
				return false;
			
			if (br.ReadByte () != 0)
				return false;
			if (br.ReadChar () != '\n')
				return false;
			
			return true;
		}
	}
	
	internal class Match
	{
		string mimeType;
		int priority;
		ArrayList matchlets = new ArrayList();
		
		public string MimeType {
			set {
				mimeType = value;
			}
			
			get {
				return mimeType;
			}
		}
		
		public int Priority {
			set {
				priority = value;
			}
			
			get {
				return priority;
			}
		}
		
		public ArrayList Matchlets {
			get {
				return matchlets;
			}
		}
	}
	
	internal class Matchlet
	{
		byte[] byteValue;
		byte[] mask = null;
		
		int offset;
		int offsetLength;
		int wordSize = 1;
		
		ArrayList matchlets = new ArrayList ();
		
		public byte[] ByteValue {
			set {
				byteValue = value;
			}
			
			get {
				return byteValue;
			}
		}
		
		public byte[] Mask {
			set {
				mask = value;
			}
			
			get {
				return mask;
			}
		}
		
		public int Offset {
			set {
				offset = value;
			}
			
			get {
				return offset;
			}
		}
		
		public int OffsetLength {
			set {
				offsetLength = value;
			}
			
			get {
				return offsetLength;
			}
		}
		
		public int WordSize {
			set {
				wordSize = value;
			}
			
			get {
				return wordSize;
			}
		}
		
		public ArrayList Matchlets {
			get {
				return matchlets;
			}
		}
	}
}