// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename       : CDRWin.cs
// Author(s)      : Natalia Portillo <claunia@claunia.com>
//
// Component      : Disc image plugins.
//
// --[ Description ] ----------------------------------------------------------
//
//     Manages CDRWin cuesheets (cue/bin).
//
// --[ License ] --------------------------------------------------------------
//
//     This library is free software; you can redistribute it and/or modify
//     it under the terms of the GNU Lesser General Public License as
//     published by the Free Software Foundation; either version 2.1 of the
//     License, or (at your option) any later version.
//
//     This library is distributed in the hope that it will be useful, but
//     WITHOUT ANY WARRANTY; without even the implied warranty of
//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
//     Lesser General Public License for more details.
//
//     You should have received a copy of the GNU Lesser General Public
//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2018 Natalia Portillo
// ****************************************************************************/

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using DiscImageChef.Checksums;
using DiscImageChef.CommonTypes;
using DiscImageChef.Console;
using DiscImageChef.Filters;

namespace DiscImageChef.DiscImages
{
    // TODO: Implement track flags
    public class CdrWin : IWritableImage
    {
        // Type for FILE entity
        /// <summary>Data as-is in little-endian</summary>
        const string CDRWIN_DISK_TYPE_LITTLE_ENDIAN = "BINARY";
        /// <summary>Data as-is in big-endian</summary>
        const string CDRWIN_DISK_TYPE_BIG_ENDIAN = "MOTOROLA";
        /// <summary>Audio in Apple AIF file</summary>
        const string CDRWIN_DISK_TYPE_AIFF = "AIFF";
        /// <summary>Audio in Microsoft WAV file</summary>
        const string CDRWIN_DISK_TYPE_RIFF = "WAVE";
        /// <summary>Audio in MP3 file</summary>
        const string CDRWIN_DISK_TYPE_MP3 = "MP3";

        // Type for TRACK entity
        /// <summary>Audio track, 2352 bytes/sector</summary>
        const string CDRWIN_TRACK_TYPE_AUDIO = "AUDIO";
        /// <summary>CD+G track, 2448 bytes/sector (audio+subchannel)</summary>
        const string CDRWIN_TRACK_TYPE_CDG = "CDG";
        /// <summary>Mode 1 track, cooked, 2048 bytes/sector</summary>
        const string CDRWIN_TRACK_TYPE_MODE1 = "MODE1/2048";
        /// <summary>Mode 1 track, raw, 2352 bytes/sector</summary>
        const string CDRWIN_TRACK_TYPE_MODE1_RAW = "MODE1/2352";
        /// <summary>Mode 2 form 1 track, cooked, 2048 bytes/sector</summary>
        const string CDRWIN_TRACK_TYPE_MODE2_FORM1 = "MODE2/2048";
        /// <summary>Mode 2 form 2 track, cooked, 2324 bytes/sector</summary>
        const string CDRWIN_TRACK_TYPE_MODE2_FORM2 = "MODE2/2324";
        /// <summary>Mode 2 formless track, cooked, 2336 bytes/sector</summary>
        const string CDRWIN_TRACK_TYPE_MODE2_FORMLESS = "MODE2/2336";
        /// <summary>Mode 2 track, raw, 2352 bytes/sector</summary>
        const string CDRWIN_TRACK_TYPE_MODE2_RAW = "MODE2/2352";
        /// <summary>CD-i track, cooked, 2336 bytes/sector</summary>
        const string CDRWIN_TRACK_TYPE_CDI = "CDI/2336";
        /// <summary>CD-i track, raw, 2352 bytes/sector</summary>
        const string CDRWIN_TRACK_TYPE_CDI_RAW = "CDI/2352";

        // Type for REM ORIGINAL MEDIA-TYPE entity
        /// <summary>DiskType.CD</summary>
        const string CDRWIN_DISK_TYPE_CD = "CD";
        /// <summary>DiskType.CDRW</summary>
        const string CDRWIN_DISK_TYPE_CDRW = "CD-RW";
        /// <summary>DiskType.CDMRW</summary>
        const string CDRWIN_DISK_TYPE_CDMRW = "CD-MRW";
        /// <summary>DiskType.CDMRW</summary>
        const string CDRWIN_DISK_TYPE_CDMRW2 = "CD-(MRW)";
        /// <summary>DiskType.DVDROM</summary>
        const string CDRWIN_DISK_TYPE_DVD = "DVD";
        /// <summary>DiskType.DVDPRW</summary>
        const string CDRWIN_DISK_TYPE_DVDPMRW = "DVD+MRW";
        /// <summary>DiskType.DVDPRW</summary>
        const string CDRWIN_DISK_TYPE_DVDPMRW2 = "DVD+(MRW)";
        /// <summary>DiskType.DVDPRWDL</summary>
        const string CDRWIN_DISK_TYPE_DVDPMRWDL = "DVD+MRW DL";
        /// <summary>DiskType.DVDPRWDL</summary>
        const string CDRWIN_DISK_TYPE_DVDPMRWDL2 = "DVD+(MRW) DL";
        /// <summary>DiskType.DVDPR</summary>
        const string CDRWIN_DISK_TYPE_DVDPR = "DVD+R";
        /// <summary>DiskType.DVDPRDL</summary>
        const string CDRWIN_DISK_TYPE_DVDPRDL = "DVD+R DL";
        /// <summary>DiskType.DVDPRW</summary>
        const string CDRWIN_DISK_TYPE_DVDPRW = "DVD+RW";
        /// <summary>DiskType.DVDPRWDL</summary>
        const string CDRWIN_DISK_TYPE_DVDPRWDL = "DVD+RW DL";
        /// <summary>DiskType.DVDPR</summary>
        const string CDRWIN_DISK_TYPE_DVDPVR = "DVD+VR";
        /// <summary>DiskType.DVDRAM</summary>
        const string CDRWIN_DISK_TYPE_DVDRAM = "DVD-RAM";
        /// <summary>DiskType.DVDR</summary>
        const string CDRWIN_DISK_TYPE_DVDR = "DVD-R";
        /// <summary>DiskType.DVDRDL</summary>
        const string CDRWIN_DISK_TYPE_DVDRDL = "DVD-R DL";
        /// <summary>DiskType.DVDRW</summary>
        const string CDRWIN_DISK_TYPE_DVDRW = "DVD-RW";
        /// <summary>DiskType.DVDRWDL</summary>
        const string CDRWIN_DISK_TYPE_DVDRWDL = "DVD-RW DL";
        /// <summary>DiskType.DVDR</summary>
        const string CDRWIN_DISK_TYPE_DVDVR = "DVD-VR";
        /// <summary>DiskType.DVDRW</summary>
        const string CDRWIN_DISK_TYPE_DVDRW2 = "DVDRW";
        /// <summary>DiskType.HDDVDROM</summary>
        const string CDRWIN_DISK_TYPE_HDDVD = "HD DVD";
        /// <summary>DiskType.HDDVDRAM</summary>
        const string CDRWIN_DISK_TYPE_HDDVDRAM = "HD DVD-RAM";
        /// <summary>DiskType.HDDVDR</summary>
        const string CDRWIN_DISK_TYPE_HDDVDR = "HD DVD-R";
        /// <summary>DiskType.HDDVDR</summary>
        const string CDRWIN_DISK_TYPE_HDDVDRDL = "HD DVD-R DL";
        /// <summary>DiskType.HDDVDRW</summary>
        const string CDRWIN_DISK_TYPE_HDDVDRW = "HD DVD-RW";
        /// <summary>DiskType.HDDVDRW</summary>
        const string CDRWIN_DISK_TYPE_HDDVDRWDL = "HD DVD-RW DL";
        /// <summary>DiskType.BDROM</summary>
        const string CDRWIN_DISK_TYPE_BD = "BD";
        /// <summary>DiskType.BDR</summary>
        const string CDRWIN_DISK_TYPE_BDR = "BD-R";
        /// <summary>DiskType.BDRE</summary>
        const string CDRWIN_DISK_TYPE_BDRE = "BD-RE";
        /// <summary>DiskType.BDR</summary>
        const string CDRWIN_DISK_TYPE_BDRDL = "BD-R DL";
        /// <summary>DiskType.BDRE</summary>
        const string CDRWIN_DISK_TYPE_BDREDL = "BD-RE DL";

        const string REGEX_SESSION    = @"\bREM\s+SESSION\s+(?<number>\d+).*$";
        const string REGEX_MEDIA_TYPE = @"\bREM\s+ORIGINAL MEDIA-TYPE:\s+(?<mediatype>.+)$";
        const string REGEX_LEAD_OUT   = @"\bREM\s+LEAD-OUT\s+(?<msf>[\d]+:[\d]+:[\d]+)$";
        // Not checked
        const string REGEX_LBA        = @"\bREM MSF:\s+(?<msf>[\d]+:[\d]+:[\d]+)\s+=\s+LBA:\s+(?<lba>[\d]+)$";
        const string REGEX_DISC_ID    = @"\bDISC_ID\s+(?<diskid>[\da-f]{8})$";
        const string REGEX_BARCODE    = @"\bUPC_EAN\s+(?<barcode>[\d]{12,13})$";
        const string REGEX_COMMENT    = @"\bREM\s+(?<comment>.+)$";
        const string REGEX_CDTEXT     = @"\bCDTEXTFILE\s+(?<filename>.+)$";
        const string REGEX_MCN        = @"\bCATALOG\s+(?<catalog>\d{13})$";
        const string REGEX_TITLE      = @"\bTITLE\s+(?<title>.+)$";
        const string REGEX_GENRE      = @"\bGENRE\s+(?<genre>.+)$";
        const string REGEX_ARRANGER   = @"\bARRANGER\s+(?<arranger>.+)$";
        const string REGEX_COMPOSER   = @"\bCOMPOSER\s+(?<composer>.+)$";
        const string REGEX_PERFORMER  = @"\bPERFORMER\s+(?<performer>.+)$";
        const string REGEX_SONGWRITER = @"\bSONGWRITER\s+(?<songwriter>.+)$";
        const string REGEX_FILE       = @"\bFILE\s+(?<filename>.+)\s+(?<type>\S+)$";
        const string REGEX_TRACK      = @"\bTRACK\s+(?<number>\d+)\s+(?<type>\S+)$";
        const string REGEX_ISRC       = @"\bISRC\s+(?<isrc>\w{12})$";
        const string REGEX_INDEX      = @"\bINDEX\s+(?<index>\d+)\s+(?<msf>[\d]+:[\d]+:[\d]+)$";
        const string REGEX_PREGAP     = @"\bPREGAP\s+(?<msf>[\d]+:[\d]+:[\d]+)$";
        const string REGEX_POSTGAP    = @"\bPOSTGAP\s+(?<msf>[\d]+:[\d]+:[\d]+)$";
        const string REGEX_FLAGS      = @"\bFLAGS\s+(((?<dcp>DCP)|(?<quad>4CH)|(?<pre>PRE)|(?<scms>SCMS))\s*)+$";

        IFilter      cdrwinFilter;
        StreamReader cueStream;
        StreamWriter descriptorStream;
        CdrWinDisc   discimage;
        ImageInfo    imageInfo;
        Stream       imageStream;
        /// <summary>Dictionary, index is track #, value is TrackFile</summary>
        Dictionary<uint, ulong> offsetmap;
        bool                    separateTracksWriting;

        Dictionary<byte, byte>       trackFlags;
        Dictionary<byte, string>     trackIsrcs;
        string                       writingBaseName;
        Dictionary<uint, FileStream> writingStreams;
        List<Track>                  writingTracks;

        public CdrWin()
        {
            imageInfo = new ImageInfo
            {
                ReadableSectorTags    = new List<SectorTagType>(),
                ReadableMediaTags     = new List<MediaTagType>(),
                HasPartitions         = true,
                HasSessions           = true,
                Version               = null,
                ApplicationVersion    = null,
                MediaTitle            = null,
                Creator               = null,
                MediaManufacturer     = null,
                MediaModel            = null,
                MediaPartNumber       = null,
                MediaSequence         = 0,
                LastMediaSequence     = 0,
                DriveManufacturer     = null,
                DriveModel            = null,
                DriveSerialNumber     = null,
                DriveFirmwareRevision = null
            };
        }

        public ImageInfo Info => imageInfo;

        public string Name => "CDRWin cuesheet";
        public Guid   Id   => new Guid("664568B2-15D4-4E64-8A7A-20BDA8B8386F");

        public string Format => "CDRWin CUESheet";

        public List<Partition> Partitions { get; private set; }

        public List<Track> Tracks
        {
            get
            {
                List<Track> tracks = new List<Track>();

                ulong previousStartSector = 0;

                foreach(CdrWinTrack cdrTrack in discimage.Tracks)
                {
                    Track dicTrack = new Track
                    {
                        Indexes                = cdrTrack.Indexes,
                        TrackDescription       = cdrTrack.Title,
                        TrackStartSector       = previousStartSector,
                        TrackPregap            = cdrTrack.Pregap,
                        TrackSession           = cdrTrack.Session,
                        TrackSequence          = cdrTrack.Sequence,
                        TrackType              = CdrWinTrackTypeToTrackType(cdrTrack.Tracktype),
                        TrackFile              = cdrTrack.Trackfile.Datafilter.GetFilename(),
                        TrackFilter            = cdrTrack.Trackfile.Datafilter,
                        TrackFileOffset        = cdrTrack.Trackfile.Offset,
                        TrackFileType          = cdrTrack.Trackfile.Filetype,
                        TrackRawBytesPerSector = cdrTrack.Bps,
                        TrackBytesPerSector    = CdrWinTrackTypeToCookedBytesPerSector(cdrTrack.Tracktype)
                    };
                    dicTrack.TrackEndSector = dicTrack.TrackStartSector + cdrTrack.Sectors - 1;

                    /*if(!cdrTrack.Indexes.TryGetValue(0, out dicTrack.TrackStartSector))
                        cdrTrack.Indexes.TryGetValue(1, out dicTrack.TrackStartSector);*/
                    if(cdrTrack.Bps == 2448)
                    {
                        dicTrack.TrackSubchannelFilter = cdrTrack.Trackfile.Datafilter;
                        dicTrack.TrackSubchannelFile   = cdrTrack.Trackfile.Datafilter.GetFilename();
                        dicTrack.TrackSubchannelOffset = cdrTrack.Trackfile.Offset;
                        dicTrack.TrackSubchannelType   = TrackSubchannelType.RawInterleaved;
                    }
                    else dicTrack.TrackSubchannelType = TrackSubchannelType.None;

                    tracks.Add(dicTrack);
                    previousStartSector = dicTrack.TrackEndSector + 1;
                }

                return tracks;
            }
        }

