using System;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace BizHawk.Emulation.DiscSystem
{
	/// <summary>
	/// Parsing Alcohol 120% files
	/// Info taken from:
	/// * http://forum.redump.org/post/41803/#p41803
	/// * Libmirage image-mds parser - https://sourceforge.net/projects/cdemu/files/libmirage/
	/// * DiscImageChef -   https://github.com/claunia/DiscImageChef/blob/master/DiscImageChef.DiscImages/Alcohol120.cs
	/// </summary>
	public class MDS_Format
	{
		/// <summary>
		/// A loose representation of an Alcohol 120 .mds file (with a few extras)
		/// </summary>
		public class AFile
		{
			/// <summary>
			/// Full path to the MDS file
			/// </summary>
			public string MDSPath;

			/// <summary>
			/// MDS Header
			/// </summary>
			public AHeader Header = new AHeader();

			/// <summary>
			/// List of MDS session blocks
			/// </summary>
			public List<ASession> Sessions = new List<ASession>();

			/// <summary>
			/// List of track blocks
			/// </summary>
			public List<ATrack> Tracks = new List<ATrack>();

			/// <summary>
			/// Current parsed session objects
			/// </summary>
			public List<Session> ParsedSession = new List<Session>();

			/// <summary>
			/// Calculated MDS TOC entries (still to be parsed into BizHawk)
			/// </summary>
			public List<ATOCEntry> TOCEntries = new List<ATOCEntry>();
			
		}

		public class AHeader
		{
			/// <summary>
			/// Standard alcohol 120% signature - usually "MEDIA DESCRIPTOR"
			/// </summary>
			public string Signature;                // 16 bytes

			/// <summary>
			/// Alcohol version?
			/// </summary>
			public byte[] Version;                  // 2 bytes

			/// <summary>
			/// The medium type
			/// * 0x00  -   CD
			/// * 0x01  -   CD-R
			/// * 0x02  -   CD-RW
			/// * 0x10  -   DVD
			/// * 0x12  -   DVD-R
			/// </summary>
			public int Medium;

			/// <summary>
			/// Number of sessions
			/// </summary>
			public int SessionCount;

			/// <summary>
			/// Burst Cutting Area length
			/// </summary>
			public int BCALength;

			/// <summary>
			/// Burst Cutting Area data offset
			/// </summary>
			public long BCAOffset;

			/// <summary>
			/// Offset to disc (DVD?) structures
			/// </summary>
			public long StructureOffset;

			/// <summary>
			/// Offset to the first session block
			/// </summary>
			public long SessionOffset;

			/// <summary>
			/// Data Position Measurement offset
			/// </summary>
			public long DPMOffset;

			/// <summary>
			/// Parse mds stream for the header
			/// </summary>
			public AHeader Parse(Stream stream)
			{
				EndianBitConverter bc = EndianBitConverter.CreateForLittleEndian();
				EndianBitConverter bcBig = EndianBitConverter.CreateForBigEndian();
				
				byte[] header = new byte[88];
				stream.Read(header, 0, 88);

				this.Signature = Encoding.ASCII.GetString(header.Take(16).ToArray());
				this.Version = header.Skip(16).Take(2).ToArray();
				this.Medium = bc.ToInt16(header.Skip(18).Take(2).ToArray());
				this.SessionCount = bc.ToInt16(header.Skip(20).Take(2).ToArray());
				this.BCALength = bc.ToInt16(header.Skip(26).Take(2).ToArray());
				this.BCAOffset = bc.ToInt32(header.Skip(36).Take(4).ToArray());
				this.StructureOffset = bc.ToInt32(header.Skip(64).Take(4).ToArray());
				this.SessionOffset = bc.ToInt32(header.Skip(80).Take(4).ToArray());
				this.DPMOffset = bc.ToInt32(header.Skip(84).Take(4).ToArray());

				return this;
			}
		}

		/// <summary>
		/// MDS session block representation
		/// </summary>
		public class ASession
		{
			public int SessionStart;        /* Session's start address */
			public int SessionEnd;          /* Session's end address */
			public int SessionNumber;       /* Session number */
			public byte AllBlocks;          /* Number of all data blocks. */
			public byte NonTrackBlocks;     /* Number of lead-in data blocks */
			public int FirstTrack;          /* First track in session */
			public int LastTrack;           /* Last track in session */
			public long TrackOffset;       /* Offset of lead-in+regular track data blocks. */
		}

		/// <summary>
		/// Representation of an MDS track block
		/// For convenience (and extra confusion) this also holds the track extrablock, filename(footer) block infos
		/// as well as the calculated image filepath as specified in the MDS file
		/// </summary>
		public class ATrack
		{
			/// <summary>
			/// The specified data mode
			/// 0x00    -   None (no data)
			/// 0x02    -   DVD
			/// 0xA9    -   Audio
			/// 0xAA    -   Mode1
			/// 0xAB    -   Mode2
			/// 0xAC    -   Mode2 Form1
			/// 0xAD    -   Mode2 Form2
			/// </summary>
			public byte Mode;               /* Track mode */

			/// <summary>
			/// Subchannel mode for the track (0x00 = None, 0x08 = Interleaved)
			/// </summary>
			public byte SubMode;            /* Subchannel mode */

			/* These are the fields from Sub-channel Q information, which are
                also returned in full TOC by READ TOC/PMA/ATIP command */
			public int ADR_Control;         /* Adr/Ctl */
			public int TrackNo;             /* Track number field */
			public int Point;               /* Point field (= track number for track entries) */
			public int AMin;                /* Min */
			public int ASec;                /* Sec */
			public int AFrame;              /* Frame */
			public int Zero;                /* Zero */
			public int PMin;                /* PMin */
			public int PSec;                /* PSec */
			public int PFrame;              /* PFrame */

			public long ExtraOffset;       /* Start offset of this track's extra block. */
			public int SectorSize;          /* Sector size. */
			public long PLBA;               /* Track start sector (PLBA). */
			public ulong StartOffset;       /* Track start offset (from beginning of MDS file) */
			public long Files;             /* Number of filenames for this track */
			public long FooterOffset;      /* Start offset of footer (from beginning of MDS file) */

			/// <summary>
			/// Track extra block
			/// </summary>
			public ATrackExtra ExtraBlock = new ATrackExtra();

			/// <summary>
			/// List of footer(filename) blocks for this track
			/// </summary>
			public List<AFooter> FooterBlocks = new List<AFooter>();

			/// <summary>
			/// List of the calculated full paths to this track's image file
			/// The MDS file itself may contain a filename, or just an *.extension
			/// </summary>
			public List<string> ImageFileNamePaths = new List<string>();

			public int BlobIndex;
		}

		/// <summary>
		/// Extra track block
		/// </summary>
		public class ATrackExtra
		{
			public long Pregap;            /* Number of sectors in pregap. */
			public long Sectors;           /* Number of sectors in track. */
		}

		/// <summary>
		/// Footer (filename) block - potentially one for every track
		/// </summary>
		public class AFooter
		{
			public long FilenameOffset;    /* Start offset of image filename string (from beginning of mds file) */
			public long WideChar;          /* Seems to be set to 1 if widechar filename is used */
		}

		/// <summary>
		/// Represents a parsed MDS TOC entry
		/// </summary>
		public class ATOCEntry
		{
			public ATOCEntry(int entryNum)
			{
				EntryNum = entryNum;
			}

			/// <summary>
			/// these should be 0-indexed
			/// </summary>
			public int EntryNum;


			/// <summary>
			/// 1-indexed - the session that this entry belongs to
			/// </summary>
			public int Session;

//          /// <summary>
//          /// this seems just to be the LBA corresponding to AMIN:ASEC:AFRAME (give or take 150). It's not stored on the disc, and it's redundant.
//          /// </summary>
//          public int ALBA;

			/// <summary>
			/// this seems just to be the LBA corresponding to PMIN:PSEC:PFRAME (give or take 150).
			/// </summary>
			public int PLBA;

			//these correspond pretty directly to values in the Q subchannel fields
			//NOTE: they're specified as absolute MSF. That means, they're 2 seconds off from what they should be when viewed as final TOC values
			public int ADR_Control;
			public int TrackNo;
			public int Point;
			public int AMin;
			public int ASec;
			public int AFrame;
			public int Zero;
			public int PMin;
			public int PSec;
			public int PFrame;


			public int SectorSize;
			public long TrackOffset;

			/// <summary>
			/// List of the calculated full paths to this track's image file
			/// The MDS file itself may contain a filename, or just an *.extension
			/// </summary>
			public List<string> ImageFileNamePaths = new List<string>();

			/// <summary>
			/// Track extra block
			/// </summary>
			public ATrackExtra ExtraBlock = new ATrackExtra();

			public int BlobIndex;
		}

		/// <exception cref="MDSParseException">header is malformed or identifies file as MDS 2.x, or any track has a DVD mode</exception>
		public AFile Parse(Stream stream)
		{
			EndianBitConverter bc = EndianBitConverter.CreateForLittleEndian();
			EndianBitConverter bcBig = EndianBitConverter.CreateForBigEndian();
			bool isDvd = false;

			var aFile = new AFile
			{
				MDSPath = (stream as FileStream).Name
			};

			stream.Seek(0, SeekOrigin.Begin);

			// check whether the header in the mds file is long enough
			if (stream.Length < 88) throw new MDSParseException("Malformed MDS format: The descriptor file does not appear to be long enough.");

			// parse header
			aFile.Header = aFile.Header.Parse(stream);

			// check version to make sure this is only v1.x
			// currently NO support for version 2.x

			if (aFile.Header.Version[0] > 1)
			{
				throw new MDSParseException($"MDS Parse Error: Only MDS version 1.x is supported!\nDetected version: {aFile.Header.Version[0]}.{aFile.Header.Version[1]}");
			}

			// parse sessions
			Dictionary<int, ASession> aSessions = new Dictionary<int, ASession>();

			stream.Seek(aFile.Header.SessionOffset, SeekOrigin.Begin);
			for (int se = 0; se < aFile.Header.SessionCount; se++)
			{
				byte[] sessionHeader = new byte[24];
				stream.Read(sessionHeader, 0, 24);
				//sessionHeader.Reverse().ToArray();

				var session = new ASession
				{
					SessionStart = bc.ToInt32(sessionHeader.Take(4).ToArray()),
					SessionEnd = bc.ToInt32(sessionHeader.Skip(4).Take(4).ToArray()),
					SessionNumber = bc.ToInt16(sessionHeader.Skip(8).Take(2).ToArray()),
					AllBlocks = sessionHeader[10],
					NonTrackBlocks = sessionHeader[11],
					FirstTrack = bc.ToInt16(sessionHeader.Skip(12).Take(2).ToArray()),
					LastTrack = bc.ToInt16(sessionHeader.Skip(14).Take(2).ToArray()),
					TrackOffset = bc.ToInt32(sessionHeader.Skip(20).Take(4).ToArray())
				};

				//mdsf.Sessions.Add(session);
				aSessions.Add(session.SessionNumber, session);
			}

			long footerOffset = 0;

			// parse track blocks
			Dictionary<int, ATrack> aTracks = new Dictionary<int, ATrack>();

			// iterate through each session block
			foreach (ASession session in aSessions.Values)
			{
				stream.Seek(session.TrackOffset, SeekOrigin.Begin);
				//Dictionary<int, ATrack> sessionToc = new Dictionary<int, ATrack>();

				// iterate through every block specified in each session
				for (int bl = 0; bl < session.AllBlocks; bl++)
				{
					byte[] trackHeader;
					ATrack track = new ATrack();

					trackHeader = new byte[80];

					stream.Read(trackHeader, 0, 80);

					track.Mode = trackHeader[0];
					track.SubMode = trackHeader[1];
					track.ADR_Control = trackHeader[2];
					track.TrackNo = trackHeader[3];
					track.Point = trackHeader[4];
					track.AMin = trackHeader[5];
					track.ASec = trackHeader[6];
					track.AFrame = trackHeader[7];
					track.Zero = trackHeader[8];
					track.PMin = trackHeader[9];
					track.PSec = trackHeader[10];
					track.PFrame = trackHeader[11];
					track.ExtraOffset = bc.ToInt32(trackHeader.Skip(12).Take(4).ToArray());
					track.SectorSize = bc.ToInt16(trackHeader.Skip(16).Take(2).ToArray());
					track.PLBA = bc.ToInt32(trackHeader.Skip(36).Take(4).ToArray());
					track.StartOffset = BitConverter.ToUInt64(trackHeader.Skip(40).Take(8).ToArray(), 0);
					track.Files = bc.ToInt32(trackHeader.Skip(48).Take(4).ToArray());
					track.FooterOffset = bc.ToInt32(trackHeader.Skip(52).Take(4).ToArray());

					if (track.Mode == 0x02)
					{
						isDvd = true;
						throw new MDSParseException("DVD Detected. Not currently supported!");
					}
						

					// check for track extra block - this can probably be handled in a separate loop,
					// but I'll just store the current stream position then seek forward to the extra block for this track
					long currPos = stream.Position;

					// Only CDs have extra blocks - for DVDs ExtraOffset = track length
					if (track.ExtraOffset > 0 && !isDvd)
					{
						byte[] extHeader = new byte[8];
						stream.Seek(track.ExtraOffset, SeekOrigin.Begin);
						stream.Read(extHeader, 0, 8);
						track.ExtraBlock.Pregap = bc.ToInt32(extHeader.Take(4).ToArray());
						track.ExtraBlock.Sectors = bc.ToInt32(extHeader.Skip(4).Take(4).ToArray());
						stream.Seek(currPos, SeekOrigin.Begin);
					}
					else if (isDvd == true)
					{
						track.ExtraBlock.Sectors = track.ExtraOffset;
					}

					// read the footer/filename block for this track
					currPos = stream.Position;
					long numOfFilenames = track.Files;
					for (long fi = 1; fi <= numOfFilenames; fi++)
					{
						// skip leadin/out info tracks
						if (track.FooterOffset == 0)
							continue;

						byte[] foot = new byte[16];
						stream.Seek(track.FooterOffset, SeekOrigin.Begin);
						stream.Read(foot, 0, 16);

						var f = new AFooter
						{
							FilenameOffset = bc.ToInt32(foot.Take(4).ToArray()),
							WideChar = bc.ToInt32(foot.Skip(4).Take(4).ToArray())
						};
						track.FooterBlocks.Add(f);
						track.FooterBlocks = track.FooterBlocks.Distinct().ToList();

						// parse the filename string
						string fileName = "*.mdf";
						if (f.FilenameOffset > 0)
						{
							// filename offset is present
							stream.Seek(f.FilenameOffset, SeekOrigin.Begin);
							byte[] fname;

							if (numOfFilenames == 1)
							{
								if (aFile.Header.DPMOffset == 0)
								{
									// filename is in the remaining space to EOF
									fname = new byte[stream.Length - stream.Position];
								}
								else
								{
									// filename is in the remaining space to EOF + dpm offset
									fname = new byte[aFile.Header.DPMOffset - stream.Position];
								}
							}

							else
							{
								// looks like each filename string is 6 bytes with a trailing \0
								fname = new byte[6];
							}
							

							// read the filename
							stream.Read(fname, 0, fname.Length);

							// if widechar is 1 filename is stored using 16-bit, otherwise 8-bit is used
							if (f.WideChar == 1)
								fileName = Encoding.Unicode.GetString(fname).TrimEnd('\0');
							else
								fileName = Encoding.Default.GetString(fname).TrimEnd('\0');
						}

						else
						{
							// assume an MDF file with the same name as the MDS
						}

						string dir = Path.GetDirectoryName(aFile.MDSPath);

						if (f.FilenameOffset == 0 ||
							string.Compare(fileName, "*.mdf", StringComparison.InvariantCultureIgnoreCase) == 0)
						{
							fileName = $@"{dir}\{Path.GetFileNameWithoutExtension(aFile.MDSPath)}.mdf";
						}
						else
						{
							fileName = $@"{dir}\{fileName}";
						}

						track.ImageFileNamePaths.Add(fileName);
						track.ImageFileNamePaths = track.ImageFileNamePaths.Distinct().ToList();
					}

					stream.Position = currPos;


					aTracks.Add(track.Point, track);
					aFile.Tracks.Add(track);

					if (footerOffset == 0)
						footerOffset = track.FooterOffset;
				}
			}

			
			// build custom session object
			aFile.ParsedSession = new List<Session>();
			foreach (var s in aSessions.Values)
			{
				Session session = new Session();

				if (!aTracks.TryGetValue(s.FirstTrack, out var startTrack))
				{
					break;
				}

				if (!aTracks.TryGetValue(s.LastTrack, out var endTrack))
				{
					break;
				}

				session.StartSector = startTrack.PLBA;
				session.StartTrack = s.FirstTrack;
				session.SessionSequence = s.SessionNumber;
				session.EndSector = endTrack.PLBA + endTrack.ExtraBlock.Sectors - 1;
				session.EndTrack = s.LastTrack;

				aFile.ParsedSession.Add(session);
			}

			// now build the TOC object
			foreach (var se in aFile.ParsedSession)
				foreach (var t in aTracks.Values
					.Where(a => se.StartTrack <= a.TrackNo && a.TrackNo <= se.EndTrack)
					.OrderBy(a => a.TrackNo))
				{
					aFile.TOCEntries.Add(new ATOCEntry(t.Point)
					{
						ADR_Control = t.ADR_Control,
						AFrame = t.AFrame,
						AMin = t.AMin,
						ASec = t.ASec,
						BlobIndex = t.BlobIndex,
						EntryNum = t.TrackNo,
						ExtraBlock = t.ExtraBlock,
						ImageFileNamePaths = t.ImageFileNamePaths,
						PFrame = t.PFrame,
						PLBA = Convert.ToInt32(t.PLBA),
						PMin = t.PMin,
						Point = t.Point,
						PSec = t.PSec,
						SectorSize = t.SectorSize,
						Session = se.SessionSequence,
						TrackOffset = Convert.ToInt64(t.StartOffset),
						Zero = t.Zero
					});
				}

			return aFile;
		}

		/// <summary>
		/// Custom session object
		/// </summary>
		public class Session
		{
			public long StartSector;
			public int StartTrack;
			public int SessionSequence;
			public long EndSector;
			public int EndTrack;
		}


		public class MDSParseException : Exception
		{
			public MDSParseException(string message) : base(message) { }
		}
		

		public class LoadResults
		{
			public List<RawTOCEntry> RawTOCEntries;
			public AFile ParsedMDSFile;
			public bool Valid;
			public MDSParseException FailureException;
			public string MdsPath;
		}

		public static LoadResults LoadMDSPath(string path)
		{
			var ret = new LoadResults { MdsPath = path };
			//ret.MdfPath = Path.ChangeExtension(path, ".mdf");
			try
			{
				if (!File.Exists(path)) throw new MDSParseException("Malformed MDS format: nonexistent MDS file!");

				AFile mdsf;
				using (var infMDS = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
					mdsf = new MDS_Format().Parse(infMDS);

				ret.ParsedMDSFile = mdsf;

				ret.Valid = true;
			}
			catch (MDSParseException ex)
			{
				ret.FailureException = ex;
			}

			return ret;
		}

		/// <exception cref="MDSParseException">path reference no longer points to file</exception>
		Dictionary<int, IBlob> MountBlobs(AFile mdsf, Disc disc)
		{
			Dictionary<int, IBlob> BlobIndex = new Dictionary<int, IBlob>();

			int count = 0;
			foreach (var track in mdsf.Tracks)
			{
				foreach (var file in track.ImageFileNamePaths.Distinct())
				{
					if (!File.Exists(file))
						throw new MDSParseException($"Malformed MDS format: nonexistent image file: {file}");

					IBlob mdfBlob = null;
					long mdfLen = -1;

					//mount the file			
					if (mdfBlob == null)
					{
						var mdfFile = new Disc.Blob_RawFile() { PhysicalPath = file };
						mdfLen = mdfFile.Length;
						mdfBlob = mdfFile;
					}

					bool dupe = false;
					foreach (var re in disc.DisposableResources)
					{
						if (re.ToString() == mdfBlob.ToString())
							dupe = true;
					}

					if (!dupe)
					{
						// wrap in zeropadadapter
						disc.DisposableResources.Add(mdfBlob);
						BlobIndex[count++] = mdfBlob;
					}
				}
			}

			return BlobIndex;
		}

		RawTOCEntry EmitRawTOCEntry(ATOCEntry entry)
		{
			BCD2 tno, ino;

			//this should actually be zero. im not sure if this is stored as BCD2 or not
			tno = BCD2.FromDecimal(entry.TrackNo);

			//these are special values.. I think, taken from this:
			//http://www.staff.uni-mainz.de/tacke/scsi/SCSI2-14.html
			//the CCD will contain Points as decimal values except for these specially converted decimal values which should stay as BCD. 
			//Why couldn't they all be BCD? I don't know. I guess because BCD is inconvenient, but only A0 and friends have special meaning. It's confusing.
			ino = BCD2.FromDecimal(entry.Point);
			if (entry.Point == 0xA0) ino.BCDValue = 0xA0;
			else if (entry.Point == 0xA1) ino.BCDValue = 0xA1;
			else if (entry.Point == 0xA2) ino.BCDValue = 0xA2;

			// get ADR & Control from ADR_Control byte
			byte adrc = Convert.ToByte(entry.ADR_Control);
			var Control = adrc & 0x0F;
			var ADR = adrc >> 4;

			var q = new SubchannelQ
			{
				q_status = SubchannelQ.ComputeStatus(ADR, (EControlQ)(Control & 0xF)),
				q_tno = tno,
				q_index = ino,
				min = BCD2.FromDecimal(entry.AMin),
				sec = BCD2.FromDecimal(entry.ASec),
				frame = BCD2.FromDecimal(entry.AFrame),
				zero = (byte)entry.Zero,
				ap_min = BCD2.FromDecimal(entry.PMin),
				ap_sec = BCD2.FromDecimal(entry.PSec),
				ap_frame = BCD2.FromDecimal(entry.PFrame),
				q_crc = 0, //meaningless
			};

			return new RawTOCEntry { QData = q };
		}

		/// <exception cref="MDSParseException">no file found at <paramref name="mdsPath"/> or BLOB error</exception>
		public Disc LoadMDSToDisc(string mdsPath, DiscMountPolicy IN_DiscMountPolicy)
		{
			var loadResults = LoadMDSPath(mdsPath);
			if (!loadResults.Valid)
				throw loadResults.FailureException;

			Disc disc = new Disc();

			// load all blobs
			Dictionary<int, IBlob> BlobIndex = MountBlobs(loadResults.ParsedMDSFile, disc);

			var mdsf = loadResults.ParsedMDSFile;
			
			//generate DiscTOCRaw items from the ones specified in the MDS file
			disc.RawTOCEntries = new List<RawTOCEntry>();
			foreach (var entry in mdsf.TOCEntries)
			{
				disc.RawTOCEntries.Add(EmitRawTOCEntry(entry));
			}

			//analyze the RAWTocEntries to figure out what type of track track 1 is
			var tocSynth = new Synthesize_DiscTOC_From_RawTOCEntries_Job() { Entries = disc.RawTOCEntries };
			tocSynth.Run();

			// now build the sectors
			int currBlobIndex = 0;
			foreach (var session in mdsf.ParsedSession)
			{
				for (int i = session.StartTrack; i <= session.EndTrack; i++)
				{
					int relMSF = -1;

					var track = mdsf.TOCEntries.Where(t => t.Point == i).FirstOrDefault();
					if (track == null)
						break;

					// ignore the info entries
					if (track.Point == 0xA0 ||
					track.Point == 0xA1 ||
					track.Point == 0xA2)
					{
						continue;
					}

					// get the blob(s) for this track
					// its probably a safe assumption that there will be only one blob per track, 
					// but i'm still not 100% sure on this 
					var tr = (from a in mdsf.TOCEntries
								  where a.Point == i
								  select a).FirstOrDefault();

					if (tr == null)
						throw new MDSParseException("BLOB Error!");

					List<string> blobstrings = new List<string>();
					foreach (var t in tr.ImageFileNamePaths)
					{
						if (!blobstrings.Contains(t))
							blobstrings.Add(t);
					}

					var tBlobs = (from a in tr.ImageFileNamePaths
									 select a).ToList();

					if (tBlobs.Count < 1)
						throw new MDSParseException("BLOB Error!");

					// is the currBlob valid for this track, or do we need to increment?   
					string bString = tBlobs.First();

					IBlob mdfBlob = null;
					
					// check for track pregap and create if necessary
					// this is specified in the track extras block
					if (track.ExtraBlock.Pregap > 0)
					{
						CUE.CueTrackType pregapTrackType = CUE.CueTrackType.Audio;
						if (tocSynth.Result.TOCItems[1].IsData)
						{
							if (tocSynth.Result.Session1Format == SessionFormat.Type20_CDXA)
								pregapTrackType = CUE.CueTrackType.Mode2_2352;
							else if (tocSynth.Result.Session1Format == SessionFormat.Type10_CDI)
								pregapTrackType = CUE.CueTrackType.CDI_2352;
							else if (tocSynth.Result.Session1Format == SessionFormat.Type00_CDROM_CDDA)
								pregapTrackType = CUE.CueTrackType.Mode1_2352;
						}
						for (int pre = 0; pre < track.ExtraBlock.Pregap; pre++)
						{
							relMSF++;

							var ss_gap = new CUE.SS_Gap()
							{
								Policy = IN_DiscMountPolicy,
								TrackType = pregapTrackType
							};
							disc._Sectors.Add(ss_gap);

							int qRelMSF = pre - Convert.ToInt32(track.ExtraBlock.Pregap);

							//tweak relMSF due to ambiguity/contradiction in yellowbook docs
							if (!IN_DiscMountPolicy.CUE_PregapContradictionModeA)
								qRelMSF++;

							//setup subQ
							byte ADR = 1; //absent some kind of policy for how to set it, this is a safe assumption:
							ss_gap.sq.SetStatus(ADR, tocSynth.Result.TOCItems[1].Control);
							ss_gap.sq.q_tno = BCD2.FromDecimal(1);
							ss_gap.sq.q_index = BCD2.FromDecimal(0);
							ss_gap.sq.AP_Timestamp = pre;
							ss_gap.sq.Timestamp = qRelMSF;

							//setup subP
							ss_gap.Pause = true;
						}
						// pregap processing completed
					}



					// create track sectors
					long currBlobOffset = track.TrackOffset;
					for (long sector = session.StartSector; sector <= session.EndSector; sector++)
					{
						CUE.SS_Base sBase = null;

						// get the current blob from the BlobIndex
						Disc.Blob_RawFile currBlob = BlobIndex[currBlobIndex] as Disc.Blob_RawFile;
						long currBlobLength = currBlob.Length;
						long currBlobPosition = sector;
						if (currBlobPosition == currBlobLength)
							currBlobIndex++;
						mdfBlob = disc.DisposableResources[currBlobIndex] as Disc.Blob_RawFile;

						//int userSector = 2048;
						switch (track.SectorSize)
						{
							case 2448:
								sBase = new CUE.SS_2352()
								{
									Policy = IN_DiscMountPolicy                                 
								};
								//userSector = 2352;                          
								break;
							case 2048:
							default:
								sBase = new CUE.SS_Mode1_2048()
								{
									Policy = IN_DiscMountPolicy
								};
								//userSector = 2048;
								break;
							
								//throw new Exception($"Not supported: Sector Size {track.SectorSize}");
						}

						// configure blob
						sBase.Blob = mdfBlob;
						sBase.BlobOffset = currBlobOffset;

						currBlobOffset += track.SectorSize; // userSector;
						
						// add subchannel data
						relMSF++;
						BCD2 tno, ino;

						//this should actually be zero. im not sure if this is stored as BCD2 or not
						tno = BCD2.FromDecimal(track.TrackNo);

						//these are special values.. I think, taken from this:
						//http://www.staff.uni-mainz.de/tacke/scsi/SCSI2-14.html
						//the CCD will contain Points as decimal values except for these specially converted decimal values which should stay as BCD. 
						//Why couldn't they all be BCD? I don't know. I guess because BCD is inconvenient, but only A0 and friends have special meaning. It's confusing.
						ino = BCD2.FromDecimal(track.Point);
						if (track.Point == 0xA0) ino.BCDValue = 0xA0;
						else if (track.Point == 0xA1) ino.BCDValue = 0xA1;
						else if (track.Point == 0xA2) ino.BCDValue = 0xA2;

						// get ADR & Control from ADR_Control byte
						byte adrc = Convert.ToByte(track.ADR_Control);
						var Control = adrc & 0x0F;
						var ADR = adrc >> 4;

						var q = new SubchannelQ
						{
							q_status = SubchannelQ.ComputeStatus(ADR, (EControlQ)(Control & 0xF)),
							q_tno = BCD2.FromDecimal(track.Point),
							q_index = ino,
							AP_Timestamp = disc._Sectors.Count,
							Timestamp = relMSF - Convert.ToInt32(track.ExtraBlock.Pregap)
						};

						sBase.sq = q;

						disc._Sectors.Add(sBase);
						
					}
				}
			}

			return disc;
		}

	} //class MDS_Format
}