﻿using System;
using System.IO;
using System.Collections.Generic;

using BizHawk.Common;

//HOW TO USE
//we dont expect anyone to use this fully yet. It's just over-engineered for future use.
//for now, just use it when you truly dont know what to do with a file.
//This system depends heavily on the provided extension. We're not going to exhaustively try every format all the time. If someone loads a cue which is named .sfc, we cant cope with that. 
//However, common mistakes will be handled, on an as-needed basis.

//TODO - check for archives too? further, check archive contents (probably just based on filename)?
//TODO - parameter to enable checks vs firmware, game databases
//TODO (in client) - costly hashes could happen only once the file type is known (and a hash for that filetype could be used)

namespace BizHawk.Emulation.Cores
{
	/// <summary>
	/// Each of these should ideally represent a single file type.
	/// However for now they just may resemble a console, and a core would know how to parse some set of those after making its own determination.
	/// If formats are very similar but with small differences, and that determination can be made, then it will be in the ExtraInfo in the FileIDResult
	/// </summary>
	public enum FileIDType
	{
		None, 
		Multiple, //dont think this makes sense. shouldnt the multiple options be returned?

		Disc, //an unknown disc
		PSX, PSX_EXE, PSF,
		PSP, 
		Saturn, MegaCD,

		PCE, SGX, TurboCD,
		INES, FDS, UNIF, NSF,
		SFC, N64,
		GB, GBC, GBA, NDS,
		COL,
		SG, SMS, GG, S32X,
		SMD, //http://en.wikibooks.org/wiki/Genesis_Programming#ROM_header
		
		WS, WSC, NGC,

		C64, 
		INT,
		A26, A52, A78, LNX,

		JAD, SBI,
		M3U,

		//audio codec formats
		WAV, APE, MPC, FLAC,
		MP3, //can't be ID'd very readily..
		
		//misc disc-related files:
		ECM
	}

	public class FileIDResult
	{
		public FileIDResult()
		{
		}

		public FileIDResult(FileIDType type, int confidence)
		{
			FileIDType = type;
			Confidence = confidence;
		}

		public FileIDResult(FileIDType type)
		{
			FileIDType = type;
		}

		/// <summary>
		/// a percentage between 0 and 100 assessing the confidence of this result
		/// </summary>
		public int Confidence;

		/// <summary>
		/// 
		/// </summary>
		public FileIDType FileIDType;

		/// <summary>
		/// extra information which could be easily gotten during the file ID (region, suspected homebrew, CRC invalid, etc.)
		/// </summary>
		public Dictionary<string, object> ExtraInfo = new Dictionary<string, object>();
	}

	public class FileIDResults : List<FileIDResult>
	{
		public FileIDResults() { }
		public FileIDResults(FileIDResult item)
		{
			base.Add(item);
		}
		public new void Sort()
		{
			base.Sort((x, y) => x.Confidence.CompareTo(y.Confidence));
		}

		/// <summary>
		/// indicates whether the client should try again after mounting the disc image for further inspection
		/// </summary>
		public bool ShouldTryDisc;
	}

	public class FileID
	{
		/// <summary>
		/// parameters for an Identify job
		/// </summary>
		public class IdentifyParams
		{
			/// <summary>
			/// The extension of the original file (with or without the .)
			/// </summary>
			public string Extension;

			/// <summary>
			/// a seekable stream which can be used
			/// </summary>
			public Stream SeekableStream;

			/// <summary>
			/// the file in question mounted as a disc
			/// </summary>
			public DiscSystem.Disc Disc;
		}

		class IdentifyJob
		{
			public Stream Stream;
			public string Extension;
			public DiscSystem.Disc Disc;
		}