        public List<Session> Sessions => discimage.Sessions;

        // Due to .cue format, this method must parse whole file, ignoring errors (those will be thrown by OpenImage()).
        public bool Identify(IFilter imageFilter)
        {
            cdrwinFilter = imageFilter;

            try
            {
                imageFilter.GetDataForkStream().Seek(0, SeekOrigin.Begin);
                byte[] testArray = new byte[512];
                imageFilter.GetDataForkStream().Read(testArray, 0, 512);
                imageFilter.GetDataForkStream().Seek(0, SeekOrigin.Begin);
                // Check for unexpected control characters that shouldn't be present in a text file and can crash this plugin
                bool twoConsecutiveNulls = false;
                for(int i = 0; i < 512; i++)
                {
                    if(i >= imageFilter.GetDataForkStream().Length) break;

                    if(testArray[i] == 0)
                    {
                        if(twoConsecutiveNulls) return false;

                        twoConsecutiveNulls = true;
                    }
                    else twoConsecutiveNulls = false;

                    if(testArray[i] < 0x20 && testArray[i] != 0x0A && testArray[i] != 0x0D && testArray[i] != 0x00)
                        return false;
                }

                cueStream = new StreamReader(cdrwinFilter.GetDataForkStream());

                while(cueStream.Peek() >= 0)
                {
                    string line = cueStream.ReadLine();

                    Regex sr = new Regex(REGEX_SESSION);
                    Regex rr = new Regex(REGEX_COMMENT);
                    Regex cr = new Regex(REGEX_MCN);
                    Regex fr = new Regex(REGEX_FILE);
                    Regex tr = new Regex(REGEX_CDTEXT);

                    // First line must be SESSION, REM, CATALOG,  FILE or CDTEXTFILE.
                    Match sm = sr.Match(line ?? throw new InvalidOperationException());
                    Match rm = rr.Match(line);
                    Match cm = cr.Match(line);
                    Match fm = fr.Match(line);
                    Match tm = tr.Match(line);

                    return sm.Success || rm.Success || cm.Success || fm.Success || tm.Success;
                }

                return false;
            }
            catch(Exception ex)
            {
                DicConsole.ErrorWriteLine("Exception trying to identify image file {0}", cdrwinFilter);
                DicConsole.ErrorWriteLine("Exception: {0}",                              ex.Message);
                DicConsole.ErrorWriteLine("Stack trace: {0}",                            ex.StackTrace);
                return false;
            }
        }