		/// <summary>
		/// performs wise heuristics to identify a file.
		/// this will attempt to return early if a confident result can be produced.
		/// </summary>
		public FileIDResults Identify(IdentifyParams p)
		{
			IdentifyJob job = new IdentifyJob() { 
				Stream = p.SeekableStream,
				Disc = p.Disc
			};

			//if we have a disc, that's a separate codepath
			if (job.Disc != null)
				return IdentifyDisc(job);

			FileIDResults ret = new FileIDResults();

			string ext = p.Extension;
			if(ext != null)
			{
				ext = ext.TrimStart('.').ToUpper();
				job.Extension = ext;
			}

			if (job.Extension == "CUE")
			{
				ret.ShouldTryDisc = true;
				return ret;
			}

			if(job.Extension != null)
			{
				//first test everything associated with this extension
				ExtensionInfo handler = null;
				if (ExtensionHandlers.TryGetValue(ext, out handler))
				{
					foreach (var del in handler.Testers)
					{
						var fidr = del(job);
						if (fidr.FileIDType == FileIDType.None)
							continue;
						ret.Add(fidr);
					}

					ret.Sort();

					//add a low confidence result just based on extension, if it doesnt exist
					if(ret.Find( (x) => x.FileIDType == handler.DefaultForExtension) == null)
					{
						var fidr = new FileIDResult(handler.DefaultForExtension, 5);
						ret.Add(fidr);
					}
				}
			}

			ret.Sort();

			//if we didnt find anything high confidence, try all the testers (TODO)

			return ret;
		}

		/// <summary>
		/// performs wise heuristics to identify a file (simple version)
		/// </summary>
		public FileIDType IdentifySimple(IdentifyParams p)
		{
			var ret = Identify(p);
			if (ret.ShouldTryDisc)
				return FileIDType.Disc;
			if (ret.Count == 0)
				return FileIDType.None;
			else if(ret.Count == 1)
				return ret[0].FileIDType;
			else if (ret[0].Confidence == ret[1].Confidence)
				return FileIDType.Multiple;
			else return ret[0].FileIDType;
		}

		FileIDResults IdentifyDisc(IdentifyJob job)
		{
			var discIdentifier = new DiscSystem.DiscIdentifier(job.Disc);
			//DiscSystem could use some newer approaches from this file (instead of parsing ISO filesystem... maybe?)
			switch (discIdentifier.DetectDiscType())
			{
				case DiscSystem.DiscType.SegaSaturn:
					return new FileIDResults(new FileIDResult(FileIDType.Saturn, 100));

				case DiscSystem.DiscType.SonyPSP:
					return new FileIDResults(new FileIDResult(FileIDType.PSP, 100));

				case DiscSystem.DiscType.SonyPSX:
					return new FileIDResults(new FileIDResult(FileIDType.PSX, 100));

				case DiscSystem.DiscType.MegaCD:
					return new FileIDResults(new FileIDResult(FileIDType.MegaCD, 100));

				case DiscSystem.DiscType.TurboCD:
					return new FileIDResults(new FileIDResult(FileIDType.TurboCD, 5));

				case DiscSystem.DiscType.UnknownCDFS:
				case DiscSystem.DiscType.UnknownFormat:
				default:
					return new FileIDResults(new FileIDResult());
			}
		}

		class SimpleMagicRecord
		{
			public int Offset;
			public string Key;
			public int Length = -1;
			public Func<Stream,bool> ExtraCheck;
		}

		//some of these (NES, UNIF for instance) should be lower confidence probably...
		//if you change some of the Length arguments for longer keys, please make notes about why
		static class SimpleMagics
		{
			public static SimpleMagicRecord INES = new SimpleMagicRecord { Offset = 0, Key = "NES" };
			public static SimpleMagicRecord UNIF = new SimpleMagicRecord { Offset = 0, Key = "UNIF" };
			public static SimpleMagicRecord NSF = new SimpleMagicRecord { Offset = 0, Key = "NESM\x1A" }; 

			public static SimpleMagicRecord FDS_HEADERLESS = new SimpleMagicRecord { Offset = 0, Key = "\x01*NINTENDO-HVC*" };
			public static SimpleMagicRecord FDS_HEADER = new SimpleMagicRecord { Offset = 0, Key = "FDS\x1A" };

			//the GBA nintendo logo.. we'll only use 16 bytes of it but theyre all here, for reference
			//we cant expect these roms to be normally sized, but we may be able to find other features of the header to use for extra checks
			public static SimpleMagicRecord GBA = new SimpleMagicRecord {  Offset = 4, Length = 16, Key = "\x24\xFF\xAE\x51\x69\x9A\xA2\x21\x3D\x84\x82\x0A\x84\xE4\x09\xAD\x11\x24\x8B\x98\xC0\x81\x7F\x21\xA3\x52\xBE\x19\x93\x09\xCE\x20\x10\x46\x4A\x4A\xF8\x27\x31\xEC\x58\xC7\xE8\x33\x82\xE3\xCE\xBF\x85\xF4\xDF\x94\xCE\x4B\x09\xC1\x94\x56\x8A\xC0\x13\x72\xA7\xFC\x9F\x84\x4D\x73\xA3\xCA\x9A\x61\x58\x97\xA3\x27\xFC\x03\x98\x76\x23\x1D\xC7\x61\x03\x04\xAE\x56\xBF\x38\x84\x00\x40\xA7\x0E\xFD\xFF\x52\xFE\x03\x6F\x95\x30\xF1\x97\xFB\xC0\x85\x60\xD6\x80\x25\xA9\x63\xBE\x03\x01\x4E\x38\xE2\xF9\xA2\x34\xFF\xBB\x3E\x03\x44\x78\x00\x90\xCB\x88\x11\x3A\x94\x65\xC0\x7C\x63\x87\xF0\x3C\xAF\xD6\x25\xE4\x8B\x38\x0A\xAC\x72\x21\xD4\xF8\x07" };
			public static SimpleMagicRecord NDS = new SimpleMagicRecord { Offset = 0xC0, Length = 16, Key = "\x24\xFF\xAE\x51\x69\x9A\xA2\x21\x3D\x84\x82\x0A\x84\xE4\x09\xAD\x11\x24\x8B\x98\xC0\x81\x7F\x21\xA3\x52\xBE\x19\x93\x09\xCE\x20\x10\x46\x4A\x4A\xF8\x27\x31\xEC\x58\xC7\xE8\x33\x82\xE3\xCE\xBF\x85\xF4\xDF\x94\xCE\x4B\x09\xC1\x94\x56\x8A\xC0\x13\x72\xA7\xFC\x9F\x84\x4D\x73\xA3\xCA\x9A\x61\x58\x97\xA3\x27\xFC\x03\x98\x76\x23\x1D\xC7\x61\x03\x04\xAE\x56\xBF\x38\x84\x00\x40\xA7\x0E\xFD\xFF\x52\xFE\x03\x6F\x95\x30\xF1\x97\xFB\xC0\x85\x60\xD6\x80\x25\xA9\x63\xBE\x03\x01\x4E\x38\xE2\xF9\xA2\x34\xFF\xBB\x3E\x03\x44\x78\x00\x90\xCB\x88\x11\x3A\x94\x65\xC0\x7C\x63\x87\xF0\x3C\xAF\xD6\x25\xE4\x8B\x38\x0A\xAC\x72\x21\xD4\xF8\x07" };

			public static SimpleMagicRecord GB = new SimpleMagicRecord {  Offset=0x104, Length = 16, Key = "\xCE\xED\x66\x66\xCC\x0D\x00\x0B\x03\x73\x00\x83\x00\x0C\x00\x0D\x00\x08\x11\x1F\x88\x89\x00\x0E\xDC\xCC\x6E\xE6\xDD\xDD\xD9\x99\xBB\xBB\x67\x63\x6E\x0E\xEC\xCC\xDD\xDC\x99\x9F\xBB\xB9\x33\x3E" };

			public static SimpleMagicRecord S32X = new SimpleMagicRecord { Offset = 0x100, Key = "SEGA 32X" };

			public static SimpleMagicRecord SEGAGENESIS = new SimpleMagicRecord { Offset = 0x100, Key = "SEGA GENESIS" };
			public static SimpleMagicRecord SEGAMEGADRIVE = new SimpleMagicRecord { Offset = 0x100, Key = "SEGA MEGA DRIVE" };
			public static SimpleMagicRecord SEGASATURN = new SimpleMagicRecord { Offset = 0, Key = "SEGA SEGASATURN" };
			public static SimpleMagicRecord SEGADISCSYSTEM = new SimpleMagicRecord { Offset = 0, Key = "SEGADISCSYSTEM" };