        public bool Open(IFilter imageFilter)
        {
            if(imageFilter == null) return false;

            cdrwinFilter = imageFilter;

            try
            {
                imageFilter.GetDataForkStream().Seek(0, SeekOrigin.Begin);
                cueStream           = new StreamReader(imageFilter.GetDataForkStream());
                int  lineNumber     = 0;
                bool intrack        = false;
                byte currentsession = 1;

                // Initialize all RegExs
                Regex regexSession    = new Regex(REGEX_SESSION);
                Regex regexDiskType   = new Regex(REGEX_MEDIA_TYPE);
                Regex regexLeadOut    = new Regex(REGEX_LEAD_OUT);
                Regex regexLba        = new Regex(REGEX_LBA);
                Regex regexDiskId     = new Regex(REGEX_DISC_ID);
                Regex regexBarCode    = new Regex(REGEX_BARCODE);
                Regex regexComment    = new Regex(REGEX_COMMENT);
                Regex regexCdText     = new Regex(REGEX_CDTEXT);
                Regex regexMcn        = new Regex(REGEX_MCN);
                Regex regexTitle      = new Regex(REGEX_TITLE);
                Regex regexGenre      = new Regex(REGEX_GENRE);
                Regex regexArranger   = new Regex(REGEX_ARRANGER);
                Regex regexComposer   = new Regex(REGEX_COMPOSER);
                Regex regexPerformer  = new Regex(REGEX_PERFORMER);
                Regex regexSongWriter = new Regex(REGEX_SONGWRITER);
                Regex regexFile       = new Regex(REGEX_FILE);
                Regex regexTrack      = new Regex(REGEX_TRACK);
                Regex regexIsrc       = new Regex(REGEX_ISRC);
                Regex regexIndex      = new Regex(REGEX_INDEX);
                Regex regexPregap     = new Regex(REGEX_PREGAP);
                Regex regexPostgap    = new Regex(REGEX_POSTGAP);
                Regex regexFlags      = new Regex(REGEX_FLAGS);

                // Initialize all RegEx matches
                Match matchTrack;

                // Initialize disc
                discimage = new CdrWinDisc
                {
                    Sessions = new List<Session>(),
                    Tracks   = new List<CdrWinTrack>(),
                    Comment  = ""
                };

                CdrWinTrack     currenttrack            = new CdrWinTrack {Indexes = new Dictionary<int, ulong>()};
                CdrWinTrackFile currentfile             = new CdrWinTrackFile();
                ulong           currentfileoffsetsector = 0;

                int trackCount = 0;

                while(cueStream.Peek() >= 0)
                {
                    lineNumber++;
                    string line = cueStream.ReadLine();

                    matchTrack = regexTrack.Match(line);
                    if(!matchTrack.Success) continue;

                    uint trackSeq = uint.Parse(matchTrack.Groups[1].Value);
                    if(trackCount + 1 != trackSeq)
                        throw new
                            FeatureUnsupportedImageException($"Found TRACK {trackSeq} out of order in line {lineNumber}");

                    trackCount++;
                }

                if(trackCount == 0) throw new FeatureUnsupportedImageException("No tracks found");

                CdrWinTrack[] cuetracks = new CdrWinTrack[trackCount];

                lineNumber = 0;
                imageFilter.GetDataForkStream().Seek(0, SeekOrigin.Begin);
                cueStream = new StreamReader(imageFilter.GetDataForkStream());

                FiltersList filtersList = new FiltersList();

                while(cueStream.Peek() >= 0)
                {
                    lineNumber++;
                    string line = cueStream.ReadLine();

                    Match matchSession  = regexSession.Match(line);
                    Match matchDiskType = regexDiskType.Match(line);
                    Match matchComment  = regexComment.Match(line);
                    Match matchLba      = regexLba.Match(line);
                    Match matchLeadOut  = regexLeadOut.Match(line);

                    if(matchDiskType.Success && !intrack)
                    {
                        DicConsole.DebugWriteLine("CDRWin plugin", "Found REM ORIGINAL MEDIA TYPE at line {0}",
                                                  lineNumber);
                        discimage.Disktypestr = matchDiskType.Groups[1].Value;
                    }
                    else if(matchDiskType.Success && intrack)
                        throw new
                            FeatureUnsupportedImageException($"Found REM ORIGINAL MEDIA TYPE field after a track in line {lineNumber}");
                    else if(matchSession.Success)
                    {
                        DicConsole.DebugWriteLine("CDRWin plugin", "Found REM SESSION at line {0}", lineNumber);
                        currentsession = byte.Parse(matchSession.Groups[1].Value);

                        // What happens between sessions
                    }
                    else if(matchLba.Success)
                        DicConsole.DebugWriteLine("CDRWin plugin", "Found REM MSF at line {0}", lineNumber);
                    else if(matchLeadOut.Success)
                        DicConsole.DebugWriteLine("CDRWin plugin", "Found REM LEAD-OUT at line {0}", lineNumber);
                    else if(matchComment.Success)
                    {
                        DicConsole.DebugWriteLine("CDRWin plugin", "Found REM at line {0}", lineNumber);
                        if(discimage.Comment == "") discimage.Comment = matchComment.Groups[1].Value; // First comment
                        else
                            discimage.Comment +=
                                Environment.NewLine + matchComment.Groups[1].Value; // Append new comments as new lines
                    }
                    else
                    {
                        matchTrack            = regexTrack.Match(line);
                        Match matchTitle      = regexTitle.Match(line);
                        Match matchSongWriter = regexSongWriter.Match(line);
                        Match matchPregap     = regexPregap.Match(line);
                        Match matchPostgap    = regexPostgap.Match(line);
                        Match matchPerformer  = regexPerformer.Match(line);
                        Match matchMcn        = regexMcn.Match(line);
                        Match matchIsrc       = regexIsrc.Match(line);
                        Match matchIndex      = regexIndex.Match(line);
                        Match matchGenre      = regexGenre.Match(line);
                        Match matchFlags      = regexFlags.Match(line);
                        Match matchFile       = regexFile.Match(line);
                        Match matchDiskId     = regexDiskId.Match(line);
                        Match matchComposer   = regexComposer.Match(line);
                        Match matchCdText     = regexCdText.Match(line);
                        Match matchBarCode    = regexBarCode.Match(line);
                        Match matchArranger   = regexArranger.Match(line);

                        if(matchArranger.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found ARRANGER at line {0}", lineNumber);
                            if(intrack) currenttrack.Arranger = matchArranger.Groups[1].Value;
                            else discimage.Arranger           = matchArranger.Groups[1].Value;
                        }
                        else if(matchBarCode.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found UPC_EAN at line {0}", lineNumber);
                            if(!intrack) discimage.Barcode = matchBarCode.Groups[1].Value;
                            else
                                throw new
                                    FeatureUnsupportedImageException($"Found barcode field in incorrect place at line {lineNumber}");
                        }
                        else if(matchCdText.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found CDTEXTFILE at line {0}", lineNumber);
                            if(!intrack) discimage.Cdtextfile = matchCdText.Groups[1].Value;
                            else
                                throw new
                                    FeatureUnsupportedImageException($"Found CD-Text file field in incorrect place at line {lineNumber}");
                        }
                        else if(matchComposer.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found COMPOSER at line {0}", lineNumber);
                            if(intrack) currenttrack.Composer = matchComposer.Groups[1].Value;
                            else discimage.Composer           = matchComposer.Groups[1].Value;
                        }
                        else if(matchDiskId.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found DISC_ID at line {0}", lineNumber);
                            if(!intrack) discimage.DiskId = matchDiskId.Groups[1].Value;
                            else
                                throw new
                                    FeatureUnsupportedImageException($"Found CDDB ID field in incorrect place at line {lineNumber}");
                        }
                        else if(matchFile.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found FILE at line {0}", lineNumber);

                            if(currenttrack.Sequence != 0)
                            {
                                currentfile.Sequence   = currenttrack.Sequence;
                                currenttrack.Trackfile = currentfile;
                                currenttrack.Sectors   =
                                    ((ulong)currentfile.Datafilter.GetLength() - currentfile.Offset) /
                                    CdrWinTrackTypeToBytesPerSector(currenttrack.Tracktype);
                                cuetracks[currenttrack.Sequence - 1] = currenttrack;
                                intrack                              = false;
                                currenttrack                         = new CdrWinTrack();
                                currentfile                          = new CdrWinTrackFile();
                                filtersList                          = new FiltersList();
                            }

                            //currentfile = new CDRWinTrackFile();
                            string datafile      = matchFile.Groups[1].Value;
                            currentfile.Filetype = matchFile.Groups[2].Value;

                            // Check if file path is quoted
                            if(datafile[0] == '"' && datafile[datafile.Length    - 1] == '"')
                                datafile = datafile.Substring(1, datafile.Length - 2); // Unquote it

                            currentfile.Datafilter = filtersList.GetFilter(datafile);

                            // Check if file exists
                            if(currentfile.Datafilter == null)
                                if(datafile[0]        == '/' || datafile[0] == '/' && datafile[1] == '.'
                                ) // UNIX absolute path
                                {
                                    Regex unixpath      = new Regex("^(.+)/([^/]+)$");
                                    Match unixpathmatch = unixpath.Match(datafile);

                                    if(unixpathmatch.Success)
                                    {
                                        currentfile.Datafilter = filtersList.GetFilter(unixpathmatch.Groups[1].Value);

                                        if(currentfile.Datafilter == null)
                                        {
                                            string path = imageFilter.GetParentFolder() + Path.PathSeparator +
                                                          unixpathmatch.Groups[1].Value;
                                            currentfile.Datafilter = filtersList.GetFilter(path);

                                            if(currentfile.Datafilter == null)
                                                throw new
                                                    FeatureUnsupportedImageException($"File \"{matchFile.Groups[1].Value}\" not found.");
                                        }
                                    }
                                    else
                                        throw new
                                            FeatureUnsupportedImageException($"File \"{matchFile.Groups[1].Value}\" not found.");
                                }
                                else if(datafile[1] == ':'  && datafile[2] == '\\' ||
                                        datafile[0] == '\\' && datafile[1] == '\\' ||
                                        datafile[0] == '.'  && datafile[1] == '\\') // Windows absolute path
                                {
                                    Regex winpath =
                                        new
                                            Regex("^(?:[a-zA-Z]\\:(\\\\|\\/)|file\\:\\/\\/|\\\\\\\\|\\.(\\/|\\\\))([^\\\\\\/\\:\\*\\?\\<\\>\\\"\\|]+(\\\\|\\/){0,1})+$");
                                    Match winpathmatch = winpath.Match(datafile);
                                    if(winpathmatch.Success)
                                    {
                                        currentfile.Datafilter = filtersList.GetFilter(winpathmatch.Groups[1].Value);

                                        if(currentfile.Datafilter == null)
                                        {
                                            string path = imageFilter.GetParentFolder() + Path.PathSeparator +
                                                          winpathmatch.Groups[1].Value;
                                            currentfile.Datafilter = filtersList.GetFilter(path);

                                            if(currentfile.Datafilter == null)
                                                throw new
                                                    FeatureUnsupportedImageException($"File \"{matchFile.Groups[1].Value}\" not found.");
                                        }
                                    }
                                    else
                                        throw new
                                            FeatureUnsupportedImageException($"File \"{matchFile.Groups[1].Value}\" not found.");
                                }
                                else
                                {
                                    string path =
                                        imageFilter.GetParentFolder() + Path.PathSeparator + datafile;
                                    currentfile.Datafilter = filtersList.GetFilter(path);

                                    if(currentfile.Datafilter == null)
                                        throw new
                                            FeatureUnsupportedImageException($"File \"{matchFile.Groups[1].Value}\" not found.");
                                }

                            // File does exist, process it
                            DicConsole.DebugWriteLine("CDRWin plugin", "File \"{0}\" found",
                                                      currentfile.Datafilter.GetFilename());

                            switch(currentfile.Filetype)
                            {
                                case CDRWIN_DISK_TYPE_LITTLE_ENDIAN: break;
                                case CDRWIN_DISK_TYPE_BIG_ENDIAN:
                                case CDRWIN_DISK_TYPE_AIFF:
                                case CDRWIN_DISK_TYPE_RIFF:
                                case CDRWIN_DISK_TYPE_MP3:
                                    throw new
                                        FeatureSupportedButNotImplementedImageException($"Unsupported file type {currentfile.Filetype}");
                                default:
                                    throw new
                                        FeatureUnsupportedImageException($"Unknown file type {currentfile.Filetype}");
                            }

                            currentfile.Offset   = 0;
                            currentfile.Sequence = 0;
                        }
                        else if(matchFlags.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found FLAGS at line {0}", lineNumber);
                            if(!intrack)
                                throw new
                                    FeatureUnsupportedImageException($"Found FLAGS field in incorrect place at line {lineNumber}");

                            currenttrack.FlagDcp  |= matchFlags.Groups["dcp"].Value  == "DCP";
                            currenttrack.Flag4ch  |= matchFlags.Groups["quad"].Value == "4CH";
                            currenttrack.FlagPre  |= matchFlags.Groups["pre"].Value  == "PRE";
                            currenttrack.FlagScms |= matchFlags.Groups["scms"].Value == "SCMS";
                        }
                        else if(matchGenre.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found GENRE at line {0}", lineNumber);
                            if(intrack) currenttrack.Genre = matchGenre.Groups[1].Value;
                            else discimage.Genre           = matchGenre.Groups[1].Value;
                        }
                        else if(matchIndex.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found INDEX at line {0}", lineNumber);
                            if(!intrack)
                                throw new FeatureUnsupportedImageException($"Found INDEX before a track {lineNumber}");

                            int   index  = int.Parse(matchIndex.Groups[1].Value);
                            ulong offset = CdrWinMsftoLba(matchIndex.Groups[2].Value);

                            if(index != 0 && index != 1 && currenttrack.Indexes.Count == 0)
                                throw new
                                    FeatureUnsupportedImageException($"Found INDEX {index} before INDEX 00 or INDEX 01");

                            if(index                                == 0 ||
                               index                                == 1 && !currenttrack.Indexes.ContainsKey(0))
                                if((int)(currenttrack.Sequence - 2) >= 0 && offset > 1)
                                {
                                    cuetracks[currenttrack.Sequence - 2].Sectors = offset - currentfileoffsetsector;
                                    currentfile.Offset                           +=
                                        cuetracks[currenttrack.Sequence - 2].Sectors *
                                        cuetracks[currenttrack.Sequence - 2].Bps;
                                    DicConsole.DebugWriteLine("CDRWin plugin",
                                                              "Sets currentfile.offset to {0} at line 553",
                                                              currentfile.Offset);
                                    DicConsole.DebugWriteLine("CDRWin plugin",
                                                              "cuetracks[currenttrack.sequence-2].sectors = {0}",
                                                              cuetracks[currenttrack.Sequence - 2].Sectors);
                                    DicConsole.DebugWriteLine("CDRWin plugin",
                                                              "cuetracks[currenttrack.sequence-2].bps = {0}",
                                                              cuetracks[currenttrack.Sequence - 2].Bps);
                                }

                            if((index                == 0 || index == 1 && !currenttrack.Indexes.ContainsKey(0)) &&
                               currenttrack.Sequence == 1)
                            {
                                DicConsole.DebugWriteLine("CDRWin plugin", "Sets currentfile.offset to {0} at line 559",
                                                          offset * currenttrack.Bps);
                                currentfile.Offset = offset      * currenttrack.Bps;
                            }

                            currentfileoffsetsector = offset;
                            currenttrack.Indexes.Add(index, offset);
                        }
                        else if(matchIsrc.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found ISRC at line {0}", lineNumber);
                            if(!intrack)
                                throw new FeatureUnsupportedImageException($"Found ISRC before a track {lineNumber}");

                            currenttrack.Isrc = matchIsrc.Groups[1].Value;
                        }
                        else if(matchMcn.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found CATALOG at line {0}", lineNumber);
                            if(!intrack) discimage.Mcn = matchMcn.Groups[1].Value;
                            else
                                throw new
                                    FeatureUnsupportedImageException($"Found CATALOG field in incorrect place at line {lineNumber}");
                        }
                        else if(matchPerformer.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found PERFORMER at line {0}", lineNumber);
                            if(intrack) currenttrack.Performer = matchPerformer.Groups[1].Value;
                            else discimage.Performer           = matchPerformer.Groups[1].Value;
                        }
                        else if(matchPostgap.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found POSTGAP at line {0}", lineNumber);
                            if(intrack) currenttrack.Postgap = CdrWinMsftoLba(matchPostgap.Groups[1].Value);
                            else
                                throw new
                                    FeatureUnsupportedImageException($"Found POSTGAP field before a track at line {lineNumber}");
                        }
                        else if(matchPregap.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found PREGAP at line {0}", lineNumber);
                            if(intrack) currenttrack.Pregap = CdrWinMsftoLba(matchPregap.Groups[1].Value);
                            else
                                throw new
                                    FeatureUnsupportedImageException($"Found PREGAP field before a track at line {lineNumber}");
                        }
                        else if(matchSongWriter.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found SONGWRITER at line {0}", lineNumber);
                            if(intrack) currenttrack.Songwriter = matchSongWriter.Groups[1].Value;
                            else discimage.Songwriter           = matchSongWriter.Groups[1].Value;
                        }
                        else if(matchTitle.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found TITLE at line {0}", lineNumber);
                            if(intrack) currenttrack.Title = matchTitle.Groups[1].Value;
                            else discimage.Title           = matchTitle.Groups[1].Value;
                        }
                        else if(matchTrack.Success)
                        {
                            DicConsole.DebugWriteLine("CDRWin plugin", "Found TRACK at line {0}", lineNumber);
                            if(currentfile.Datafilter == null)
                                throw new
                                    FeatureUnsupportedImageException($"Found TRACK field before a file is defined at line {lineNumber}");

                            if(intrack)
                            {
                                if(currenttrack.Indexes.ContainsKey(0) && currenttrack.Pregap == 0)
                                    currenttrack.Indexes.TryGetValue(0, out currenttrack.Pregap);
                                currentfile.Sequence                 = currenttrack.Sequence;
                                currenttrack.Trackfile               = currentfile;
                                cuetracks[currenttrack.Sequence - 1] = currenttrack;
                            }

                            currenttrack = new CdrWinTrack
                            {
                                Indexes  = new Dictionary<int, ulong>(),
                                Sequence = uint.Parse(matchTrack.Groups[1].Value)
                            };
                            DicConsole.DebugWriteLine("CDRWin plugin", "Setting currenttrack.sequence to {0}",
                                                      currenttrack.Sequence);
                            currentfile.Sequence   = currenttrack.Sequence;
                            currenttrack.Bps       = CdrWinTrackTypeToBytesPerSector(matchTrack.Groups[2].Value);
                            currenttrack.Tracktype = matchTrack.Groups[2].Value;
                            currenttrack.Session   = currentsession;
                            intrack                = true;
                        }
                        else if(line == "") // Empty line, ignore it
                        { }
                        else // Non-empty unknown field
                            throw new
                                FeatureUnsupportedImageException($"Found unknown field defined at line {lineNumber}: \"{line}\"");
                    }
                }

                if(currenttrack.Sequence != 0)
                {
                    currentfile.Sequence   = currenttrack.Sequence;
                    currenttrack.Trackfile = currentfile;
                    currenttrack.Sectors   = ((ulong)currentfile.Datafilter.GetLength() - currentfile.Offset) /
                                             CdrWinTrackTypeToBytesPerSector(currenttrack.Tracktype);
                    cuetracks[currenttrack.Sequence - 1] = currenttrack;
                }

                Session[] sessions = new Session[currentsession];
                for(int s = 1; s <= sessions.Length; s++)
                {
                    sessions[s - 1].SessionSequence = 1;

                    if(s > 1) sessions[s - 1].StartSector = sessions[s - 2].EndSector + 1;
                    else sessions[s      - 1].StartSector = 0;

                    ulong sessionSectors   = 0;
                    int   lastSessionTrack = 0;

                    for(int i = 0; i            < cuetracks.Length; i++)
                        if(cuetracks[i].Session == s)
                        {
                            sessionSectors                            += cuetracks[i].Sectors;
                            if(i > lastSessionTrack) lastSessionTrack =  i;
                        }

                    sessions[s - 1].EndTrack  = cuetracks[lastSessionTrack].Sequence;
                    sessions[s - 1].EndSector = sessionSectors - 1;
                }

                for(int s = 1; s <= sessions.Length; s++) discimage.Sessions.Add(sessions[s - 1]);

                for(int t = 1; t <= cuetracks.Length; t++) discimage.Tracks.Add(cuetracks[t - 1]);

                discimage.Disktype = CdrWinIsoBusterDiscTypeToMediaType(discimage.Disktypestr);

                if(discimage.Disktype == MediaType.Unknown || discimage.Disktype == MediaType.CD)
                {
                    bool data       = false;
                    bool cdg        = false;
                    bool cdi        = false;
                    bool mode2      = false;
                    bool firstaudio = false;
                    bool firstdata  = false;
                    bool audio      = false;

                    for(int i = 0; i < discimage.Tracks.Count; i++)
                    {
                        // First track is audio
                        firstaudio |= i == 0 && discimage.Tracks[i].Tracktype == CDRWIN_TRACK_TYPE_AUDIO;

                        // First track is data
                        firstdata |= i == 0 && discimage.Tracks[i].Tracktype != CDRWIN_TRACK_TYPE_AUDIO;

                        // Any non first track is data
                        data |= i != 0 && discimage.Tracks[i].Tracktype != CDRWIN_TRACK_TYPE_AUDIO;

                        // Any non first track is audio
                        audio |= i != 0 && discimage.Tracks[i].Tracktype == CDRWIN_TRACK_TYPE_AUDIO;

                        switch(discimage.Tracks[i].Tracktype)
                        {
                            case CDRWIN_TRACK_TYPE_CDG:
                                cdg = true;
                                break;
                            case CDRWIN_TRACK_TYPE_CDI:
                            case CDRWIN_TRACK_TYPE_CDI_RAW:
                                cdi = true;
                                break;
                            case CDRWIN_TRACK_TYPE_MODE2_FORM1:
                            case CDRWIN_TRACK_TYPE_MODE2_FORM2:
                            case CDRWIN_TRACK_TYPE_MODE2_FORMLESS:
                            case CDRWIN_TRACK_TYPE_MODE2_RAW:
                                mode2 = true;
                                break;
                        }
                    }

                    if(!data && !firstdata) discimage.Disktype = MediaType.CDDA;
                    else if(cdg)
                        discimage.Disktype = MediaType.CDG;
                    else if(cdi)
                        discimage.Disktype = MediaType.CDI;
                    else if(firstaudio && data && discimage.Sessions.Count > 1 && mode2)
                        discimage.Disktype = MediaType.CDPLUS;
                    else if(firstdata && audio || mode2)
                        discimage.Disktype = MediaType.CDROMXA;
                    else if(!audio)
                        discimage.Disktype = MediaType.CDROM;
                    else
                        discimage.Disktype = MediaType.CD;
                }

                // DEBUG information
                DicConsole.DebugWriteLine("CDRWin plugin",
                                          "Disc image parsing results");
                DicConsole.DebugWriteLine("CDRWin plugin",                                "Disc CD-TEXT:");
                if(discimage.Arranger == null) DicConsole.DebugWriteLine("CDRWin plugin", "\tArranger is not set.");
                else
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tArranger: {0}",
                                              discimage.Arranger);
                if(discimage.Composer == null) DicConsole.DebugWriteLine("CDRWin plugin", "\tComposer is not set.");
                else
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tComposer: {0}",
                                              discimage.Composer);
                if(discimage.Genre == null) DicConsole.DebugWriteLine("CDRWin plugin", "\tGenre is not set.");
                else
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tGenre: {0}",
                                              discimage.Genre);
                if(discimage.Performer == null) DicConsole.DebugWriteLine("CDRWin plugin", "\tPerformer is not set.");
                else
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tPerformer: {0}",
                                              discimage.Performer);
                if(discimage.Songwriter == null) DicConsole.DebugWriteLine("CDRWin plugin", "\tSongwriter is not set.");
                else
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tSongwriter: {0}",
                                              discimage.Songwriter);
                if(discimage.Title == null) DicConsole.DebugWriteLine("CDRWin plugin", "\tTitle is not set.");
                else
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tTitle: {0}",
                                              discimage.Title);
                if(discimage.Cdtextfile == null)
                    DicConsole.DebugWriteLine("CDRWin plugin",  "\tCD-TEXT binary file not set.");
                else DicConsole.DebugWriteLine("CDRWin plugin", "\tCD-TEXT binary file: {0}", discimage.Cdtextfile);
                DicConsole.DebugWriteLine("CDRWin plugin",      "Disc information:");
                if(discimage.Disktypestr == null)
                    DicConsole.DebugWriteLine("CDRWin plugin",
                                              "\tISOBuster disc type not set.");
                else
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tISOBuster disc type: {0}",
                                              discimage.Disktypestr);
                DicConsole.DebugWriteLine("CDRWin plugin", "\tGuessed disk type: {0}",
                                          discimage.Disktype);
                if(discimage.Barcode == null) DicConsole.DebugWriteLine("CDRWin plugin", "\tBarcode not set.");
                else
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tBarcode: {0}",
                                              discimage.Barcode);
                if(discimage.DiskId == null) DicConsole.DebugWriteLine("CDRWin plugin", "\tDisc ID not set.");
                else
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tDisc ID: {0}",
                                              discimage.DiskId);
                if(discimage.Mcn == null) DicConsole.DebugWriteLine("CDRWin plugin",     "\tMCN not set.");
                else DicConsole.DebugWriteLine("CDRWin plugin",                          "\tMCN: {0}", discimage.Mcn);
                if(discimage.Comment == null) DicConsole.DebugWriteLine("CDRWin plugin", "\tComment not set.");
                else
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tComment: \"{0}\"",
                                              discimage.Comment);
                DicConsole.DebugWriteLine("CDRWin plugin", "Session information:");
                DicConsole.DebugWriteLine("CDRWin plugin", "\tDisc contains {0} sessions",
                                          discimage.Sessions.Count);
                for(int i = 0; i < discimage.Sessions.Count; i++)
                {
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tSession {0} information:", i + 1);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\t\tStarting track: {0}",
                                              discimage.Sessions[i].StartTrack);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\t\tStarting sector: {0}",
                                              discimage.Sessions[i].StartSector);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\t\tEnding track: {0}", discimage.Sessions[i].EndTrack);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\t\tEnding sector: {0}",
                                              discimage.Sessions[i].EndSector);
                }

                DicConsole.DebugWriteLine("CDRWin plugin", "Track information:");
                DicConsole.DebugWriteLine("CDRWin plugin", "\tDisc contains {0} tracks", discimage.Tracks.Count);
                for(int i = 0; i < discimage.Tracks.Count; i++)
                {
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tTrack {0} information:",
                                              discimage.Tracks[i].Sequence);

                    DicConsole.DebugWriteLine("CDRWin plugin", "\t\t{0} bytes per sector", discimage.Tracks[i].Bps);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\t\tPregap: {0} sectors",  discimage.Tracks[i].Pregap);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\t\tData: {0} sectors",    discimage.Tracks[i].Sectors);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\t\tPostgap: {0} sectors", discimage.Tracks[i].Postgap);

                    if(discimage.Tracks[i].Flag4ch)
                        DicConsole.DebugWriteLine("CDRWin plugin", "\t\tTrack is flagged as quadraphonic");
                    if(discimage.Tracks[i].FlagDcp)
                        DicConsole.DebugWriteLine("CDRWin plugin", "\t\tTrack allows digital copy");
                    if(discimage.Tracks[i].FlagPre)
                        DicConsole.DebugWriteLine("CDRWin plugin",
                                                  "\t\tTrack has pre-emphasis applied");
                    if(discimage.Tracks[i].FlagScms) DicConsole.DebugWriteLine("CDRWin plugin", "\t\tTrack has SCMS");

                    DicConsole.DebugWriteLine("CDRWin plugin",
                                              "\t\tTrack resides in file {0}, type defined as {1}, starting at byte {2}",
                                              discimage.Tracks[i].Trackfile.Datafilter.GetFilename(),
                                              discimage.Tracks[i].Trackfile.Filetype,
                                              discimage.Tracks[i].Trackfile.Offset);

                    DicConsole.DebugWriteLine("CDRWin plugin", "\t\tIndexes:");
                    foreach(KeyValuePair<int, ulong> kvp in discimage.Tracks[i].Indexes)
                        DicConsole.DebugWriteLine("CDRWin plugin", "\t\t\tIndex {0} starts at sector {1}", kvp.Key,
                                                  kvp.Value);

                    if(discimage.Tracks[i].Isrc == null)
                        DicConsole.DebugWriteLine("CDRWin plugin",  "\t\tISRC is not set.");
                    else DicConsole.DebugWriteLine("CDRWin plugin", "\t\tISRC: {0}", discimage.Tracks[i].Isrc);

                    if(discimage.Tracks[i].Arranger == null)
                        DicConsole.DebugWriteLine("CDRWin plugin",  "\t\tArranger is not set.");
                    else DicConsole.DebugWriteLine("CDRWin plugin", "\t\tArranger: {0}", discimage.Tracks[i].Arranger);
                    if(discimage.Tracks[i].Composer == null)
                        DicConsole.DebugWriteLine("CDRWin plugin",  "\t\tComposer is not set.");
                    else DicConsole.DebugWriteLine("CDRWin plugin", "\t\tComposer: {0}", discimage.Tracks[i].Composer);
                    if(discimage.Tracks[i].Genre == null)
                        DicConsole.DebugWriteLine("CDRWin plugin",  "\t\tGenre is not set.");
                    else DicConsole.DebugWriteLine("CDRWin plugin", "\t\tGenre: {0}", discimage.Tracks[i].Genre);
                    if(discimage.Tracks[i].Performer == null)
                        DicConsole.DebugWriteLine("CDRWin plugin", "\t\tPerformer is not set.");
                    else
                        DicConsole.DebugWriteLine("CDRWin plugin", "\t\tPerformer: {0}", discimage.Tracks[i].Performer);
                    if(discimage.Tracks[i].Songwriter == null)
                        DicConsole.DebugWriteLine("CDRWin plugin", "\t\tSongwriter is not set.");
                    else
                        DicConsole.DebugWriteLine("CDRWin plugin", "\t\tSongwriter: {0}",
                                                  discimage.Tracks[i].Songwriter);
                    if(discimage.Tracks[i].Title == null)
                        DicConsole.DebugWriteLine("CDRWin plugin",  "\t\tTitle is not set.");
                    else DicConsole.DebugWriteLine("CDRWin plugin", "\t\tTitle: {0}", discimage.Tracks[i].Title);
                }

                DicConsole.DebugWriteLine("CDRWin plugin", "Building offset map");

                Partitions = new List<Partition>();

                ulong byteOffset        = 0;
                ulong sectorOffset      = 0;
                ulong partitionSequence = 0;
                ulong indexZeroOffset   = 0;
                ulong indexOneOffset    = 0;
                bool  indexZero         = false;

                offsetmap = new Dictionary<uint, ulong>();

                for(int i = 0; i < discimage.Tracks.Count; i++)
                {
                    ulong index0Len = 0;

                    if(discimage.Tracks[i].Sequence == 1 && i != 0)
                        throw new ImageNotSupportedException("Unordered tracks");

                    Partition partition = new Partition();

                    /*if(discimage.tracks[i].pregap > 0)
                    {
                        partition.PartitionDescription = string.Format("Track {0} pregap.", discimage.tracks[i].sequence);
                        partition.PartitionName = discimage.tracks[i].title;
                        partition.PartitionStartSector = sector_offset;
                        partition.PartitionLength = discimage.tracks[i].pregap * discimage.tracks[i].bps;
                        partition.PartitionSectors = discimage.tracks[i].pregap;
                        partition.PartitionSequence = partitionSequence;
                        partition.PartitionStart = byte_offset;
                        partition.PartitionType = discimage.tracks[i].tracktype;

                        sector_offset += partition.PartitionSectors;
                        byte_offset += partition.PartitionLength;
                        partitionSequence++;

                        if(!offsetmap.ContainsKey(discimage.tracks[i].sequence))
                            offsetmap.Add(discimage.tracks[i].sequence, partition.PartitionStartSector);
                        else
                        {
                            ulong old_start;
                            offsetmap.TryGetValue(discimage.tracks[i].sequence, out old_start);

                            if(partition.PartitionStartSector < old_start)
                            {
                                offsetmap.Remove(discimage.tracks[i].sequence);
                                offsetmap.Add(discimage.tracks[i].sequence, partition.PartitionStartSector);
                            }
                        }

                        partitions.Add(partition);
                        partition = new Partition();
                    }*/

                    indexZero |= discimage.Tracks[i].Indexes.TryGetValue(0, out indexZeroOffset);

                    if(!discimage.Tracks[i].Indexes.TryGetValue(1, out indexOneOffset))
                        throw new ImageNotSupportedException($"Track {discimage.Tracks[i].Sequence} lacks index 01");

                    /*if(index_zero && index_one_offset > index_zero_offset)
                    {
                        partition.PartitionDescription = string.Format("Track {0} index 00.", discimage.tracks[i].sequence);
                        partition.PartitionName = discimage.tracks[i].title;
                        partition.PartitionStartSector = sector_offset;
                        partition.PartitionLength = (index_one_offset - index_zero_offset) * discimage.tracks[i].bps;
                        partition.PartitionSectors = index_one_offset - index_zero_offset;
                        partition.PartitionSequence = partitionSequence;
                        partition.PartitionStart = byte_offset;
                        partition.PartitionType = discimage.tracks[i].tracktype;

                        sector_offset += partition.PartitionSectors;
                        byte_offset += partition.PartitionLength;
                        index0_len = partition.PartitionSectors;
                        partitionSequence++;

                        if(!offsetmap.ContainsKey(discimage.tracks[i].sequence))
                            offsetmap.Add(discimage.tracks[i].sequence, partition.PartitionStartSector);
                        else
                        {
                            ulong old_start;
                            offsetmap.TryGetValue(discimage.tracks[i].sequence, out old_start);

                            if(partition.PartitionStartSector < old_start)
                            {
                                offsetmap.Remove(discimage.tracks[i].sequence);
                                offsetmap.Add(discimage.tracks[i].sequence, partition.PartitionStartSector);
                            }
                        }

                        partitions.Add(partition);
                        partition = new Partition();
                    }*/

                    // Index 01
                    partition.Description = $"Track {discimage.Tracks[i].Sequence}.";
                    partition.Name        = discimage.Tracks[i].Title;
                    partition.Start       = sectorOffset;
                    partition.Size        = (discimage.Tracks[i].Sectors - index0Len) * discimage.Tracks[i].Bps;
                    partition.Length      = discimage.Tracks[i].Sectors  - index0Len;
                    partition.Sequence    = partitionSequence;
                    partition.Offset      = byteOffset;
                    partition.Type        = discimage.Tracks[i].Tracktype;

                    sectorOffset += partition.Length;
                    byteOffset   += partition.Size;
                    partitionSequence++;

                    if(!offsetmap.ContainsKey(discimage.Tracks[i].Sequence))
                        offsetmap.Add(discimage.Tracks[i].Sequence, partition.Start);
                    else
                    {
                        offsetmap.TryGetValue(discimage.Tracks[i].Sequence, out ulong oldStart);

                        if(partition.Start < oldStart)
                        {
                            offsetmap.Remove(discimage.Tracks[i].Sequence);
                            offsetmap.Add(discimage.Tracks[i].Sequence, partition.Start);
                        }
                    }

                    Partitions.Add(partition);
                }

                // Print offset map
                DicConsole.DebugWriteLine("CDRWin plugin", "printing partition map");
                foreach(Partition partition in Partitions)
                {
                    DicConsole.DebugWriteLine("CDRWin plugin", "Partition sequence: {0}", partition.Sequence);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tPartition name: {0}",   partition.Name);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tPartition description: {0}",
                                              partition.Description);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tPartition type: {0}",            partition.Type);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tPartition starting sector: {0}", partition.Start);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tPartition sectors: {0}",         partition.Length);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tPartition starting offset: {0}", partition.Offset);
                    DicConsole.DebugWriteLine("CDRWin plugin", "\tPartition size in bytes: {0}",   partition.Size);
                }

                foreach(CdrWinTrack track in discimage.Tracks) imageInfo.ImageSize += track.Bps * track.Sectors;
                foreach(CdrWinTrack track in discimage.Tracks) imageInfo.Sectors   += track.Sectors;

                if(discimage.Disktype == MediaType.CDG || discimage.Disktype == MediaType.CDEG ||
                   discimage.Disktype == MediaType.CDMIDI)
                    imageInfo.SectorSize = 2448; // CD+G subchannels ARE user data, as CD+G are useless without them
                else if(discimage.Disktype != MediaType.CDROMXA && discimage.Disktype != MediaType.CDDA &&
                        discimage.Disktype != MediaType.CDI     && discimage.Disktype != MediaType.CDPLUS)
                    imageInfo.SectorSize = 2048; // Only data tracks
                else
                    imageInfo.SectorSize = 2352; // All others

                if(discimage.Mcn        != null) imageInfo.ReadableMediaTags.Add(MediaTagType.CD_MCN);
                if(discimage.Cdtextfile != null) imageInfo.ReadableMediaTags.Add(MediaTagType.CD_TEXT);

                // Detect ISOBuster extensions
                if(discimage.Disktypestr    != null || discimage.Comment.ToLower().Contains("isobuster") ||
                   discimage.Sessions.Count > 1) imageInfo.Application = "ISOBuster";
                else imageInfo.Application                             = "CDRWin";

                imageInfo.CreationTime         = imageFilter.GetCreationTime();
                imageInfo.LastModificationTime = imageFilter.GetLastWriteTime();

                imageInfo.Comments          = discimage.Comment;
                imageInfo.MediaSerialNumber = discimage.Mcn;
                imageInfo.MediaBarcode      = discimage.Barcode;
                imageInfo.MediaType         = discimage.Disktype;

                imageInfo.ReadableSectorTags.Add(SectorTagType.CdTrackFlags);

                foreach(CdrWinTrack track in discimage.Tracks)
                    switch(track.Tracktype)
                    {
                        case CDRWIN_TRACK_TYPE_AUDIO:
                        {
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdTrackIsrc))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdTrackIsrc);
                            break;
                        }
                        case CDRWIN_TRACK_TYPE_CDG:
                        {
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdTrackIsrc))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdTrackIsrc);
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSubchannel))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSubchannel);
                            break;
                        }
                        case CDRWIN_TRACK_TYPE_MODE2_FORMLESS:
                        case CDRWIN_TRACK_TYPE_CDI:
                        {
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSubHeader))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSubHeader);
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEdc))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEdc);
                            break;
                        }
                        case CDRWIN_TRACK_TYPE_MODE2_RAW:
                        case CDRWIN_TRACK_TYPE_CDI_RAW:
                        {
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSync))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSync);
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorHeader))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorHeader);
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSubHeader))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSubHeader);
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEdc))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEdc);
                            break;
                        }
                        case CDRWIN_TRACK_TYPE_MODE1_RAW:
                        {
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSync))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSync);
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorHeader))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorHeader);
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSubHeader))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSubHeader);
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEcc))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEcc);
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEccP))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEccP);
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEccQ))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEccQ);
                            if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEdc))
                                imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEdc);
                            break;
                        }
                    }

                imageInfo.XmlMediaType = XmlMediaType.OpticalDisc;

                DicConsole.VerboseWriteLine("CDRWIN image describes a disc of type {0}", imageInfo.MediaType);
                if(!string.IsNullOrEmpty(imageInfo.Comments))
                    DicConsole.VerboseWriteLine("CDRWIN comments: {0}", imageInfo.Comments);

                return true;
            }
            catch(Exception ex)
            {
                DicConsole.ErrorWriteLine("Exception trying to identify image file {0}", imageFilter.GetFilename());
                DicConsole.ErrorWriteLine("Exception: {0}",                              ex.Message);
                DicConsole.ErrorWriteLine("Stack trace: {0}",                            ex.StackTrace);
                return false;
            }
        }

        public byte[] ReadDiskTag(MediaTagType tag)
        {
            switch(tag)
            {
                case MediaTagType.CD_MCN:
                {
                    if(discimage.Mcn != null) return Encoding.ASCII.GetBytes(discimage.Mcn);

                    throw new FeatureNotPresentImageException("Image does not contain MCN information.");
                }
                case MediaTagType.CD_TEXT:
                {
                    if(discimage.Cdtextfile != null)
                        // TODO: Check that binary text file exists, open it, read it, send it to caller.
                        throw new FeatureSupportedButNotImplementedImageException("Feature not yet implemented");

                    throw new FeatureNotPresentImageException("Image does not contain CD-TEXT information.");
                }
                default:
                    throw new FeatureSupportedButNotImplementedImageException("Feature not supported by image format");
            }
        }

        public byte[] ReadSector(ulong sectorAddress)
        {
            return ReadSectors(sectorAddress, 1);
        }

        public byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag)
        {
            return ReadSectorsTag(sectorAddress, 1, tag);
        }

        public byte[] ReadSector(ulong sectorAddress, uint track)
        {
            return ReadSectors(sectorAddress, 1, track);
        }

        public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag)
        {
            return ReadSectorsTag(sectorAddress, 1, track, tag);
        }

        public byte[] ReadSectors(ulong sectorAddress, uint length)
        {
            foreach(KeyValuePair<uint, ulong> kvp in from kvp in offsetmap
                                                     where sectorAddress >= kvp.Value
                                                     from cdrwinTrack in discimage.Tracks
                                                     where cdrwinTrack.Sequence      == kvp.Key
                                                     where sectorAddress - kvp.Value < cdrwinTrack.Sectors
                                                     select kvp)
                return ReadSectors(sectorAddress - kvp.Value, length, kvp.Key);

            throw new ArgumentOutOfRangeException(nameof(sectorAddress), "Sector address not found");
        }

        public byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag)
        {
            foreach(KeyValuePair<uint, ulong> kvp in from kvp in offsetmap
                                                     where sectorAddress >= kvp.Value
                                                     from cdrwinTrack in discimage.Tracks
                                                     where cdrwinTrack.Sequence      == kvp.Key
                                                     where sectorAddress - kvp.Value < cdrwinTrack.Sectors
                                                     select kvp)
                return ReadSectorsTag(sectorAddress - kvp.Value, length, kvp.Key, tag);

            throw new ArgumentOutOfRangeException(nameof(sectorAddress), "Sector address not found");
        }

        public byte[] ReadSectors(ulong sectorAddress, uint length, uint track)
        {
            CdrWinTrack dicTrack = new CdrWinTrack {Sequence = 0};

            foreach(CdrWinTrack cdrwinTrack in discimage.Tracks.Where(cdrwinTrack => cdrwinTrack.Sequence == track))
            {
                dicTrack = cdrwinTrack;
                break;
            }

            if(dicTrack.Sequence == 0)
                throw new ArgumentOutOfRangeException(nameof(track), "Track does not exist in disc image");

            if(length > dicTrack.Sectors)
                throw new ArgumentOutOfRangeException(nameof(length),
                                                      "Requested more sectors than present in track, won't cross tracks");

            uint sectorOffset;
            uint sectorSize;
            uint sectorSkip;

            switch(dicTrack.Tracktype)
            {
                case CDRWIN_TRACK_TYPE_MODE1:
                case CDRWIN_TRACK_TYPE_MODE2_FORM1:
                {
                    sectorOffset = 0;
                    sectorSize   = 2048;
                    sectorSkip   = 0;
                    break;
                }
                case CDRWIN_TRACK_TYPE_MODE2_FORM2:
                {
                    sectorOffset = 0;
                    sectorSize   = 2324;
                    sectorSkip   = 0;
                    break;
                }
                case CDRWIN_TRACK_TYPE_MODE2_FORMLESS:
                case CDRWIN_TRACK_TYPE_CDI:
                {
                    sectorOffset = 0;
                    sectorSize   = 2336;
                    sectorSkip   = 0;
                    break;
                }
                case CDRWIN_TRACK_TYPE_AUDIO:
                {
                    sectorOffset = 0;
                    sectorSize   = 2352;
                    sectorSkip   = 0;
                    break;
                }
                case CDRWIN_TRACK_TYPE_MODE1_RAW:
                {
                    sectorOffset = 16;
                    sectorSize   = 2048;
                    sectorSkip   = 288;
                    break;
                }
                case CDRWIN_TRACK_TYPE_MODE2_RAW:
                {
                    sectorOffset = 16;
                    sectorSize   = 2336;
                    sectorSkip   = 0;
                    break;
                }
                case CDRWIN_TRACK_TYPE_CDI_RAW:
                {
                    sectorOffset = 16;
                    sectorSize   = 2336;
                    sectorSkip   = 0;
                    break;
                }
                case CDRWIN_TRACK_TYPE_CDG:
                {
                    sectorOffset = 0;
                    sectorSize   = 2352;
                    sectorSkip   = 96;
                    break;
                }
                default: throw new FeatureSupportedButNotImplementedImageException("Unsupported track type");
            }

            byte[] buffer = new byte[sectorSize * length];

            imageStream     = dicTrack.Trackfile.Datafilter.GetDataForkStream();
            BinaryReader br = new BinaryReader(imageStream);
            br.BaseStream
              .Seek((long)dicTrack.Trackfile.Offset + (long)(sectorAddress * (sectorOffset + sectorSize + sectorSkip)),
                    SeekOrigin.Begin);
            if(sectorOffset == 0 && sectorSkip == 0) buffer = br.ReadBytes((int)(sectorSize * length));
            else
                for(int i = 0; i < length; i++)
                {
                    br.BaseStream.Seek(sectorOffset, SeekOrigin.Current);
                    byte[] sector = br.ReadBytes((int)sectorSize);
                    br.BaseStream.Seek(sectorSkip, SeekOrigin.Current);
                    Array.Copy(sector, 0, buffer, i * sectorSize, sectorSize);
                }

            return buffer;
        }

        public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag)
        {
            CdrWinTrack dicTrack = new CdrWinTrack {Sequence = 0};

            foreach(CdrWinTrack cdrwinTrack in discimage.Tracks.Where(cdrwinTrack => cdrwinTrack.Sequence == track))
            {
                dicTrack = cdrwinTrack;
                break;
            }

            if(dicTrack.Sequence == 0)
                throw new ArgumentOutOfRangeException(nameof(track), "Track does not exist in disc image");

            if(length > dicTrack.Sectors)
                throw new ArgumentOutOfRangeException(nameof(length),
                                                      "Requested more sectors than present in track, won't cross tracks");

            uint sectorOffset;
            uint sectorSize;
            uint sectorSkip;

            switch(tag)
            {
                case SectorTagType.CdSectorEcc:
                case SectorTagType.CdSectorEccP:
                case SectorTagType.CdSectorEccQ:
                case SectorTagType.CdSectorEdc:
                case SectorTagType.CdSectorHeader:
                case SectorTagType.CdSectorSubchannel:
                case SectorTagType.CdSectorSubHeader:
                case SectorTagType.CdSectorSync: break;
                case SectorTagType.CdTrackFlags:
                {
                    CdFlags flags = 0;

                    if(dicTrack.Tracktype != CDRWIN_TRACK_TYPE_AUDIO && dicTrack.Tracktype != CDRWIN_TRACK_TYPE_CDG)
                        flags |= CdFlags.DataTrack;

                    if(dicTrack.FlagDcp) flags |= CdFlags.CopyPermitted;

                    if(dicTrack.FlagPre) flags |= CdFlags.PreEmphasis;

                    if(dicTrack.Flag4ch) flags |= CdFlags.FourChannel;

                    return new[] {(byte)flags};
                }
                case SectorTagType.CdTrackIsrc:
                    if(dicTrack.Isrc == null) return null;

                    return Encoding.UTF8.GetBytes(dicTrack.Isrc);
                case SectorTagType.CdTrackText:
                    throw new FeatureSupportedButNotImplementedImageException("Feature not yet implemented");
                default: throw new ArgumentException("Unsupported tag requested", nameof(tag));
            }

            switch(dicTrack.Tracktype)
            {
                case CDRWIN_TRACK_TYPE_MODE1:
                case CDRWIN_TRACK_TYPE_MODE2_FORM1:
                case CDRWIN_TRACK_TYPE_MODE2_FORM2:
                    throw new ArgumentException("No tags in image for requested track", nameof(tag));
                case CDRWIN_TRACK_TYPE_MODE2_FORMLESS:
                case CDRWIN_TRACK_TYPE_CDI:
                {
                    switch(tag)
                    {
                        case SectorTagType.CdSectorSync:
                        case SectorTagType.CdSectorHeader:
                        case SectorTagType.CdSectorSubchannel:
                        case SectorTagType.CdSectorEcc:
                        case SectorTagType.CdSectorEccP:
                        case SectorTagType.CdSectorEccQ:
                            throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
                        case SectorTagType.CdSectorSubHeader:
                        {
                            sectorOffset = 0;
                            sectorSize   = 8;
                            sectorSkip   = 2328;
                            break;
                        }
                        case SectorTagType.CdSectorEdc:
                        {
                            sectorOffset = 2332;
                            sectorSize   = 4;
                            sectorSkip   = 0;
                            break;
                        }
                        default: throw new ArgumentException("Unsupported tag requested", nameof(tag));
                    }

                    break;
                }
                case CDRWIN_TRACK_TYPE_AUDIO:
                    throw new ArgumentException("There are no tags on audio tracks", nameof(tag));
                case CDRWIN_TRACK_TYPE_MODE1_RAW:
                {
                    switch(tag)
                    {
                        case SectorTagType.CdSectorSync:
                        {
                            sectorOffset = 0;
                            sectorSize   = 12;
                            sectorSkip   = 2340;
                            break;
                        }
                        case SectorTagType.CdSectorHeader:
                        {
                            sectorOffset = 12;
                            sectorSize   = 4;
                            sectorSkip   = 2336;
                            break;
                        }
                        case SectorTagType.CdSectorSubchannel:
                        case SectorTagType.CdSectorSubHeader:
                            throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));
                        case SectorTagType.CdSectorEcc:
                        {
                            sectorOffset = 2076;
                            sectorSize   = 276;
                            sectorSkip   = 0;
                            break;
                        }
                        case SectorTagType.CdSectorEccP:
                        {
                            sectorOffset = 2076;
                            sectorSize   = 172;
                            sectorSkip   = 104;
                            break;
                        }
                        case SectorTagType.CdSectorEccQ:
                        {
                            sectorOffset = 2248;
                            sectorSize   = 104;
                            sectorSkip   = 0;
                            break;
                        }
                        case SectorTagType.CdSectorEdc:
                        {
                            sectorOffset = 2064;
                            sectorSize   = 4;
                            sectorSkip   = 284;
                            break;
                        }
                        default: throw new ArgumentException("Unsupported tag requested", nameof(tag));
                    }

                    break;
                }
                case CDRWIN_TRACK_TYPE_MODE2_RAW: // Requires reading sector
                case CDRWIN_TRACK_TYPE_CDI_RAW:
                    throw new FeatureSupportedButNotImplementedImageException("Feature not yet implemented");
                case CDRWIN_TRACK_TYPE_CDG:
                {
                    if(tag != SectorTagType.CdSectorSubchannel)
                        throw new ArgumentException("Unsupported tag requested for this track", nameof(tag));

                    sectorOffset = 2352;
                    sectorSize   = 96;
                    sectorSkip   = 0;
                    break;
                }
                default: throw new FeatureSupportedButNotImplementedImageException("Unsupported track type");
            }

            byte[] buffer = new byte[sectorSize * length];

            imageStream     = dicTrack.Trackfile.Datafilter.GetDataForkStream();
            BinaryReader br = new BinaryReader(imageStream);
            br.BaseStream
              .Seek((long)dicTrack.Trackfile.Offset + (long)(sectorAddress * (sectorOffset + sectorSize + sectorSkip)),
                    SeekOrigin.Begin);
            if(sectorOffset == 0 && sectorSkip == 0) buffer = br.ReadBytes((int)(sectorSize * length));
            else
                for(int i = 0; i < length; i++)
                {
                    br.BaseStream.Seek(sectorOffset, SeekOrigin.Current);
                    byte[] sector = br.ReadBytes((int)sectorSize);
                    br.BaseStream.Seek(sectorSkip, SeekOrigin.Current);
                    Array.Copy(sector, 0, buffer, i * sectorSize, sectorSize);
                }

            return buffer;
        }

        public byte[] ReadSectorLong(ulong sectorAddress)
        {
            return ReadSectorsLong(sectorAddress, 1);
        }

        public byte[] ReadSectorLong(ulong sectorAddress, uint track)
        {
            return ReadSectorsLong(sectorAddress, 1, track);
        }

        public byte[] ReadSectorsLong(ulong sectorAddress, uint length)
        {
            foreach(KeyValuePair<uint, ulong> kvp in from kvp in offsetmap
                                                     where sectorAddress >= kvp.Value
                                                     from cdrwinTrack in discimage.Tracks
                                                     where cdrwinTrack.Sequence      == kvp.Key
                                                     where sectorAddress - kvp.Value < cdrwinTrack.Sectors
                                                     select kvp)
                return ReadSectorsLong(sectorAddress - kvp.Value, length, kvp.Key);

            throw new ArgumentOutOfRangeException(nameof(sectorAddress), "Sector address not found");
        }

        public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track)
        {
            CdrWinTrack dicTrack = new CdrWinTrack {Sequence = 0};

            foreach(CdrWinTrack cdrwinTrack in discimage.Tracks.Where(cdrwinTrack => cdrwinTrack.Sequence == track))
            {
                dicTrack = cdrwinTrack;
                break;
            }

            if(dicTrack.Sequence == 0)
                throw new ArgumentOutOfRangeException(nameof(track), "Track does not exist in disc image");

            if(length > dicTrack.Sectors)
                throw new ArgumentOutOfRangeException(nameof(length),
                                                      "Requested more sectors than present in track, won't cross tracks");

            uint sectorOffset;
            uint sectorSize;
            uint sectorSkip;

            switch(dicTrack.Tracktype)
            {
                case CDRWIN_TRACK_TYPE_MODE1:
                case CDRWIN_TRACK_TYPE_MODE2_FORM1:
                {
                    sectorOffset = 0;
                    sectorSize   = 2048;
                    sectorSkip   = 0;
                    break;
                }
                case CDRWIN_TRACK_TYPE_MODE2_FORM2:
                {
                    sectorOffset = 0;
                    sectorSize   = 2324;
                    sectorSkip   = 0;
                    break;
                }
                case CDRWIN_TRACK_TYPE_MODE2_FORMLESS:
                case CDRWIN_TRACK_TYPE_CDI:
                {
                    sectorOffset = 0;
                    sectorSize   = 2336;
                    sectorSkip   = 0;
                    break;
                }
                case CDRWIN_TRACK_TYPE_MODE1_RAW:
                case CDRWIN_TRACK_TYPE_MODE2_RAW:
                case CDRWIN_TRACK_TYPE_CDI_RAW:
                case CDRWIN_TRACK_TYPE_AUDIO:
                {
                    sectorOffset = 0;
                    sectorSize   = 2352;
                    sectorSkip   = 0;
                    break;
                }
                case CDRWIN_TRACK_TYPE_CDG:
                {
                    sectorOffset = 0;
                    sectorSize   = 2448;
                    sectorSkip   = 0;
                    break;
                }
                default: throw new FeatureSupportedButNotImplementedImageException("Unsupported track type");
            }

            byte[] buffer = new byte[sectorSize * length];

            imageStream     = dicTrack.Trackfile.Datafilter.GetDataForkStream();
            BinaryReader br = new BinaryReader(imageStream);

            br.BaseStream
              .Seek((long)dicTrack.Trackfile.Offset + (long)(sectorAddress * (sectorOffset + sectorSize + sectorSkip)),
                    SeekOrigin.Begin);

            if(sectorOffset == 0 && sectorSkip == 0) buffer = br.ReadBytes((int)(sectorSize * length));
            else
                for(int i = 0; i < length; i++)
                {
                    br.BaseStream.Seek(sectorOffset, SeekOrigin.Current);
                    byte[] sector = br.ReadBytes((int)sectorSize);
                    br.BaseStream.Seek(sectorSkip, SeekOrigin.Current);

                    Array.Copy(sector, 0, buffer, i * sectorSize, sectorSize);
                }

            return buffer;
        }

        public List<Track> GetSessionTracks(Session session)
        {
            if(discimage.Sessions.Contains(session)) return GetSessionTracks(session.SessionSequence);

            throw new ImageNotSupportedException("Session does not exist in disc image");
        }

        public List<Track> GetSessionTracks(ushort session)
        {
            List<Track> tracks = new List<Track>();

            foreach(CdrWinTrack cdrTrack in discimage.Tracks)
                if(cdrTrack.Session == session)
                {
                    Track dicTrack = new Track
                    {
                        Indexes                = cdrTrack.Indexes,
                        TrackDescription       = cdrTrack.Title,
                        TrackPregap            = cdrTrack.Pregap,
                        TrackSession           = cdrTrack.Session,
                        TrackSequence          = cdrTrack.Sequence,
                        TrackType              = CdrWinTrackTypeToTrackType(cdrTrack.Tracktype),
                        TrackFile              = cdrTrack.Trackfile.Datafilter.GetFilename(),
                        TrackFilter            = cdrTrack.Trackfile.Datafilter,
                        TrackFileOffset        = cdrTrack.Trackfile.Offset,
                        TrackFileType          = cdrTrack.Trackfile.Filetype,
                        TrackRawBytesPerSector = cdrTrack.Bps,
                        TrackBytesPerSector    = CdrWinTrackTypeToCookedBytesPerSector(cdrTrack.Tracktype)
                    };

                    if(!cdrTrack.Indexes.TryGetValue(0, out dicTrack.TrackStartSector))
                        cdrTrack.Indexes.TryGetValue(1, out dicTrack.TrackStartSector);
                    dicTrack.TrackEndSector = dicTrack.TrackStartSector + cdrTrack.Sectors - 1;
                    if(cdrTrack.Bps == 2448)
                    {
                        dicTrack.TrackSubchannelFilter = cdrTrack.Trackfile.Datafilter;
                        dicTrack.TrackSubchannelFile   = cdrTrack.Trackfile.Datafilter.GetFilename();
                        dicTrack.TrackSubchannelOffset = cdrTrack.Trackfile.Offset;
                        dicTrack.TrackSubchannelType   = TrackSubchannelType.RawInterleaved;
                    }
                    else dicTrack.TrackSubchannelType = TrackSubchannelType.None;

                    tracks.Add(dicTrack);
                }

            return tracks;
        }

        public bool? VerifySector(ulong sectorAddress)
        {
            byte[] buffer = ReadSectorLong(sectorAddress);
            return CdChecksums.CheckCdSector(buffer);
        }

        public bool? VerifySector(ulong sectorAddress, uint track)
        {
            byte[] buffer = ReadSectorLong(sectorAddress, track);
            return CdChecksums.CheckCdSector(buffer);
        }

        public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
                                   out                                   List<ulong> unknownLbas)
        {
            byte[] buffer = ReadSectorsLong(sectorAddress, length);
            int    bps    = (int)(buffer.Length / length);
            byte[] sector = new byte[bps];
            failingLbas   = new List<ulong>();
            unknownLbas   = new List<ulong>();

            for(int i = 0; i < length; i++)
            {
                Array.Copy(buffer, i * bps, sector, 0, bps);
                bool? sectorStatus = CdChecksums.CheckCdSector(sector);

                switch(sectorStatus)
                {
                    case null:
                        unknownLbas.Add((ulong)i + sectorAddress);
                        break;
                    case false:
                        failingLbas.Add((ulong)i + sectorAddress);
                        break;
                }
            }

            if(unknownLbas.Count > 0) return null;

            return failingLbas.Count <= 0;
        }

        public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
                                   out                                               List<ulong> unknownLbas)
        {
            byte[] buffer = ReadSectorsLong(sectorAddress, length, track);
            int    bps    = (int)(buffer.Length / length);
            byte[] sector = new byte[bps];
            failingLbas   = new List<ulong>();
            unknownLbas   = new List<ulong>();

            for(int i = 0; i < length; i++)
            {
                Array.Copy(buffer, i * bps, sector, 0, bps);
                bool? sectorStatus = CdChecksums.CheckCdSector(sector);

                switch(sectorStatus)
                {
                    case null:
                        unknownLbas.Add((ulong)i + sectorAddress);
                        break;
                    case false:
                        failingLbas.Add((ulong)i + sectorAddress);
                        break;
                }
            }

            if(unknownLbas.Count > 0) return null;

            return failingLbas.Count <= 0;
        }

        public bool? VerifyMediaImage()
        {
            return null;
        }

        public IEnumerable<MediaTagType>  SupportedMediaTags  => new[] {MediaTagType.CD_MCN, MediaTagType.CD_TEXT};
        public IEnumerable<SectorTagType> SupportedSectorTags =>
            new[]
            {
                SectorTagType.CdSectorEcc, SectorTagType.CdSectorEccP, SectorTagType.CdSectorEccQ,
                SectorTagType.CdSectorEdc, SectorTagType.CdSectorHeader, SectorTagType.CdSectorSubchannel,
                SectorTagType.CdSectorSubHeader, SectorTagType.CdSectorSync, SectorTagType.CdTrackFlags,
                SectorTagType.CdTrackIsrc
            };
        public IEnumerable<MediaType> SupportedMediaTypes =>
            new[]
            {
                MediaType.BDR, MediaType.BDRE, MediaType.BDREXL, MediaType.BDROM, MediaType.BDRXL, MediaType.CBHD,
                MediaType.CD, MediaType.CDDA, MediaType.CDEG, MediaType.CDG, MediaType.CDI, MediaType.CDMIDI,
                MediaType.CDMRW, MediaType.CDPLUS, MediaType.CDR, MediaType.CDROM, MediaType.CDROMXA, MediaType.CDRW,
                MediaType.CDV, MediaType.DDCD, MediaType.DDCDR, MediaType.DDCDRW, MediaType.DVDDownload,
                MediaType.DVDPR, MediaType.DVDPRDL, MediaType.DVDPRW, MediaType.DVDPRWDL, MediaType.DVDR,
                MediaType.DVDRAM, MediaType.DVDRDL, MediaType.DVDROM, MediaType.DVDRW, MediaType.DVDRWDL, MediaType.EVD,
                MediaType.FDDVD, MediaType.DTSCD, MediaType.FVD, MediaType.HDDVDR, MediaType.HDDVDRAM,
                MediaType.HDDVDRDL, MediaType.HDDVDROM, MediaType.HDDVDRW, MediaType.HDDVDRWDL, MediaType.HDVMD,
                MediaType.HVD, MediaType.JaguarCD, MediaType.MEGACD, MediaType.PD650, MediaType.PD650_WORM,
                MediaType.PS1CD, MediaType.PS2CD, MediaType.PS2DVD, MediaType.PS3BD, MediaType.PS3DVD, MediaType.PS4BD,
                MediaType.SuperCDROM2, MediaType.SVCD, MediaType.SVOD, MediaType.SATURNCD, MediaType.ThreeDO,
                MediaType.UDO, MediaType.UDO2, MediaType.UDO2_WORM, MediaType.UMD, MediaType.VCD, MediaType.VCDHD
            };
        public IEnumerable<(string name, Type type, string description)> SupportedOptions =>
            new[] {("separate", typeof(bool), "Write each track to a separate file.")};
        public IEnumerable<string> KnownExtensions => new[] {".cue"};
        public bool                IsWriting       { get; private set; }
        public string              ErrorMessage    { get; private set; }

        public bool Create(string path, MediaType mediaType, Dictionary<string, string> options, ulong sectors,
                           uint   sectorSize)
        {
            if(options != null)
            {
                if(options.TryGetValue("separate", out string tmpValue))
                {
                    if(!bool.TryParse(tmpValue, out separateTracksWriting))
                    {
                        ErrorMessage = "Invalid value for split option";
                        return false;
                    }

                    if(separateTracksWriting)
                    {
                        ErrorMessage = "Separate tracksnot yet implemented";
                        return false;
                    }
                }
            }
            else separateTracksWriting = false;

            if(!SupportedMediaTypes.Contains(mediaType))
            {
                ErrorMessage = $"Unsupport media format {mediaType}";
                return false;
            }

            imageInfo = new ImageInfo {MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors};

            // TODO: Separate tracks
            try
            {
                writingBaseName  = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path));
                descriptorStream = new StreamWriter(path, false, Encoding.ASCII);
            }
            catch(IOException e)
            {
                ErrorMessage = $"Could not create new image file, exception {e.Message}";
                return false;
            }

            discimage = new CdrWinDisc
            {
                Disktype = mediaType,
                Sessions = new List<Session>(),
                Tracks   = new List<CdrWinTrack>()
            };

            trackFlags = new Dictionary<byte, byte>();
            trackIsrcs = new Dictionary<byte, string>();

            IsWriting    = true;
            ErrorMessage = null;
            return true;
        }

        public bool WriteMediaTag(byte[] data, MediaTagType tag)
        {
            if(!IsWriting)
            {
                ErrorMessage = "Tried to write on a non-writable image";
                return false;
            }

            switch(tag)
            {
                case MediaTagType.CD_MCN:
                    discimage.Mcn = Encoding.ASCII.GetString(data);
                    return true;
                case MediaTagType.CD_TEXT:
                    FileStream cdTextStream = new FileStream(writingBaseName + "_cdtext.bin", FileMode.Create,
                                                             FileAccess.ReadWrite, FileShare.None);
                    cdTextStream.Write(data, 0, data.Length);
                    discimage.Cdtextfile = Path.GetFileName(cdTextStream.Name);
                    cdTextStream.Close();
                    return true;
                default:
                    ErrorMessage = $"Unsupported media tag {tag}";
                    return false;
            }
        }

        public bool WriteSector(byte[] data, ulong sectorAddress)
        {
            if(!IsWriting)
            {
                ErrorMessage = "Tried to write on a non-writable image";
                return false;
            }

            Track track =
                writingTracks.FirstOrDefault(trk => sectorAddress >= trk.TrackStartSector &&
                                                    sectorAddress <= trk.TrackEndSector);

            if(track.TrackSequence == 0)
            {
                ErrorMessage = $"Can't found track containing {sectorAddress}";
                return false;
            }

            FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;

            if(trackStream == null)
            {
                ErrorMessage = $"Can't found file containing {sectorAddress}";
                return false;
            }

            if(track.TrackBytesPerSector != track.TrackRawBytesPerSector)
            {
                ErrorMessage = "Invalid write mode for this sector";
                return false;
            }

            if(data.Length != track.TrackRawBytesPerSector)
            {
                ErrorMessage = "Incorrect data size";
                return false;
            }

            trackStream.Seek((long)(track.TrackFileOffset + (sectorAddress - track.TrackStartSector) * (ulong)track.TrackRawBytesPerSector),
                             SeekOrigin.Begin);
            trackStream.Write(data, 0, data.Length);

            return true;
        }

        public bool WriteSectors(byte[] data, ulong sectorAddress, uint length)
        {
            if(!IsWriting)
            {
                ErrorMessage = "Tried to write on a non-writable image";
                return false;
            }

            Track track =
                writingTracks.FirstOrDefault(trk => sectorAddress >= trk.TrackStartSector &&
                                                    sectorAddress <= trk.TrackEndSector);

            if(track.TrackSequence == 0)
            {
                ErrorMessage = $"Can't found track containing {sectorAddress}";
                return false;
            }

            FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;

            if(trackStream == null)
            {
                ErrorMessage = $"Can't found file containing {sectorAddress}";
                return false;
            }

            if(track.TrackBytesPerSector != track.TrackRawBytesPerSector)
            {
                ErrorMessage = "Invalid write mode for this sector";
                return false;
            }

            if(sectorAddress + length > track.TrackEndSector + 1)
            {
                ErrorMessage = "Can't cross tracks";
                return false;
            }

            if(data.Length % track.TrackRawBytesPerSector != 0)
            {
                ErrorMessage = "Incorrect data size";
                return false;
            }

            trackStream.Seek((long)(track.TrackFileOffset + (sectorAddress - track.TrackStartSector) * (ulong)track.TrackRawBytesPerSector),
                             SeekOrigin.Begin);
            trackStream.Write(data, 0, data.Length);

            return true;
        }

        public bool WriteSectorLong(byte[] data, ulong sectorAddress)
        {
            if(!IsWriting)
            {
                ErrorMessage = "Tried to write on a non-writable image";
                return false;
            }

            Track track =
                writingTracks.FirstOrDefault(trk => sectorAddress >= trk.TrackStartSector &&
                                                    sectorAddress <= trk.TrackEndSector);

            if(track.TrackSequence == 0)
            {
                ErrorMessage = $"Can't found track containing {sectorAddress}";
                return false;
            }

            FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;

            if(trackStream == null)
            {
                ErrorMessage = $"Can't found file containing {sectorAddress}";
                return false;
            }

            if(data.Length != track.TrackRawBytesPerSector)
            {
                ErrorMessage = "Incorrect data size";
                return false;
            }

            trackStream.Seek((long)(track.TrackFileOffset + (sectorAddress - track.TrackStartSector) * (ulong)track.TrackRawBytesPerSector),
                             SeekOrigin.Begin);
            trackStream.Write(data, 0, data.Length);

            return true;
        }

        public bool WriteSectorsLong(byte[] data, ulong sectorAddress, uint length)
        {
            if(!IsWriting)
            {
                ErrorMessage = "Tried to write on a non-writable image";
                return false;
            }

            Track track =
                writingTracks.FirstOrDefault(trk => sectorAddress >= trk.TrackStartSector &&
                                                    sectorAddress <= trk.TrackEndSector);

            if(track.TrackSequence == 0)
            {
                ErrorMessage = $"Can't found track containing {sectorAddress}";
                return false;
            }

            FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;

            if(trackStream == null)
            {
                ErrorMessage = $"Can't found file containing {sectorAddress}";
                return false;
            }

            if(sectorAddress + length > track.TrackEndSector + 1)
            {
                ErrorMessage = "Can't cross tracks";
                return false;
            }

            if(data.Length % track.TrackRawBytesPerSector != 0)
            {
                ErrorMessage = "Incorrect data size";
                return false;
            }

            trackStream.Seek((long)(track.TrackFileOffset + (sectorAddress - track.TrackStartSector) * (ulong)track.TrackRawBytesPerSector),
                             SeekOrigin.Begin);
            trackStream.Write(data, 0, data.Length);

            return true;
        }

        public bool SetTracks(List<Track> tracks)
        {
            if(!IsWriting)
            {
                ErrorMessage = "Tried to write on a non-writable image";
                return false;
            }

            if(tracks == null || tracks.Count == 0)
            {
                ErrorMessage = "Invalid tracks sent";
                return false;
            }

            ulong currentOffset = 0;
            writingTracks       = new List<Track>();
            foreach(Track track in tracks.OrderBy(t => t.TrackSequence))
            {
                Track newTrack     = track;
                newTrack.TrackFile = separateTracksWriting
                                         ? writingBaseName + $"_track{track.TrackSequence:D2}.bin"
                                         : writingBaseName + ".bin";
                newTrack.TrackFileOffset = separateTracksWriting ? 0 : currentOffset;
                writingTracks.Add(newTrack);
                currentOffset += (ulong)newTrack.TrackRawBytesPerSector *
                                 (newTrack.TrackEndSector - newTrack.TrackStartSector + 1);
            }

            writingStreams = new Dictionary<uint, FileStream>();
            if(separateTracksWriting)
                foreach(Track track in writingTracks)
                    writingStreams.Add(track.TrackSequence,
                                       new FileStream(track.TrackFile, FileMode.CreateNew, FileAccess.ReadWrite,
                                                      FileShare.None));
            else
            {
                FileStream jointstream = new FileStream(writingBaseName + ".bin", FileMode.CreateNew,
                                                        FileAccess.ReadWrite, FileShare.None);
                foreach(Track track in writingTracks) writingStreams.Add(track.TrackSequence, jointstream);
            }

            return true;
        }

        public bool Close()
        {
            if(!IsWriting)
            {
                ErrorMessage = "Image is not opened for writing";
                return false;
            }

            if(separateTracksWriting)
                foreach(FileStream writingStream in writingStreams.Values)
                {
                    writingStream.Flush();
                    writingStream.Close();
                }
            else
            {
                writingStreams.First().Value.Flush();
                writingStreams.First().Value.Close();
            }

            int currentSession = 0;

            if(!string.IsNullOrWhiteSpace(discimage.Comment))
            {
                string[] commentLines = discimage.Comment.Split(new[] {'\n'}, StringSplitOptions.RemoveEmptyEntries);
                foreach(string line in commentLines) descriptorStream.WriteLine("REM {0}", line);
            }

            descriptorStream.WriteLine("REM ORIGINAL MEDIA-TYPE {0}", MediaTypeToCdrwinType(imageInfo.MediaType));

            if(!string.IsNullOrEmpty(discimage.Cdtextfile))
                descriptorStream.WriteLine("CDTEXTFILE \"{0}\"", Path.GetFileName(discimage.Cdtextfile));

            if(!string.IsNullOrEmpty(discimage.Title)) descriptorStream.WriteLine("TITLE {0}", discimage.Title);

            if(!string.IsNullOrEmpty(discimage.Mcn)) descriptorStream.WriteLine("CATALOG {0}", discimage.Mcn);

            if(!string.IsNullOrEmpty(discimage.Barcode)) descriptorStream.WriteLine("UPC_EAN {0}", discimage.Barcode);

            if(!separateTracksWriting)
                descriptorStream.WriteLine("FILE \"{0}\" BINARY", Path.GetFileName(writingStreams.First().Value.Name));

            foreach(Track track in writingTracks)
            {
                if(track.TrackSession > currentSession) descriptorStream.WriteLine("REM SESSION {0}", ++currentSession);

                if(separateTracksWriting)
                    descriptorStream.WriteLine("FILE \"{0}\" BINARY", Path.GetFileName(track.TrackFile));

                (byte minute, byte second, byte frame) msf = LbaToMsf(track.TrackStartSector);
                descriptorStream.WriteLine("  TRACK {0:D2} {1}", track.TrackSequence, GetTrackMode(track));

                if(trackFlags.TryGetValue((byte)track.TrackSequence, out byte flagsByte))
                    if(flagsByte != 0 && flagsByte != (byte)CdFlags.DataTrack)
                    {
                        CdFlags flags = (CdFlags)flagsByte;
                        descriptorStream.WriteLine("    FLAGS{0}{1}{2}",
                                                   flags.HasFlag(CdFlags.CopyPermitted) ? " DCP" : "",
                                                   flags.HasFlag(CdFlags.FourChannel) ? " 4CH" : "",
                                                   flags.HasFlag(CdFlags.PreEmphasis) ? " PRE" : "");
                    }

                if(trackIsrcs.TryGetValue((byte)track.TrackSequence, out string isrc))
                    descriptorStream.WriteLine("    FLAGS {0}", isrc);

                descriptorStream.WriteLine("    INDEX {0:D2} {1:D2}:{2:D2}:{3:D2}", 1, msf.minute, msf.second,
                                           msf.frame);
            }

            descriptorStream.Flush();
            descriptorStream.Close();
            IsWriting = false;

            return true;
        }

        public bool SetGeometry(uint cylinders, uint heads, uint sectorsPerTrack)
        {
            ErrorMessage = "Unsupported feature";
            return false;
        }

        public bool WriteSectorTag(byte[] data, ulong sectorAddress, SectorTagType tag)
        {
            if(!IsWriting)
            {
                ErrorMessage = "Tried to write on a non-writable image";
                return false;
            }

            Track track =
                writingTracks.FirstOrDefault(trk => sectorAddress >= trk.TrackStartSector &&
                                                    sectorAddress <= trk.TrackEndSector);

            if(track.TrackSequence == 0)
            {
                ErrorMessage = $"Can't found track containing {sectorAddress}";
                return false;
            }

            switch(tag)
            {
                case SectorTagType.CdTrackFlags:
                {
                    if(data.Length != 1)
                    {
                        ErrorMessage = "Incorrect data size for track flags";
                        return false;
                    }

                    trackFlags.Add((byte)track.TrackSequence, data[0]);
                    return true;
                }
                case SectorTagType.CdTrackIsrc:
                {
                    if(data != null) trackIsrcs.Add((byte)track.TrackSequence, Encoding.UTF8.GetString(data));
                    return true;
                }
                default:
                    ErrorMessage = $"Unsupported tag type {tag}";
                    return false;
            }
        }

        public bool WriteSectorsTag(byte[] data, ulong sectorAddress, uint length, SectorTagType tag)
        {
            throw new NotImplementedException();
        }

        public bool SetMetadata(ImageInfo metadata)
        {
            discimage.Barcode = metadata.MediaBarcode;
            discimage.Comment = metadata.Comments;
            discimage.Title   = metadata.MediaTitle;
            return true;
        }

        static ulong CdrWinMsftoLba(string msf)
        {
            string[] msfElements = msf.Split(':');
            ulong    minute      = ulong.Parse(msfElements[0]);
            ulong    second      = ulong.Parse(msfElements[1]);
            ulong    frame       = ulong.Parse(msfElements[2]);

            ulong sectors = minute * 60 * 75 + second * 75 + frame;

            return sectors;
        }

        static ushort CdrWinTrackTypeToBytesPerSector(string trackType)
        {
            switch(trackType)
            {
                case CDRWIN_TRACK_TYPE_MODE1:
                case CDRWIN_TRACK_TYPE_MODE2_FORM1: return 2048;
                case CDRWIN_TRACK_TYPE_MODE2_FORM2: return 2324;
                case CDRWIN_TRACK_TYPE_MODE2_FORMLESS:
                case CDRWIN_TRACK_TYPE_CDI: return 2336;
                case CDRWIN_TRACK_TYPE_AUDIO:
                case CDRWIN_TRACK_TYPE_MODE1_RAW:
                case CDRWIN_TRACK_TYPE_MODE2_RAW:
                case CDRWIN_TRACK_TYPE_CDI_RAW: return 2352;
                case CDRWIN_TRACK_TYPE_CDG:     return 2448;
                default:                        return 0;
            }
        }

        static ushort CdrWinTrackTypeToCookedBytesPerSector(string trackType)
        {
            switch(trackType)
            {
                case CDRWIN_TRACK_TYPE_MODE1:
                case CDRWIN_TRACK_TYPE_MODE2_FORM1:
                case CDRWIN_TRACK_TYPE_MODE1_RAW:   return 2048;
                case CDRWIN_TRACK_TYPE_MODE2_FORM2: return 2324;
                case CDRWIN_TRACK_TYPE_MODE2_FORMLESS:
                case CDRWIN_TRACK_TYPE_CDI:
                case CDRWIN_TRACK_TYPE_MODE2_RAW:
                case CDRWIN_TRACK_TYPE_CDI_RAW: return 2336;
                case CDRWIN_TRACK_TYPE_AUDIO:   return 2352;
                case CDRWIN_TRACK_TYPE_CDG:     return 2448;
                default:                        return 0;
            }
        }

        static TrackType CdrWinTrackTypeToTrackType(string trackType)
        {
            switch(trackType)
            {
                case CDRWIN_TRACK_TYPE_MODE1:
                case CDRWIN_TRACK_TYPE_MODE1_RAW:   return TrackType.CdMode1;
                case CDRWIN_TRACK_TYPE_MODE2_FORM1: return TrackType.CdMode2Form1;
                case CDRWIN_TRACK_TYPE_MODE2_FORM2: return TrackType.CdMode2Form2;
                case CDRWIN_TRACK_TYPE_CDI_RAW:
                case CDRWIN_TRACK_TYPE_CDI:
                case CDRWIN_TRACK_TYPE_MODE2_RAW:
                case CDRWIN_TRACK_TYPE_MODE2_FORMLESS: return TrackType.CdMode2Formless;
                case CDRWIN_TRACK_TYPE_AUDIO:
                case CDRWIN_TRACK_TYPE_CDG: return TrackType.Audio;
                default:                    return TrackType.Data;
            }
        }

        static MediaType CdrWinIsoBusterDiscTypeToMediaType(string discType)
        {
            switch(discType)
            {
                case CDRWIN_DISK_TYPE_CD: return MediaType.CD;
                case CDRWIN_DISK_TYPE_CDRW:
                case CDRWIN_DISK_TYPE_CDMRW:
                case CDRWIN_DISK_TYPE_CDMRW2: return MediaType.CDRW;
                case CDRWIN_DISK_TYPE_DVD:    return MediaType.DVDROM;
                case CDRWIN_DISK_TYPE_DVDPRW:
                case CDRWIN_DISK_TYPE_DVDPMRW:
                case CDRWIN_DISK_TYPE_DVDPMRW2: return MediaType.DVDPRW;
                case CDRWIN_DISK_TYPE_DVDPRWDL:
                case CDRWIN_DISK_TYPE_DVDPMRWDL:
                case CDRWIN_DISK_TYPE_DVDPMRWDL2: return MediaType.DVDPRWDL;
                case CDRWIN_DISK_TYPE_DVDPR:
                case CDRWIN_DISK_TYPE_DVDPVR:  return MediaType.DVDPR;
                case CDRWIN_DISK_TYPE_DVDPRDL: return MediaType.DVDPRDL;
                case CDRWIN_DISK_TYPE_DVDRAM:  return MediaType.DVDRAM;
                case CDRWIN_DISK_TYPE_DVDVR:
                case CDRWIN_DISK_TYPE_DVDR:   return MediaType.DVDR;
                case CDRWIN_DISK_TYPE_DVDRDL: return MediaType.DVDRDL;
                case CDRWIN_DISK_TYPE_DVDRW:
                case CDRWIN_DISK_TYPE_DVDRWDL:
                case CDRWIN_DISK_TYPE_DVDRW2:   return MediaType.DVDRW;
                case CDRWIN_DISK_TYPE_HDDVD:    return MediaType.HDDVDROM;
                case CDRWIN_DISK_TYPE_HDDVDRAM: return MediaType.HDDVDRAM;
                case CDRWIN_DISK_TYPE_HDDVDR:
                case CDRWIN_DISK_TYPE_HDDVDRDL: return MediaType.HDDVDR;
                case CDRWIN_DISK_TYPE_HDDVDRW:
                case CDRWIN_DISK_TYPE_HDDVDRWDL: return MediaType.HDDVDRW;
                case CDRWIN_DISK_TYPE_BD:        return MediaType.BDROM;
                case CDRWIN_DISK_TYPE_BDR:
                case CDRWIN_DISK_TYPE_BDRDL: return MediaType.BDR;
                case CDRWIN_DISK_TYPE_BDRE:
                case CDRWIN_DISK_TYPE_BDREDL: return MediaType.BDRE;
                default:                      return MediaType.Unknown;
            }
        }

        static (byte minute, byte second, byte frame) LbaToMsf(ulong sector)
        {
            return ((byte)(sector / 75 / 60), (byte)(sector / 75 % 60), (byte)(sector % 75));
        }

        static string GetTrackMode(Track track)
        {
            switch(track.TrackType)
            {
                case TrackType.Audio when track.TrackRawBytesPerSector == 2448: return CDRWIN_TRACK_TYPE_CDG;
                case TrackType.Audio when track.TrackRawBytesPerSector == 2352:
                    return CDRWIN_TRACK_TYPE_AUDIO;
                case TrackType.Data:
                    return CDRWIN_TRACK_TYPE_MODE1;
                case TrackType.CdMode1 when track.TrackRawBytesPerSector == 2352:
                    return CDRWIN_TRACK_TYPE_MODE1_RAW;
                case TrackType.CdMode2Formless when track.TrackRawBytesPerSector != 2352:
                    return CDRWIN_TRACK_TYPE_MODE2_FORMLESS;
                case TrackType.CdMode2Form1 when track.TrackRawBytesPerSector != 2352:
                    return CDRWIN_TRACK_TYPE_MODE2_FORM1;
                case TrackType.CdMode2Form2 when track.TrackRawBytesPerSector != 2352:
                    return CDRWIN_TRACK_TYPE_MODE2_FORM2;
                case TrackType.CdMode2Formless when track.TrackRawBytesPerSector == 2352:
                case TrackType.CdMode2Form1 when track.TrackRawBytesPerSector    == 2352:
                case TrackType.CdMode2Form2 when track.TrackRawBytesPerSector    == 2352:
                    return CDRWIN_TRACK_TYPE_MODE2_RAW;
                default: return CDRWIN_TRACK_TYPE_MODE1;
            }
        }

        static string MediaTypeToCdrwinType(MediaType type)
        {
            switch(type)
            {
                case MediaType.BDRXL:
                case MediaType.BDR: return CDRWIN_DISK_TYPE_BDR;
                case MediaType.BDREXL:
                case MediaType.BDRE: return CDRWIN_DISK_TYPE_BDRE;
                case MediaType.BDROM:
                case MediaType.CBHD:
                case MediaType.PS3BD:
                case MediaType.PS4BD:
                case MediaType.UDO:
                case MediaType.UDO2:
                case MediaType.UDO2_WORM: return CDRWIN_DISK_TYPE_BD;
                case MediaType.CDV:
                case MediaType.DDCD:
                case MediaType.DDCDR:
                case MediaType.DDCDRW:
                case MediaType.CDPLUS:
                case MediaType.CDR:
                case MediaType.CDROM:
                case MediaType.CDROMXA:
                case MediaType.CD:
                case MediaType.CDDA:
                case MediaType.CDEG:
                case MediaType.CDG:
                case MediaType.CDI:
                case MediaType.CDMIDI:
                case MediaType.DTSCD:
                case MediaType.JaguarCD:
                case MediaType.MEGACD:
                case MediaType.PD650:
                case MediaType.PD650_WORM:
                case MediaType.PS1CD:
                case MediaType.PS2CD:
                case MediaType.SuperCDROM2:
                case MediaType.SVCD:
                case MediaType.SVOD:
                case MediaType.SATURNCD:
                case MediaType.ThreeDO:
                case MediaType.VCD:
                case MediaType.VCDHD:    return CDRWIN_DISK_TYPE_CD;
                case MediaType.CDMRW:    return CDRWIN_DISK_TYPE_CDMRW;
                case MediaType.CDRW:     return CDRWIN_DISK_TYPE_CDRW;
                case MediaType.DVDPR:    return CDRWIN_DISK_TYPE_DVDPR;
                case MediaType.DVDPRDL:  return CDRWIN_DISK_TYPE_DVDPRDL;
                case MediaType.DVDPRW:   return CDRWIN_DISK_TYPE_DVDPRW;
                case MediaType.DVDPRWDL: return CDRWIN_DISK_TYPE_DVDPRWDL;
                case MediaType.DVDR:     return CDRWIN_DISK_TYPE_DVDR;
                case MediaType.DVDRAM:   return CDRWIN_DISK_TYPE_DVDRAM;
                case MediaType.DVDRDL:   return CDRWIN_DISK_TYPE_DVDRDL;
                case MediaType.DVDDownload:
                case MediaType.DVDROM:
                case MediaType.UMD:
                case MediaType.PS2DVD:
                case MediaType.PS3DVD:    return CDRWIN_DISK_TYPE_DVD;
                case MediaType.DVDRW:     return CDRWIN_DISK_TYPE_DVDRW;
                case MediaType.DVDRWDL:   return CDRWIN_DISK_TYPE_DVDRWDL;
                case MediaType.HDDVDR:    return CDRWIN_DISK_TYPE_HDDVDR;
                case MediaType.HDDVDRAM:  return CDRWIN_DISK_TYPE_HDDVDRAM;
                case MediaType.HDDVDRDL:  return CDRWIN_DISK_TYPE_HDDVDRDL;
                case MediaType.HDDVDROM:  return CDRWIN_DISK_TYPE_HDDVD;
                case MediaType.HDDVDRW:   return CDRWIN_DISK_TYPE_HDDVDRW;
                case MediaType.HDDVDRWDL: return CDRWIN_DISK_TYPE_HDDVDRWDL;
                default:                  return "";
            }
        }

        struct CdrWinTrackFile
        {
            /// <summary>Track #</summary>
            public uint Sequence;
            /// <summary>Filter of file containing track</summary>
            public IFilter Datafilter;
            /// <summary>Offset of track start in file</summary>
            public ulong Offset;
            /// <summary>Type of file</summary>
            public string Filetype;
        }

        struct CdrWinTrack
        {
            /// <summary>Track #</summary>
            public uint Sequence;
            /// <summary>Track title (from CD-Text)</summary>
            public string Title;
            /// <summary>Track genre (from CD-Text)</summary>
            public string Genre;
            /// <summary>Track arranger (from CD-Text)</summary>
            public string Arranger;
            /// <summary>Track composer (from CD-Text)</summary>
            public string Composer;
            /// <summary>Track performer (from CD-Text)</summary>
            public string Performer;
            /// <summary>Track song writer (from CD-Text)</summary>
            public string Songwriter;
            /// <summary>Track ISRC</summary>
            public string Isrc;
            /// <summary>File struct for this track</summary>
            public CdrWinTrackFile Trackfile;
            /// <summary>Indexes on this track</summary>
            public Dictionary<int, ulong> Indexes;
            /// <summary>Track pre-gap in sectors</summary>
            public ulong Pregap;
            /// <summary>Track post-gap in sectors</summary>
            public ulong Postgap;
            /// <summary>Digical Copy Permitted</summary>
            public bool FlagDcp;
            /// <summary>Track is quadraphonic</summary>
            public bool Flag4ch;
            /// <summary>Track has preemphasis</summary>
            public bool FlagPre;
            /// <summary>Track has SCMS</summary>
            public bool FlagScms;
            /// <summary>Bytes per sector</summary>
            public ushort Bps;
            /// <summary>Sectors in track</summary>
            public ulong Sectors;
            /// <summary>Track type</summary>
            public string Tracktype;
            /// <summary>Track session</summary>
            public ushort Session;
        }

        struct CdrWinDisc
        {
            /// <summary>Disk title (from CD-Text)</summary>
            public string Title;
            /// <summary>Disk genre (from CD-Text)</summary>
            public string Genre;
            /// <summary>Disk arranger (from CD-Text)</summary>
            public string Arranger;
            /// <summary>Disk composer (from CD-Text)</summary>
            public string Composer;
            /// <summary>Disk performer (from CD-Text)</summary>
            public string Performer;
            /// <summary>Disk song writer (from CD-Text)</summary>
            public string Songwriter;
            /// <summary>Media catalog number</summary>
            public string Mcn;
            /// <summary>Disk type</summary>
            public MediaType Disktype;
            /// <summary>Disk type string</summary>
            public string Disktypestr;
            /// <summary>Disk CDDB ID</summary>
            public string DiskId;
            /// <summary>Disk UPC/EAN</summary>
            public string Barcode;
            /// <summary>Sessions</summary>
            public List<Session> Sessions;
            /// <summary>Tracks</summary>
            public List<CdrWinTrack> Tracks;
            /// <summary>Disk comment</summary>
            public string Comment;
            /// <summary>File containing CD-Text</summary>
            public string Cdtextfile;
        }
    }
}