			public static SimpleMagicRecord PSX = new SimpleMagicRecord { Offset = 0x24E0, Key = "  Licensed  by          Sony Computer Entertainment" }; //there might be other ideas for checking in mednafen sources, if we need them
			public static SimpleMagicRecord PSX_EXE = new SimpleMagicRecord { Key = "PS-X EXE\0" };
			public static SimpleMagicRecord PSP = new SimpleMagicRecord { Offset = 0x8000, Key = "\x01CD001\x01\0x00PSP GAME" };
			public static SimpleMagicRecord PSF = new SimpleMagicRecord { Offset = 0, Key = "PSF\x1" };

			//https://sites.google.com/site/atari7800wiki/a78-header
			public static SimpleMagicRecord A78 = new SimpleMagicRecord { Offset = 0, Key = "\x01ATARI7800" };

			//could be at various offsets?
			public static SimpleMagicRecord TMR_SEGA = new SimpleMagicRecord { Offset = 0x7FF0, Key = "TMR SEGA" };

			public static SimpleMagicRecord SBI = new SimpleMagicRecord { Key = "SBI\0" };
			public static SimpleMagicRecord M3U = new SimpleMagicRecord { Key = "#EXTM3U" }; //note: M3U may not have this. EXTM3U only has it. We'll still catch it by extension though.

			public static SimpleMagicRecord ECM = new SimpleMagicRecord { Key = "ECM\0" };
			public static SimpleMagicRecord FLAC = new SimpleMagicRecord { Key = "fLaC" };
			public static SimpleMagicRecord MPC = new SimpleMagicRecord { Key = "MP+", ExtraCheck = (s) => { s.Position += 3; return s.ReadByte() >= 7; } };
			public static SimpleMagicRecord APE = new SimpleMagicRecord { Key = "MAC " };
			public static SimpleMagicRecord[] WAV = new SimpleMagicRecord[] {
				new SimpleMagicRecord { Offset = 0, Key = "RIFF" },
				new SimpleMagicRecord { Offset = 8, Key = "WAVEfmt " }
			};
		}

		class ExtensionInfo
		{
			public ExtensionInfo(FileIDType defaultForExtension, FormatTester tester)
			{
				Testers = new List<FormatTester>(1);
				if(tester != null)
					Testers.Add(tester);
				DefaultForExtension = defaultForExtension;
			}

			public FileIDType DefaultForExtension;
			public List<FormatTester> Testers;
		}

		/// <summary>
		/// testers to try for each extension, along with a default for the extension
		/// </summary>
		static Dictionary<string, ExtensionInfo> ExtensionHandlers = new Dictionary<string, ExtensionInfo> {
		  { "NES", new ExtensionInfo(FileIDType.INES, Test_INES ) },
			{ "FDS", new ExtensionInfo(FileIDType.FDS, Test_FDS ) },
			{ "GBA", new ExtensionInfo(FileIDType.GBA, (j)=>Test_Simple(j,FileIDType.GBA,SimpleMagics.GBA) ) },
			{ "NDS", new ExtensionInfo(FileIDType.NDS, (j)=>Test_Simple(j,FileIDType.NDS,SimpleMagics.NDS) ) },
			{ "UNF", new ExtensionInfo(FileIDType.UNIF, Test_UNIF ) },
			{ "UNIF", new ExtensionInfo(FileIDType.UNIF, Test_UNIF ) },
			{ "GB", new ExtensionInfo(FileIDType.GB, Test_GB_GBC ) },
			{ "GBC", new ExtensionInfo(FileIDType.GBC, Test_GB_GBC ) },
			{ "N64", new ExtensionInfo(FileIDType.N64, Test_N64 ) },
			{ "Z64", new ExtensionInfo(FileIDType.N64, Test_N64 ) },
			{ "V64", new ExtensionInfo(FileIDType.N64, Test_N64 ) },
			{ "A78", new ExtensionInfo(FileIDType.A78, Test_A78 ) },
			{ "SMS", new ExtensionInfo(FileIDType.SMS, Test_SMS ) },

			{ "BIN", new ExtensionInfo(FileIDType.Multiple, Test_BIN_ISO ) },
			{ "ISO", new ExtensionInfo(FileIDType.Multiple, Test_BIN_ISO ) },
			{ "M3U", new ExtensionInfo(FileIDType.M3U, (j)=>Test_Simple(j,FileIDType.M3U,SimpleMagics.M3U) ) },

			{ "JAD", new ExtensionInfo(FileIDType.Multiple, Test_JAD_JAC ) },
			{ "JAC", new ExtensionInfo(FileIDType.Multiple, Test_JAD_JAC ) },
			{ "SBI", new ExtensionInfo(FileIDType.SBI, (j)=>Test_Simple(j,FileIDType.SBI,SimpleMagics.SBI) ) },

			{ "EXE", new ExtensionInfo(FileIDType.PSX_EXE, (j)=>Test_Simple(j,FileIDType.PSX_EXE,SimpleMagics.PSX_EXE) ) },

			//royal mess
			{ "MD", new ExtensionInfo(FileIDType.SMD, null ) },
			{ "SMD", new ExtensionInfo(FileIDType.SMD, null ) },
			{ "GEN", new ExtensionInfo(FileIDType.SMD, null ) },

			//nothing yet...
			{ "PSF", new ExtensionInfo(FileIDType.PSF, (j)=>Test_Simple(j,FileIDType.PSF,SimpleMagics.PSF) ) },
			{ "INT", new ExtensionInfo(FileIDType.INT, null) },
			{ "SFC", new ExtensionInfo(FileIDType.SFC, null) },
			{ "SMC", new ExtensionInfo(FileIDType.SFC, null) },
			{ "LNX", new ExtensionInfo(FileIDType.LNX, null ) },
			{ "SG", new ExtensionInfo(FileIDType.SG, null ) },
			{ "SGX", new ExtensionInfo(FileIDType.SGX, null ) },
			{ "COL", new ExtensionInfo(FileIDType.COL, null ) },
			{ "A52", new ExtensionInfo(FileIDType.A52, null ) },
			{ "A26", new ExtensionInfo(FileIDType.A26, null ) },
			{ "PCE", new ExtensionInfo(FileIDType.PCE, null ) },
			{ "GG", new ExtensionInfo(FileIDType.GG, null ) },
			{ "WS", new ExtensionInfo(FileIDType.WS, null ) },
			{ "WSC", new ExtensionInfo(FileIDType.WSC, null ) },
			{ "NGC", new ExtensionInfo(FileIDType.NGC, null ) },
			{ "32X", new ExtensionInfo(FileIDType.S32X, (j)=>Test_Simple(j,FileIDType.S32X,SimpleMagics.S32X) ) },

			//various C64 formats.. can we distinguish between these?
			{ "PRG", new ExtensionInfo(FileIDType.C64, null ) },
			{ "D64", new ExtensionInfo(FileIDType.C64, null ) },
			{ "T64", new ExtensionInfo(FileIDType.C64, null ) },
			{ "G64", new ExtensionInfo(FileIDType.C64, null ) },
			{ "CRT", new ExtensionInfo(FileIDType.C64, null ) },
			{ "NIB", new ExtensionInfo(FileIDType.C64, null ) }, //not supported yet
			
			//for now
			{ "ROM", new ExtensionInfo(FileIDType.Multiple, null ) }, //could be MSX too

			{ "MP3", new ExtensionInfo(FileIDType.MP3, null ) },
			{ "WAV", new ExtensionInfo(FileIDType.WAV, (j)=>Test_Simple(j,FileIDType.WAV,SimpleMagics.WAV) ) },
			{ "APE", new ExtensionInfo(FileIDType.APE, (j)=>Test_Simple(j,FileIDType.APE,SimpleMagics.APE) ) },
			{ "MPC", new ExtensionInfo(FileIDType.MPC, (j)=>Test_Simple(j,FileIDType.MPC,SimpleMagics.MPC) ) },
			{ "FLAC", new ExtensionInfo(FileIDType.FLAC, (j)=>Test_Simple(j,FileIDType.FLAC,SimpleMagics.FLAC) ) },
			{ "ECM", new ExtensionInfo(FileIDType.ECM, (j)=>Test_Simple(j,FileIDType.ECM,SimpleMagics.ECM) ) },
		};

		delegate FileIDResult FormatTester(IdentifyJob job);

		static int[] no_offsets = new int[] { 0 };

		/// <summary>
		/// checks for the magic string (bytewise ASCII check) at the given address
		/// </summary>
		static bool CheckMagic(Stream stream, IEnumerable<SimpleMagicRecord> recs, params int[] offsets)
		{
			if (offsets.Length == 0)
				offsets = no_offsets;

			foreach (int n in offsets)
			{
				bool ok = true;
				foreach (var r in recs)
				{
					if (!CheckMagicOne(stream, r, n))
					{
						ok = false;
						break;
					}
				}
				if (ok) return true;
			}
			return false;
		}

		static bool CheckMagic(Stream stream, SimpleMagicRecord rec, params int[] offsets)
		{
			return CheckMagic(stream, new SimpleMagicRecord[] { rec }, offsets);
		}

		static bool CheckMagicOne(Stream stream, SimpleMagicRecord rec, int offset)
		{
			stream.Position = rec.Offset + offset;
			string key = rec.Key;
			int len = rec.Length;
			if (len == -1)
				len = key.Length;
			for (int i = 0; i < len; i++)
			{
				int n = stream.ReadByte();
				if (n == -1) return false;
				if (n != key[i])
					return false;
			}
			if (rec.ExtraCheck != null)
			{
				stream.Position = rec.Offset + offset;
				return rec.ExtraCheck(stream);
			}
			else return true;
		}

		static int ReadByte(Stream stream, int ofs)
		{
			stream.Position = ofs;
			return stream.ReadByte();
		}

		static FileIDResult Test_INES(IdentifyJob job)
		{
			if (!CheckMagic(job.Stream, SimpleMagics.INES))
				return new FileIDResult();

			var ret = new FileIDResult(FileIDType.INES, 100);

			//an INES file should be a multiple of 8k, with the 16 byte header.
			//if it isnt.. this is fishy.
			if (((job.Stream.Length - 16) & (8 * 1024 - 1)) != 0)
				ret.Confidence = 50;

			return ret;
		}

		static FileIDResult Test_FDS(IdentifyJob job)
		{
			if (CheckMagic(job.Stream, SimpleMagics.FDS_HEADER))
				return new FileIDResult(FileIDType.FDS, 90); //kind of a small header..
			if (CheckMagic(job.Stream, SimpleMagics.FDS_HEADERLESS))
				return new FileIDResult(FileIDType.FDS, 95);

			return new FileIDResult();
		}

		/// <summary>
		/// all magics must pass
		/// </summary>
		static FileIDResult Test_Simple(IdentifyJob job, FileIDType type, SimpleMagicRecord[] magics)
		{
			var ret = new FileIDResult(type);

			if (CheckMagic(job.Stream, magics))
				return new FileIDResult(type, 100);
			else
				return new FileIDResult();
		}

		static FileIDResult Test_Simple(IdentifyJob job, FileIDType type, SimpleMagicRecord magic)
		{
			var ret = new FileIDResult(type);

			if (CheckMagic(job.Stream, magic))
				return new FileIDResult(type, 100);
			else
				return new FileIDResult();
		}

		static FileIDResult Test_UNIF(IdentifyJob job)
		{
			if (!CheckMagic(job.Stream, SimpleMagics.UNIF))
				return new FileIDResult();

			//TODO - simple parser (for starters, check for a known chunk being next, see http://wiki.nesdev.com/w/index.php/UNIF)

			var ret = new FileIDResult(FileIDType.UNIF, 100);

			return ret;
		}

		static FileIDResult Test_GB_GBC(IdentifyJob job)
		{
			if (!CheckMagic(job.Stream, SimpleMagics.GB))
				return new FileIDResult();

			var ret = new FileIDResult(FileIDType.GB, 100);
			int type = ReadByte(job.Stream, 0x143);
			if ((type & 0x80) != 0)
				ret.FileIDType = FileIDType.GBC;

			//could check cart type and rom size for extra info if necessary

			return ret;
		}

		static FileIDResult Test_SMS(IdentifyJob job)
		{
			//http://www.smspower.org/Development/ROMHeader

			//actually, not sure how to handle this yet
			return new FileIDResult();
		}

		static FileIDResult Test_N64(IdentifyJob job)
		{
			//  .Z64 = No swapping
			//  .N64 = Word Swapped
			//  .V64 = Byte Swapped

			//not sure how to check for these yet...
			var ret = new FileIDResult(FileIDType.N64, 5);
			if (job.Extension == "V64") ret.ExtraInfo["byteswap"] = true;
			if (job.Extension == "N64") ret.ExtraInfo["wordswap"] = true;
			return ret;
		}

		static FileIDResult Test_A78(IdentifyJob job)
		{
			int len = (int)job.Stream.Length;
			
			//we may have a header to analyze
			if (len % 1024 == 128)
			{
				if (CheckMagic(job.Stream, SimpleMagics.A78))
					new FileIDResult(FileIDType.A78, 100);
			}
			else if (len % 1024 == 0)
			{
			}
			else { }

			return new FileIDResult(0);
		}

		static FileIDResult Test_BIN_ISO(IdentifyJob job)
		{
			//ok, this is complicated.
			//there are lots of mislabeled bins/isos so lets just treat them the same (mostly)
			//if the BIN cant be recognized, but it is small, it is more likely some other rom BIN than a disc (turbocd or other)

			if (job.Extension == "BIN")
			{
				//first we can check for SMD magic words.
				//since this extension is ambiguous, we can't be completely sure about it. but it's almost surely accurate
				if (CheckMagic(job.Stream, SimpleMagics.SEGAGENESIS))
				{
					var ret = new FileIDResult(FileIDType.SMD, 95);
					ret.ExtraInfo["type"] = "genesis";
					return ret;
				}

				if (CheckMagic(job.Stream, SimpleMagics.SEGAMEGADRIVE))
				{
					var ret = new FileIDResult(FileIDType.SMD, 95);
					ret.ExtraInfo["type"] = "megadrive";
				}
			}

			//well... guess it's a disc.
			//since it's just a bin, we dont need the user to provide a DiscSystem disc.
			//lets just analyze this as best we can.
			//of course, it's a lot of redundant logic with the discsystem disc checker.
			//but you kind of need different approaches when loading a hugely unstructured bin file
			//discsystem won't really even be happy mounting a .bin anyway, and we don't want it to be

			//for PSX, we have a magic word to look for.
			//it's at 0x24E0 with a mode2 (2352 byte) track 1.
			//what if its 2048 byte? 
			//i found a ".iso" which was actually 2352 byte sectors..
			//found a hilarious ".bin.iso" which was actually 2352 byte sectors
			//so, I think it's possible that every valid PSX disc is mode2 in the track 1
			if (CheckMagic(job.Stream, SimpleMagics.PSX))
			{
				var ret = new FileIDResult(FileIDType.PSX, 95);
				//this is an unreliable way to get a PSX game!
				ret.ExtraInfo["unreliable"] = true;
				return ret;
			}

			//it's not proven that this is reliable. this is actually part of the Mode 1 CDFS header. perhaps it's mobile?
			//if it's mobile, we'll need to mount it as an ISO file here via discsystem
			if (CheckMagic(job.Stream, SimpleMagics.PSP))
				return new FileIDResult(FileIDType.PSP, 95);

			//if this was an ISO, we might discover the magic word at offset 0...
			//if it was a mode2/2352 bin, we might discover it at offset 16 (after the data sector header)
			if(CheckMagic(job.Stream, SimpleMagics.SEGASATURN,0))
				return new FileIDResult(FileIDType.Saturn, job.Extension == "ISO" ? 95 : 90);
			if (CheckMagic(job.Stream, SimpleMagics.SEGASATURN, 16))
				return new FileIDResult(FileIDType.Saturn, job.Extension == "BIN" ? 95 : 90);
			if (CheckMagic(job.Stream, SimpleMagics.SEGADISCSYSTEM, 0))
				return new FileIDResult(FileIDType.MegaCD, job.Extension == "ISO" ? 95 : 90);
			if (CheckMagic(job.Stream, SimpleMagics.SEGADISCSYSTEM, 16))
				return new FileIDResult(FileIDType.MegaCD, job.Extension == "BIN" ? 95 : 90);

			if (job.Extension == "ISO")
				return new FileIDResult(FileIDType.Disc, 1);
			else
				return new FileIDResult(FileIDType.Multiple, 1);
		}

		static FileIDResult Test_JAD_JAC(IdentifyJob job)
		{
			//TBD
			//just mount it as a disc and send it through the disc checker?
			return null;
		}

	}
}