// /***************************************************************************
// Aaru Data Preservation Suite
// ----------------------------------------------------------------------------
//
// Filename       : Read.cs
// Author(s)      : Natalia Portillo <claunia@claunia.com>
//
// Component      : Disk image plugins.
//
// --[ Description ] ----------------------------------------------------------
//
//     Reads 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-2025 Natalia Portillo
// ****************************************************************************/

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Aaru.CommonTypes;
using Aaru.CommonTypes.AaruMetadata;
using Aaru.CommonTypes.Enums;
using Aaru.CommonTypes.Interfaces;
using Aaru.Decoders.CD;
using Aaru.Helpers;
using Aaru.Logging;
using Partition = Aaru.CommonTypes.Partition;
using Session = Aaru.CommonTypes.Structs.Session;
using Track = Aaru.CommonTypes.Structs.Track;
using TrackType = Aaru.CommonTypes.Enums.TrackType;

namespace Aaru.Images;

public sealed partial class CdrWin
{
#region IWritableOpticalImage Members

    /// <inheritdoc />
    public ErrorNumber Open(IFilter imageFilter)
    {
        if(imageFilter == null) return ErrorNumber.InvalidArgument;

        _cdrwinFilter = imageFilter;

        try
        {
            imageFilter.GetDataForkStream().Seek(0, SeekOrigin.Begin);
            _cueStream = new StreamReader(imageFilter.GetDataForkStream());
            var  lineNumber     = 0;
            var  inTrack        = false;
            byte currentSession = 1;

            // Initialize all RegExs
            Regex regexSession                = SessionRegex();
            Regex regexDiskType               = MediaTypeRegex();
            Regex regexLeadOut                = LeadOutRegex();
            Regex regexLba                    = LbaRegex();
            Regex regexDiskId                 = DiscIdRegex();
            Regex regexBarCode                = BarcodeRegex();
            Regex regexComment                = CommentRegex();
            Regex regexCdText                 = CdtextRegex();
            Regex regexMcn                    = McnRegex();
            Regex regexTitle                  = TitleRegex();
            Regex regexGenre                  = GenreRegex();
            Regex regexArranger               = ArrangerRegex();
            Regex regexComposer               = ComposerRegex();
            Regex regexPerformer              = PerformerRegex();
            Regex regexSongWriter             = SongwriterRegex();
            Regex regexFile                   = FileRegex();
            Regex regexTrack                  = TrackRegex();
            Regex regexIsrc                   = IsrcRegex();
            Regex regexIndex                  = IndexRegex();
            Regex regexPregap                 = PregapRegex();
            Regex regexPostgap                = PostgapRegex();
            Regex regexFlags                  = FlagsRegex();
            Regex regexApplication            = ApplicationRegex();
            Regex regexTruripDisc             = TruripDiscHashesRegex();
            Regex regexTruripDiscCrc32        = TruripDiscCrc32Regex();
            Regex regexTruripDiscMd5          = TruripDiscMd5Regex();
            Regex regexTruripDiscSha1         = TruripDiscSha1Regex();
            Regex regexTruripTrack            = TruripTrackMethodRegex();
            Regex regexTruripTrackCrc32       = TruripTrackCrc32Regex();
            Regex regexTruripTrackMd5         = TruripTrackMd5Regex();
            Regex regexTruripTrackSha1        = TruripTrackSha1Regex();
            Regex regexTruripTrackUnknownHash = TruripTrackUnknownRegex();
            Regex regexDicMediaType           = DicMediaTypeRegex();
            Regex regexApplicationVersion     = ApplicationVersionRegex();
            Regex regexDumpExtent             = DumpExtentRegex();
            Regex regexAaruMediaType          = AaruMediaTypeRegex();
            Regex regexRedumpSdArea           = RedumpSdAreaRegex();
            Regex regexRedumpHdArea           = RedumpHdAreaRegex();

            // Initialize all RegEx matches
            Match matchTrack;

            // Initialize disc
            _discImage = new CdrWinDisc
            {
                Sessions   = [],
                Tracks     = [],
                Comment    = "",
                DiscHashes = new Dictionary<string, string>()
            };

            var currentTrack = new CdrWinTrack
            {
                Indexes = new SortedDictionary<ushort, int>()
            };

            var  currentFile             = new CdrWinTrackFile();
            long currentFileOffsetSector = 0;

            var trackCount = 0;

            Dictionary<byte, int> leadouts = new();

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

                matchTrack = regexTrack.Match(line);

                if(!matchTrack.Success) continue;

                var trackSeq = uint.Parse(matchTrack.Groups[1].Value);

                if(trackCount + 1 != trackSeq)
                {
                    AaruLogging.Error(string.Format(Localization.Found_TRACK_0_out_of_order_in_line_1,
                                                    trackSeq,
                                                    lineNumber));

                    return ErrorNumber.InvalidArgument;
                }

                trackCount++;
            }

            if(trackCount == 0)
            {
                AaruLogging.Error(Localization.No_tracks_found);

                return ErrorNumber.InvalidArgument;
            }

            var cueTracks = new CdrWinTrack[trackCount];

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

            var inTruripDiscHash      = false;
            var inTruripTrackHash     = false;
            var firstTrackInSession   = false;
            var currentEmptyPregap    = 0;
            var cumulativeEmptyPregap = 0;

            const ulong gdRomSession2Offset = 45000;

            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);
                Match matchApplication        = regexApplication.Match(line);
                Match matchTruripDisc         = regexTruripDisc.Match(line);
                Match matchTruripTrack        = regexTruripTrack.Match(line);
                Match matchDicMediaType       = regexDicMediaType.Match(line);
                Match matchApplicationVersion = regexApplicationVersion.Match(line);
                Match matchDumpExtent         = regexDumpExtent.Match(line);
                Match matchAaruMediaType      = regexAaruMediaType.Match(line);
                Match matchRedumpSdArea       = regexRedumpSdArea.Match(line);
                Match matchRedumpHdArea       = regexRedumpHdArea.Match(line);

                if(inTruripDiscHash)
                {
                    Match matchTruripDiscCrc32 = regexTruripDiscCrc32.Match(line);
                    Match matchTruripDiscMd5   = regexTruripDiscMd5.Match(line);
                    Match matchTruripDiscSha1  = regexTruripDiscSha1.Match(line);

                    if(matchTruripDiscCrc32.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_CRC32_at_line_0, lineNumber);
                        _discImage.DiscHashes.Add("crc32", matchTruripDiscCrc32.Groups[1].Value.ToLowerInvariant());

                        continue;
                    }

                    if(matchTruripDiscMd5.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_MD5_at_line_0, lineNumber);
                        _discImage.DiscHashes.Add("md5", matchTruripDiscMd5.Groups[1].Value.ToLowerInvariant());

                        continue;
                    }

                    if(matchTruripDiscSha1.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_SHA1_at_line_0, lineNumber);
                        _discImage.DiscHashes.Add("sha1", matchTruripDiscSha1.Groups[1].Value.ToLowerInvariant());

                        continue;
                    }
                }
                else if(inTruripTrackHash)
                {
                    Match matchTruripTrackCrc32       = regexTruripTrackCrc32.Match(line);
                    Match matchTruripTrackMd5         = regexTruripTrackMd5.Match(line);
                    Match matchTruripTrackSha1        = regexTruripTrackSha1.Match(line);
                    Match matchTruripTrackUnknownHash = regexTruripTrackUnknownHash.Match(line);

                    if(matchTruripTrackCrc32.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME,
                                          Localization.Found_CRC32_for_1_2_at_line_0,
                                          lineNumber,
                                          matchTruripTrackCrc32.Groups[1].Value == "Trk"
                                              ? Localization.track
                                              : Localization.gap,
                                          matchTruripTrackCrc32.Groups[2].Value);

                        continue;
                    }

                    if(matchTruripTrackMd5.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME,
                                          Localization.Found_MD5_for_1_2_at_line_0,
                                          lineNumber,
                                          matchTruripTrackMd5.Groups[1].Value == "Trk"
                                              ? Localization.track
                                              : Localization.gap,
                                          matchTruripTrackMd5.Groups[2].Value);

                        continue;
                    }

                    if(matchTruripTrackSha1.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME,
                                          Localization.Found_SHA1_for_1_2_at_line_0,
                                          lineNumber,
                                          matchTruripTrackSha1.Groups[1].Value == "Trk"
                                              ? Localization.track
                                              : Localization.gap,
                                          matchTruripTrackSha1.Groups[2].Value);

                        continue;
                    }

                    if(matchTruripTrackUnknownHash.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME,
                                          Localization
                                             .Found_unknown_hash_for_1_2_at_line_0_Please_report_this_disc_image,
                                          lineNumber,
                                          matchTruripTrackUnknownHash.Groups[1].Value == "Trk"
                                              ? Localization.track
                                              : Localization.gap,
                                          matchTruripTrackUnknownHash.Groups[2].Value);

                        continue;
                    }
                }

                inTruripDiscHash  = false;
                inTruripTrackHash = false;

                if(matchDumpExtent.Success                                                      &&
                   !inTrack                                                                     &&
                   ulong.TryParse(matchDumpExtent.Groups["start"].Value, out ulong extentStart) &&
                   ulong.TryParse(matchDumpExtent.Groups["end"].Value,   out ulong extentEnd))
                {
                    AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_METADATA_DUMP_EXTENT_at_line_0, lineNumber);

                    DumpHardware ??= [];

                    DumpHardware existingDump =
                        DumpHardware.FirstOrDefault(d =>
                                                        d.Manufacturer ==
                                                        matchDumpExtent.Groups["manufacturer"].Value           &&
                                                        d.Model    == matchDumpExtent.Groups["model"].Value    &&
                                                        d.Firmware == matchDumpExtent.Groups["firmware"].Value &&
                                                        d.Serial   == matchDumpExtent.Groups["serial"].Value   &&
                                                        d.Software.Name ==
                                                        matchDumpExtent.Groups["application"].Value                   &&
                                                        d.Software.Version == matchDumpExtent.Groups["version"].Value &&
                                                        d.Software.OperatingSystem ==
                                                        matchDumpExtent.Groups["os"].Value);

                    if(existingDump is null)
                    {
                        DumpHardware.Add(new DumpHardware
                        {
                            Extents =
                            [
                                new Extent
                                {
                                    Start = extentStart,
                                    End   = extentEnd
                                }
                            ],
                            Firmware     = matchDumpExtent.Groups["firmware"].Value,
                            Manufacturer = matchDumpExtent.Groups["manufacturer"].Value,
                            Model        = matchDumpExtent.Groups["model"].Value,
                            Serial       = matchDumpExtent.Groups["serial"].Value,
                            Software = new Software
                            {
                                Name            = matchDumpExtent.Groups["application"].Value,
                                Version         = matchDumpExtent.Groups["version"].Value,
                                OperatingSystem = matchDumpExtent.Groups["os"].Value
                            }
                        });
                    }
                    else
                    {
                        existingDump.Extents = new List<Extent>(existingDump.Extents)
                            {
                                new()
                                {
                                    Start = extentStart,
                                    End   = extentEnd
                                }
                            }.OrderBy(static e => e.Start)
                             .ToList();
                    }
                }
                else if(matchDicMediaType.Success && !inTrack)
                {
                    AaruLogging.Debug(MODULE_NAME,
                                      Localization.Found_REM_METADATA_DIC_MEDIA_TYPE_at_line_0,
                                      lineNumber);

                    _discImage.AaruMediaType = matchDicMediaType.Groups[1].Value;
                }
                else if(matchAaruMediaType.Success && !inTrack)
                {
                    AaruLogging.Debug(MODULE_NAME,
                                      Localization.Found_REM_METADATA_AARU_MEDIA_TYPE_at_line_0,
                                      lineNumber);

                    _discImage.AaruMediaType = matchAaruMediaType.Groups[1].Value;
                }
                else if(matchDiskType.Success && !inTrack)
                {
                    AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_ORIGINAL_MEDIA_TYPE_at_line_0, lineNumber);

                    _discImage.OriginalMediaType = matchDiskType.Groups[1].Value;
                }
                else if(matchSession.Success)
                {
                    AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_SESSION_at_line_0, lineNumber);
                    currentSession      = byte.Parse(matchSession.Groups[1].Value);
                    firstTrackInSession = true;
                }
                else if(matchRedumpSdArea.Success)
                {
                    AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_SINGLE_DENSITY_AREA_at_line_0, lineNumber);

                    _discImage.IsRedumpGigadisc = true;
                    firstTrackInSession         = true;
                }
                else if(matchRedumpHdArea.Success)
                {
                    AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_HIGH_DENSITY_AREA_at_line_0, lineNumber);

                    _discImage.IsRedumpGigadisc = true;
                    currentSession              = 2;
                    firstTrackInSession         = true;
                }
                else if(matchLba.Success)
                    AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_MSF_at_line_0, lineNumber);
                else if(matchLeadOut.Success)
                {
                    AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_LEAD_OUT_at_line_0, lineNumber);
                    leadouts[currentSession] = CdrWinMsfToLba(matchLeadOut.Groups[1].Value);
                }
                else if(matchApplication.Success)
                {
                    AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_Ripping_Tool_at_line_0, lineNumber);

                    _imageInfo.Application = matchApplication.Groups[1].Value;
                }
                else if(matchApplicationVersion.Success && !inTrack)
                {
                    AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_Ripping_Tool_Version_at_line_0, lineNumber);

                    _imageInfo.ApplicationVersion = matchApplicationVersion.Groups[1].Value;
                }
                else if(matchTruripDisc.Success)
                {
                    AaruLogging.Debug(MODULE_NAME, Localization.Found_REM_DISC_HASHES_at_line_0, lineNumber);

                    inTruripDiscHash = true;
                }
                else if(matchTruripTrack.Success)
                {
                    AaruLogging.Debug(MODULE_NAME,
                                      Localization.Found_REM_Gap_Append_Method_1_2_HASHES_at_line_0,
                                      lineNumber,
                                      matchTruripTrack.Groups[1].Value,
                                      matchTruripTrack.Groups[2].Value);

                    inTruripTrackHash   = true;
                    _discImage.IsTrurip = true;
                }
                else if(matchComment.Success)
                {
                    AaruLogging.Debug(MODULE_NAME, Localization.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)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.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)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_UPC_EAN_at_line_0, lineNumber);

                        if(!inTrack)
                            _discImage.Barcode = matchBarCode.Groups[1].Value;
                        else
                        {
                            AaruLogging.Error(string.Format(Localization
                                                               .Found_barcode_field_in_incorrect_place_at_line_0,
                                                            lineNumber));

                            return ErrorNumber.InvalidArgument;
                        }
                    }
                    else if(matchCdText.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_CDTEXTFILE_at_line_0, lineNumber);

                        if(!inTrack)
                            _discImage.CdTextFile = matchCdText.Groups[1].Value;
                        else
                        {
                            AaruLogging.Error(string.Format(Localization
                                                               .Found_CD_Text_file_field_in_incorrect_place_at_line_0,
                                                            lineNumber));

                            return ErrorNumber.InvalidArgument;
                        }
                    }
                    else if(matchComposer.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.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)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_DISC_ID_at_line_0, lineNumber);

                        if(!inTrack)
                            _discImage.DiscId = matchDiskId.Groups[1].Value;
                        else
                        {
                            AaruLogging.Error(string.Format(Localization
                                                               .Found_CDDB_ID_field_in_incorrect_place_at_line_0,
                                                            lineNumber));

                            return ErrorNumber.InvalidArgument;
                        }
                    }
                    else if(matchFile.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_FILE_at_line_0, lineNumber);

                        if(currentTrack.Sequence != 0)
                        {
                            currentFile.Sequence   = currentTrack.Sequence;
                            currentTrack.TrackFile = currentFile;

                            _negativeEnd = currentFile.DataFilter.Length - (long)currentFile.Offset < 0;

                            currentTrack.Sectors = ((ulong)currentFile.DataFilter.Length - currentFile.Offset) /
                                                   CdrWinTrackTypeToBytesPerSector(currentTrack.TrackType);

                            cueTracks[currentTrack.Sequence - 1] = currentTrack;
                            inTrack                              = false;
                            currentTrack                         = new CdrWinTrack();
                            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[^1] == '"')
                            datafile = datafile.Substring(1, datafile.Length - 2); // Unquote it

                        currentFile.DataFilter = PluginRegister.Singleton.GetFilter(datafile);

                        // Check if file exists
                        if(currentFile.DataFilter == null)
                        {
                            if(datafile[0] == '/' || datafile[0] == '/' && datafile[1] == '.') // UNIX absolute path
                            {
                                var   unixPath      = new Regex("^(.+)/([^/]+)$");
                                Match unixPathMatch = unixPath.Match(datafile);

                                if(unixPathMatch.Success)
                                {
                                    currentFile.DataFilter =
                                        PluginRegister.Singleton.GetFilter(unixPathMatch.Groups[1].Value);

                                    if(currentFile.DataFilter == null)
                                    {
                                        string path = imageFilter.ParentFolder +
                                                      Path.PathSeparator       +
                                                      unixPathMatch.Groups[1].Value;

                                        currentFile.DataFilter = PluginRegister.Singleton.GetFilter(path);

                                        if(currentFile.DataFilter == null)
                                        {
                                            AaruLogging.Error(string.Format(Localization.File_0_not_found,
                                                                            matchFile.Groups[1].Value));

                                            return ErrorNumber.NoSuchFile;
                                        }
                                    }
                                }
                                else
                                {
                                    AaruLogging.Error(string.Format(Localization.File_0_not_found,
                                                                    matchFile.Groups[1].Value));

                                    return ErrorNumber.NoSuchFile;
                                }
                            }
                            else if(datafile[1] == ':'  && datafile[2] == '\\' ||
                                    datafile[0] == '\\' && datafile[1] == '\\' ||
                                    datafile[0] == '.'  && datafile[1] == '\\') // Windows absolute path
                            {
                                var winPath =
                                    new
                                        Regex("^(?:[a-zA-Z]\\:(\\\\|\\/)|file\\:\\/\\/|\\\\\\\\|\\.(\\/|\\\\))([^\\\\\\/\\:\\*\\?\\<\\>\\\"\\|]+(\\\\|\\/){0,1})+$");

                                Match winPathMatch = winPath.Match(datafile);

                                if(winPathMatch.Success)
                                {
                                    currentFile.DataFilter =
                                        PluginRegister.Singleton.GetFilter(winPathMatch.Groups[1].Value);

                                    if(currentFile.DataFilter == null)
                                    {
                                        string path = imageFilter.ParentFolder +
                                                      Path.PathSeparator       +
                                                      winPathMatch.Groups[1].Value;

                                        currentFile.DataFilter = PluginRegister.Singleton.GetFilter(path);

                                        if(currentFile.DataFilter == null)
                                        {
                                            AaruLogging.Error(string.Format(Localization.File_0_not_found,
                                                                            matchFile.Groups[1].Value));

                                            return ErrorNumber.NoSuchFile;
                                        }
                                    }
                                }
                                else
                                {
                                    AaruLogging.Error(string.Format(Localization.File_0_not_found,
                                                                    matchFile.Groups[1].Value));

                                    return ErrorNumber.NoSuchFile;
                                }
                            }
                            else
                            {
                                string path = imageFilter.ParentFolder + Path.PathSeparator + datafile;
                                currentFile.DataFilter = PluginRegister.Singleton.GetFilter(path);

                                if(currentFile.DataFilter == null)
                                {
                                    AaruLogging.Error(string.Format(Localization.File_0_not_found,
                                                                    matchFile.Groups[1].Value));

                                    return ErrorNumber.NoSuchFile;
                                }
                            }
                        }

                        // File does exist, process it
                        AaruLogging.Debug(MODULE_NAME, Localization.File_0_found, currentFile.DataFilter.Filename);

                        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:
                                AaruLogging.Error(string.Format(Localization.Unsupported_file_type_0,
                                                                currentFile.FileType));

                                return ErrorNumber.NotImplemented;
                            default:
                                AaruLogging.Error(string.Format(Localization.Unknown_file_type_0,
                                                                currentFile.FileType));

                                return ErrorNumber.InvalidArgument;
                        }

                        currentFile.Offset   = 0;
                        currentFile.Sequence = 0;
                    }
                    else if(matchFlags.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_FLAGS_at_line_0, lineNumber);

                        if(!inTrack)
                        {
                            AaruLogging.Error(string.Format(Localization.Found_FLAGS_field_in_incorrect_place_at_line_0,
                                                            lineNumber));

                            return ErrorNumber.InvalidArgument;
                        }

                        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)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.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)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_INDEX_at_line_0, lineNumber);

                        if(!inTrack)
                        {
                            AaruLogging.Error(string.Format(Localization.Found_INDEX_before_a_track_0, lineNumber));

                            return ErrorNumber.InvalidArgument;
                        }

                        var index  = ushort.Parse(matchIndex.Groups[1].Value);
                        int offset = CdrWinMsfToLba(matchIndex.Groups[2].Value) + cumulativeEmptyPregap;

                        if(index != 0 && index != 1 && currentTrack.Indexes.Count == 0)
                        {
                            AaruLogging.Error(string.Format(Localization.Found_INDEX_0_before_INDEX_00_or_INDEX_01,
                                                            index));

                            return ErrorNumber.InvalidArgument;
                        }

                        if(index == 0 || index == 1 && !currentTrack.Indexes.ContainsKey(0))
                        {
                            if((int)(currentTrack.Sequence - 2) >= 0 && offset > 1)
                            {
                                cueTracks[currentTrack.Sequence - 2].Sectors =
                                    (ulong)(offset - (int)currentFileOffsetSector);

                                currentFile.Offset += cueTracks[currentTrack.Sequence - 2].Sectors *
                                                      cueTracks[currentTrack.Sequence - 2].Bps;

                                AaruLogging.Debug(MODULE_NAME,
                                                  Localization.Sets_currentFile_offset_to_0,
                                                  currentFile.Offset);

                                AaruLogging.Debug(MODULE_NAME,
                                                  "cueTracks[currentTrack.sequence-2].sectors = {0}",
                                                  cueTracks[currentTrack.Sequence - 2].Sectors);

                                AaruLogging.Debug(MODULE_NAME,
                                                  "cueTracks[currentTrack.sequence-2].bps = {0}",
                                                  cueTracks[currentTrack.Sequence - 2].Bps);
                            }
                        }

                        if((index == 0 || index == 1 && !currentTrack.Indexes.ContainsKey(0)) &&
                           currentTrack.Sequence == 1)
                        {
                            AaruLogging.Debug(MODULE_NAME,
                                              Localization.Sets_currentFile_offset_to_0,
                                              offset * currentTrack.Bps);

                            currentFile.Offset = (ulong)(offset * currentTrack.Bps);
                        }

                        if(currentTrack.Indexes.Count == 0)
                        {
                            if(firstTrackInSession && index != 0 && offset > 150)
                            {
                                currentTrack.Indexes[0] =  offset - 150;
                                firstTrackInSession     =  false;
                                currentFileOffsetSector =  offset - 150;
                                currentFile.Offset      -= (ulong)(150 * currentTrack.Bps);
                            }
                            else
                                currentFileOffsetSector = offset;
                        }

                        if(index == 1 && currentEmptyPregap > 0 && !currentTrack.Indexes.ContainsKey(0))
                        {
                            currentTrack.Indexes[0] =  offset;
                            currentFile.Offset      -= (ulong)(currentEmptyPregap * currentTrack.Bps);
                            offset                  += currentEmptyPregap;
                            cumulativeEmptyPregap   += currentEmptyPregap;
                            currentEmptyPregap      =  0;
                        }

                        currentTrack.Indexes.Add(index, offset);
                    }
                    else if(matchIsrc.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_ISRC_at_line_0, lineNumber);

                        if(!inTrack)
                        {
                            AaruLogging.Error(string.Format(Localization.Found_ISRC_before_a_track_0, lineNumber));

                            return ErrorNumber.InvalidArgument;
                        }

                        currentTrack.Isrc = matchIsrc.Groups[1].Value;
                    }
                    else if(matchMcn.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_CATALOG_at_line_0, lineNumber);

                        if(!inTrack)
                            _discImage.Mcn = matchMcn.Groups[1].Value;
                        else
                        {
                            AaruLogging.Error(string.Format(Localization
                                                               .Found_CATALOG_field_in_incorrect_place_at_line_0,
                                                            lineNumber));

                            return ErrorNumber.InvalidArgument;
                        }
                    }
                    else if(matchPerformer.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.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)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_POSTGAP_at_line_0, lineNumber);

                        if(inTrack)
                            currentTrack.Postgap = CdrWinMsfToLba(matchPostgap.Groups[1].Value);
                        else
                        {
                            AaruLogging.Error(string.Format(Localization.Found_POSTGAP_field_before_a_track_at_line_0,
                                                            lineNumber));

                            return ErrorNumber.InvalidArgument;
                        }
                    }
                    else if(matchPregap.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_PREGAP_at_line_0, lineNumber);

                        if(!inTrack)
                        {
                            AaruLogging.Error(string.Format(Localization.Found_PREGAP_field_before_a_track_at_line_0,
                                                            lineNumber));

                            return ErrorNumber.InvalidArgument;
                        }

                        currentEmptyPregap = CdrWinMsfToLba(matchPregap.Groups[1].Value);
                    }
                    else if(matchSongWriter.Success)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.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)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.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)
                    {
                        AaruLogging.Debug(MODULE_NAME, Localization.Found_TRACK_at_line_0, lineNumber);

                        if(currentFile.DataFilter == null)
                        {
                            AaruLogging.Error(string.Format(Localization
                                                               .Found_TRACK_field_before_a_file_is_defined_at_line_0,
                                                            lineNumber));

                            return ErrorNumber.InvalidArgument;
                        }

                        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 SortedDictionary<ushort, int>(),
                            Sequence = uint.Parse(matchTrack.Groups[1].Value)
                        };

                        AaruLogging.Debug(MODULE_NAME,
                                          Localization.Setting_currentTrack_sequence_to_0,
                                          currentTrack.Sequence);

                        currentFile.Sequence   = currentTrack.Sequence;
                        currentTrack.Bps       = CdrWinTrackTypeToBytesPerSector(matchTrack.Groups[2].Value);
                        currentTrack.TrackType = matchTrack.Groups[2].Value.ToUpperInvariant();
                        currentTrack.Session   = currentSession;
                        inTrack                = true;
                    }
                    else if(line.Contains("INDEX 01 00:-2:00"))
                    {
                        AaruLogging.Error(Localization
                                             .This_image_from_PowerISO_is_damaged_beyond_possible_recovery_Will_not_open);

                        return ErrorNumber.InvalidArgument;
                    }
                    else if(line == "") // Empty line, ignore it
                    {}
                    else // Non-empty unknown field
                    {
                        AaruLogging.Error(string.Format(Localization.Found_unknown_field_defined_at_line_0_1,
                                                        lineNumber,
                                                        line));

                        return ErrorNumber.NotSupported;
                    }
                }
            }

            if(currentTrack.Sequence != 0)
            {
                currentFile.Sequence   = currentTrack.Sequence;
                currentTrack.TrackFile = currentFile;

                _negativeEnd = currentFile.DataFilter.Length - (long)currentFile.Offset < 0;

                currentTrack.Sectors = ((ulong)currentFile.DataFilter.Length - currentFile.Offset) /
                                       CdrWinTrackTypeToBytesPerSector(currentTrack.TrackType);

                cueTracks[currentTrack.Sequence - 1] = currentTrack;
            }

            if(_negativeEnd)
            {
                string firstFile = cueTracks[0].TrackFile.DataFilter.Path;

                if(cueTracks.Any(t => t.Session > 1 || t.TrackFile.DataFilter.Path != firstFile) ||
                   cueTracks[0].Indexes.ContainsKey(0))
                {
                    AaruLogging.Error(Localization
                                         .The_data_files_are_not_correct_according_to_the_cuesheet_file_cannot_continue_with_this_file);

                    return ErrorNumber.InvalidArgument;
                }

                cueTracks[0].Pregap = cueTracks[0].Indexes[1];
                int reduceOffset = cueTracks[0].Pregap * cueTracks[0].Bps;

                foreach(CdrWinTrack track in cueTracks) track.TrackFile.Offset -= (ulong)reduceOffset;

                if(currentFile.DataFilter.Length - (long)cueTracks[currentTrack.Sequence - 1].TrackFile.Offset < 0)
                {
                    AaruLogging.Error(Localization
                                         .The_data_files_are_not_correct_according_to_the_cuesheet_file_cannot_continue_with_this_file);

                    return ErrorNumber.InvalidArgument;
                }

                cueTracks[currentTrack.Sequence - 1].Sectors =
                    ((ulong)currentFile.DataFilter.Length - cueTracks[currentTrack.Sequence - 1].TrackFile.Offset) /
                    cueTracks[currentTrack.Sequence - 1].Bps;

                cueTracks[0].Indexes[0] =  0;
                _lostPregap             =  (uint)cueTracks[0].Pregap;
                cueTracks[0].Sectors    += _lostPregap;

                AaruLogging.Error(Localization
                                     .The_data_files_are_missing_a_pregap_or_hidden_track_contents_will_do_best_effort_to_make_the_rest_of_the_image_readable);
            }

            var sessions = new Session[currentSession];

            for(var s = 1; s <= sessions.Length; s++)
            {
                var firstTrackRead = false;
                sessions[s - 1].Sequence = (ushort)s;

                ulong sessionSectors   = 0;
                var   lastSessionTrack = 0;
                var   firstSessionTrk  = 0;

                for(var i = 0; i < cueTracks.Length; i++)
                {
                    if(cueTracks[i].Session != s) continue;

                    if(!firstTrackRead)
                    {
                        firstSessionTrk = i;
                        firstTrackRead  = true;
                    }

                    sessionSectors += cueTracks[i].Sectors;

                    if(i > lastSessionTrack) lastSessionTrack = i;
                }

                if(s > 1)
                {
                    if(_discImage.IsRedumpGigadisc)
                        sessions[s - 1].StartSector = gdRomSession2Offset;
                    else
                        sessions[s - 1].StartSector = sessions[s - 2].EndSector + 1;
                }
                else
                    sessions[s - 1].StartSector = 0;

                sessions[s - 1].StartTrack = cueTracks[firstSessionTrk].Sequence;
                sessions[s - 1].EndTrack   = cueTracks[lastSessionTrack].Sequence;

                if(leadouts.TryGetValue((byte)s, out int leadout))
                {
                    sessions[s - 1].EndSector = (ulong)(leadout - 1);

                    if(!cueTracks[lastSessionTrack].Indexes.TryGetValue(0, out int startSector))
                        cueTracks[lastSessionTrack].Indexes.TryGetValue(1, out startSector);

                    cueTracks[lastSessionTrack].Sectors = (ulong)(leadout - startSector);
                }
                else
                    sessions[s - 1].EndSector = sessions[s - 1].StartSector + sessionSectors - 1;

                CdrWinTrack firstSessionTrack = cueTracks.OrderBy(static t => t.Sequence).First(t => t.Session == s);

                firstSessionTrack.Indexes.TryGetValue(0, out firstSessionTrack.Pregap);

                if(firstSessionTrack.Pregap < 150) firstSessionTrack.Pregap = 150;

                if(cueTracks.Any(i => i.TrackFile.DataFilter.Filename !=
                                      cueTracks.First().TrackFile.DataFilter.Filename))
                    continue;

                if(firstSessionTrack.Indexes.TryGetValue(0, out int sessionStart))
                {
                    sessions[s - 1].StartSector = (ulong)sessionStart;

                    continue;
                }

                if(firstSessionTrack.Indexes.TryGetValue(1, out sessionStart))
                    sessions[s - 1].StartSector = (ulong)sessionStart;
            }

            for(var t = 1; t <= cueTracks.Length; t++)
            {
                if(cueTracks[t - 1].Indexes.TryGetValue(0, out int idx0) &&
                   cueTracks[t - 1].Indexes.TryGetValue(1, out int idx1))
                    cueTracks[t - 1].Pregap = idx1 - idx0;

                _discImage.Tracks.Add(cueTracks[t - 1]);
            }

            // MagicISO writes 2048 bytes per data, sets Cuesheet as 2352, and fill the images with empty data.
            if(_discImage.Tracks.Count == 1 && _discImage.Tracks[0].TrackType == "MODE1/2352")
            {
                Stream track1Stream = _discImage.Tracks[0].TrackFile.DataFilter.GetDataForkStream();

                var foundSync = true;

                var rnd = new Random();

                // We check 32 random positions, to prevent coincidence of data
                for(var i = 0; i < 32; i++)
                {
                    int next = rnd.Next(cueTracks[^1].Indexes[1]);

                    track1Stream.Position = next * 2352;
                    var data = new byte[16];
                    track1Stream.EnsureRead(data, 0, 16);

                    // If the position is not MODEx/2352, it can't be a correct Cuesheet.
                    if(data[0x000] == 0x00 &&
                       data[0x001] == 0xFF &&
                       data[0x002] == 0xFF &&
                       data[0x003] == 0xFF &&
                       data[0x004] == 0xFF &&
                       data[0x005] == 0xFF &&
                       data[0x006] == 0xFF &&
                       data[0x007] == 0xFF &&
                       data[0x008] == 0xFF &&
                       data[0x009] == 0xFF &&
                       data[0x00A] == 0xFF &&
                       data[0x00B] == 0x00)
                        continue;

                    foundSync = false;

                    break;
                }

                if(!foundSync)
                {
                    _discImage.Tracks[0].Pregap    = 0;
                    _discImage.Tracks[0].Bps       = 2048;
                    _discImage.Tracks[0].TrackType = CDRWIN_TRACK_TYPE_MODE1;
                    _imageInfo.Application         = "MagicISO";
                    _discImage.MediaType           = MediaType.DVDROM;

                    AaruLogging.Error(Localization
                                         .This_image_is_most_probably_corrupted_beyond_repair_It_is_highly_recommended_to_dump_it_with_another_software);
                }
            }

            if(!string.IsNullOrWhiteSpace(_discImage.AaruMediaType) &&
               Enum.TryParse(_discImage.AaruMediaType, true, out MediaType mediaType))
                _discImage.MediaType = mediaType;
            else if(_discImage.IsRedumpGigadisc)
                _discImage.MediaType = MediaType.GDROM;
            else if(_discImage.MediaType == MediaType.Unknown)
                _discImage.MediaType = CdrWinIsoBusterDiscTypeToMediaType(_discImage.OriginalMediaType);

            if(_discImage.MediaType is MediaType.Unknown or MediaType.CD)
            {
                var data       = false;
                var cdg        = false;
                var cdi        = false;
                var mode2      = false;
                var firstAudio = false;
                var firstData  = false;
                var audio      = false;

                for(var 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.MediaType = MediaType.CDDA;
                else if(cdg)
                    _discImage.MediaType = MediaType.CDG;
                else if(cdi)
                    _discImage.MediaType = MediaType.CDI;
                else if(firstAudio && data && sessions.Length > 1 && mode2)
                    _discImage.MediaType = MediaType.CDPLUS;
                else if(firstData && audio || mode2)
                    _discImage.MediaType = MediaType.CDROMXA;
                else if(!audio)
                    _discImage.MediaType = MediaType.CDROM;
                else
                    _discImage.MediaType = MediaType.CD;
            }

            // DEBUG information
            AaruLogging.Debug(MODULE_NAME, Localization.Disc_image_parsing_results);
            AaruLogging.Debug(MODULE_NAME, Localization.Disc_CD_TEXT);

            if(_discImage.Arranger == null)
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Arranger_is_not_set);
            else
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Arranger_0, _discImage.Arranger);

            if(_discImage.Composer == null)
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Composer_is_not_set);
            else
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Composer_0, _discImage.Composer);

            if(_discImage.Genre == null)
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Genre_is_not_set);
            else
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Genre_0, _discImage.Genre);

            if(_discImage.Performer == null)
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Performer_is_not_set);
            else
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Performer_0, _discImage.Performer);

            if(_discImage.Songwriter == null)
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Songwriter_is_not_set);
            else
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Songwriter_0, _discImage.Songwriter);

            if(_discImage.Title == null)
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Title_is_not_set);
            else
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Title_0, _discImage.Title);

            if(_discImage.CdTextFile == null)
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.CD_TEXT_binary_file_not_set);
            else
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.CD_TEXT_binary_file_0, _discImage.CdTextFile);

            AaruLogging.Debug(MODULE_NAME, Localization.Disc_information);

            if(_discImage.OriginalMediaType == null)
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.ISOBuster_disc_type_not_set);
            else
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.ISOBuster_disc_type_0, _discImage.OriginalMediaType);

            AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Guessed_disk_type_0, _discImage.MediaType);

            if(_discImage.Barcode == null)
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Barcode_not_set);
            else
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Barcode_0, _discImage.Barcode);

            if(_discImage.DiscId == null)
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Disc_ID_not_set);
            else
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Disc_ID_0, _discImage.DiscId);

            if(_discImage.Mcn == null)
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.MCN_not_set);
            else
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.MCN_0, _discImage.Mcn);

            if(_discImage.Comment == null)
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Comment_not_set);
            else
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Comment_0, _discImage.Comment);

            AaruLogging.Debug(MODULE_NAME, Localization.Track_information);

            AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Disc_contains_0_tracks, _discImage.Tracks.Count);

            foreach(CdrWinTrack t in _discImage.Tracks)
            {
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Track_0_information, t.Sequence);

                AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization._0_bytes_per_sector, t.Bps);
                AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Pregap_0_sectors,    t.Pregap);
                AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Data_0_sectors,      t.Sectors);

                AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Postgap_0_sectors, t.Postgap);

                if(t.Flag4Ch) AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Track_is_flagged_as_quadraphonic);

                if(t.FlagDcp) AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Track_allows_digital_copy);

                if(t.FlagPre) AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Track_has_pre_emphasis_applied);

                if(t.FlagScms) AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Track_has_SCMS);

                AaruLogging.Debug(MODULE_NAME,
                                  "\t\t" + Localization.Track_resides_in_file_0_type_defined_as_1_starting_at_byte_2,
                                  t.TrackFile.DataFilter.Filename,
                                  t.TrackFile.FileType,
                                  t.TrackFile.Offset);

                AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Indexes);

                foreach(KeyValuePair<ushort, int> kvp in t.Indexes)
                {
                    AaruLogging.Debug(MODULE_NAME,
                                      "\t\t\t" + Localization.Index_0_starts_at_sector_1,
                                      kvp.Key,
                                      kvp.Value);
                }

                if(t.Isrc == null)
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.ISRC_is_not_set);
                else
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.ISRC_0, t.Isrc);

                if(t.Arranger == null)
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Arranger_is_not_set);
                else
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Arranger_0, t.Arranger);

                if(t.Composer == null)
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Composer_is_not_set);
                else
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Composer_0, t.Composer);

                if(t.Genre == null)
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Genre_is_not_set);
                else
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Genre_0, t.Genre);

                if(t.Performer == null)
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Performer_is_not_set);
                else
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Performer_0, t.Performer);

                if(t.Songwriter == null)
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Songwriter_is_not_set);
                else
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Songwriter_0, t.Songwriter);

                if(t.Title == null)
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Title_is_not_set);
                else
                    AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Title_0, t.Title);
            }

            foreach(CdrWinTrack track in _discImage.Tracks) _imageInfo.ImageSize += track.Bps * track.Sectors;

            var currentSector          = 0;
            var currentFileStartSector = 0;
            var currentFilePath        = "";
            firstTrackInSession = true;

            foreach(CdrWinTrack track in _discImage.Tracks)
            {
                if(track.TrackFile.DataFilter.BasePath != currentFilePath)
                {
                    if(_discImage.IsRedumpGigadisc && track.Session == 2 && firstTrackInSession)
                    {
                        currentSector = (int)gdRomSession2Offset - track.Pregap;
                        track.Indexes.Add(0, 0);
                        track.Indexes[1]    =  track.Pregap;
                        track.Sectors       += (ulong)track.Pregap;
                        firstTrackInSession =  false;
                    }

                    currentFileStartSector = currentSector;
                    currentFilePath        = track.TrackFile.DataFilter.BasePath;
                }

                SortedDictionary<ushort, int> newIndexes = new();

                foreach(KeyValuePair<ushort, int> index in track.Indexes)
                    newIndexes[index.Key] = index.Value + currentFileStartSector;

                track.Indexes = newIndexes;

                currentSector += (int)track.Sectors;
            }

            for(var s = 0; s < sessions.Length; s++)
            {
                if(!_discImage.Tracks[(int)sessions[s].StartTrack - 1]
                              .Indexes.TryGetValue(0, out int sessionTrackStart))
                    _discImage.Tracks[(int)sessions[s].StartTrack - 1].Indexes.TryGetValue(1, out sessionTrackStart);

                sessions[s].StartSector = (ulong)(sessionTrackStart > 0 ? sessionTrackStart : 0);

                if(!_discImage.Tracks[(int)sessions[s].EndTrack - 1].Indexes.TryGetValue(0, out sessionTrackStart))
                    _discImage.Tracks[(int)sessions[s].EndTrack - 1].Indexes.TryGetValue(1, out sessionTrackStart);

                sessions[s].EndSector =  (ulong)(sessionTrackStart > 0 ? sessionTrackStart : 0);
                sessions[s].EndSector += _discImage.Tracks[(int)sessions[s].EndTrack - 1].Sectors - 1;
            }

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

            _imageInfo.Sectors = _discImage.Sessions.MaxBy(static s => s.EndSector).EndSector + 1;

            AaruLogging.Debug(MODULE_NAME, Localization.Session_information);

            AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Disc_contains_0_sessions, _discImage.Sessions.Count);

            for(var i = 0; i < _discImage.Sessions.Count; i++)
            {
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Session_0_information, i + 1);

                AaruLogging.Debug(MODULE_NAME,
                                  "\t\t" + Localization.Starting_track_0,
                                  _discImage.Sessions[i].StartTrack);

                AaruLogging.Debug(MODULE_NAME,
                                  "\t\t" + Localization.Starting_sector_0,
                                  _discImage.Sessions[i].StartSector);

                AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Ending_track_0, _discImage.Sessions[i].EndTrack);

                AaruLogging.Debug(MODULE_NAME, "\t\t" + Localization.Ending_sector_0, _discImage.Sessions[i].EndSector);
            }

            AaruLogging.Debug(MODULE_NAME, Localization.Building_offset_map);

            Partitions = [];

            ulong partitionSequence = 0;

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

            for(var i = 0; i < _discImage.Tracks.Count; i++)
            {
                if(_discImage.Tracks[i].Sequence == 1 && i != 0)
                {
                    AaruLogging.Error(Localization.Unordered_tracks);

                    return ErrorNumber.InvalidArgument;
                }

                var partition = new Partition();

                if(!_discImage.Tracks[i].Indexes.TryGetValue(1, out _))
                {
                    AaruLogging.Error(string.Format(Localization.Track_0_lacks_index_01,
                                                    _discImage.Tracks[i].Sequence));

                    return ErrorNumber.InvalidArgument;
                }

                // Index 01
                partition.Description = string.Format(Localization.Track_0, _discImage.Tracks[i].Sequence);
                partition.Name        = _discImage.Tracks[i].Title;
                partition.Start       = (ulong)_discImage.Tracks[i].Indexes[1];
                partition.Size        = _discImage.Tracks[i].Sectors * _discImage.Tracks[i].Bps;
                partition.Length      = _discImage.Tracks[i].Sectors;
                partition.Sequence    = partitionSequence;
                partition.Offset      = partition.Start * 2352;
                partition.Type        = _discImage.Tracks[i].TrackType;

                partitionSequence++;

                if(_discImage.IsRedumpGigadisc && _discImage.Tracks[i].Sequence == 3)
                {
                    _offsetMap.Add(_discImage.Tracks[i].Sequence,
                                   gdRomSession2Offset - (ulong)_discImage.Tracks[i].Pregap);
                }
                else if(_discImage.Tracks[i].Indexes.TryGetValue(0, out int idx0))
                    _offsetMap.Add(_discImage.Tracks[i].Sequence, (ulong)idx0);
                else if(_discImage.Tracks[i].Sequence > 1)
                {
                    _offsetMap.Add(_discImage.Tracks[i].Sequence,
                                   (ulong)(_discImage.Tracks[i].Indexes[1] - _discImage.Tracks[i].Pregap));
                }
                else
                    _offsetMap.Add(_discImage.Tracks[i].Sequence, (ulong)_discImage.Tracks[i].Indexes[1]);

                Partitions.Add(partition);
            }

            // Print offset map
            AaruLogging.Debug(MODULE_NAME, Localization.printing_partition_map);

            foreach(Partition partition in Partitions)
            {
                AaruLogging.Debug(MODULE_NAME, Localization.Partition_sequence_0,    partition.Sequence);
                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Partition_name_0, partition.Name);

                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Partition_description_0, partition.Description);

                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Partition_type_0, partition.Type);

                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Partition_starting_sector_0, partition.Start);

                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Partition_sectors_0, partition.Length);

                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Partition_starting_offset_0, partition.Offset);

                AaruLogging.Debug(MODULE_NAME, "\t" + Localization.Partition_size_in_bytes_0, partition.Size);
            }

            if(_discImage.MediaType != MediaType.CDROMXA &&
               _discImage.MediaType != MediaType.CDDA    &&
               _discImage.MediaType != MediaType.CDI     &&
               _discImage.MediaType != MediaType.CDPLUS  &&
               _discImage.MediaType != MediaType.CDG     &&
               _discImage.MediaType != MediaType.CDEG    &&
               _discImage.MediaType != MediaType.CDMIDI  &&
               _discImage.MediaType != MediaType.GDROM)
                _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);

            if(_imageInfo.Application is null)
            {
                if(_discImage.IsTrurip)
                    _imageInfo.Application = "trurip";

                else if(_discImage.IsRedumpGigadisc)
                    _imageInfo.Application = "Redump.org";

                // Detect ISOBuster extensions
                else if(_discImage.OriginalMediaType != null                                                  ||
                        _discImage.Comment.Contains("isobuster", StringComparison.InvariantCultureIgnoreCase) ||
                        sessions.Length > 1)
                    _imageInfo.Application = "ISOBuster";
                else
                    _imageInfo.Application = "CDRWin";
            }

            _imageInfo.CreationTime         = imageFilter.CreationTime;
            _imageInfo.LastModificationTime = imageFilter.LastWriteTime;

            _imageInfo.Comments          = _discImage.Comment;
            _imageInfo.MediaSerialNumber = _discImage.Mcn;
            _imageInfo.MediaBarcode      = _discImage.Barcode;
            _imageInfo.MediaType         = _discImage.MediaType;

            _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.MetadataMediaType = MetadataMediaType.OpticalDisc;

            AaruLogging.Verbose(Localization.CDRWIN_image_describes_a_disc_of_type_0, _imageInfo.MediaType);

            if(!string.IsNullOrEmpty(_imageInfo.Comments))
                AaruLogging.Verbose(Localization.CDRWIN_comments_0, _imageInfo.Comments);

            _sectorBuilder = new SectorBuilder();

            var mediaTypeAsInt = (int)_discImage.MediaType;

            _isCd = mediaTypeAsInt is >= 10 and <= 39
                                   or 112
                                   or 113
                                   or >= 150 and <= 152
                                   or 154
                                   or 155
                                   or >= 171 and <= 179
                                   or >= 740 and <= 749;

            if(currentSession > 1 && leadouts.Count == 0 && !_discImage.IsRedumpGigadisc && _isCd)
            {
                AaruLogging.Error(Localization
                                     .This_image_is_missing_vital_multi_session_data_and_cannot_be_read_correctly);

                return ErrorNumber.InvalidArgument;
            }

            if(_discImage.Tracks.All(static t => t.Isrc == null))
                _imageInfo.ReadableSectorTags.Remove(SectorTagType.CdTrackIsrc);

            if(_isCd) return ErrorNumber.NoError;

            _imageInfo.ReadableSectorTags.Remove(SectorTagType.CdSectorSync);
            _imageInfo.ReadableSectorTags.Remove(SectorTagType.CdSectorHeader);
            _imageInfo.ReadableSectorTags.Remove(SectorTagType.CdSectorSubHeader);
            _imageInfo.ReadableSectorTags.Remove(SectorTagType.CdSectorEcc);
            _imageInfo.ReadableSectorTags.Remove(SectorTagType.CdSectorEccP);
            _imageInfo.ReadableSectorTags.Remove(SectorTagType.CdSectorEccQ);
            _imageInfo.ReadableSectorTags.Remove(SectorTagType.CdSectorEdc);
            _imageInfo.ReadableSectorTags.Remove(SectorTagType.CdTrackFlags);
            _imageInfo.ReadableSectorTags.Remove(SectorTagType.CdTrackIsrc);

            sessions = _discImage.Sessions.ToArray();

            foreach(CdrWinTrack track in _discImage.Tracks)
            {
                track.Indexes.Remove(0);
                track.Pregap = 0;

                for(var s = 0; s < sessions.Length; s++)
                {
                    if(sessions[s].Sequence <= 1 || track.Sequence != sessions[s].StartTrack) continue;

                    track.TrackFile.Offset  += 307200;
                    track.Sectors           -= 150;
                    sessions[s].StartSector =  (ulong)track.Indexes[1];
                }
            }

            _discImage.Sessions = sessions.ToList();

            return ErrorNumber.NoError;
        }
        catch(Exception ex)
        {
            AaruLogging.Error(Localization.Exception_trying_to_identify_image_file_0, imageFilter.Filename);
            AaruLogging.Exception(ex, Localization.Exception_trying_to_identify_image_file_0, imageFilter.Filename);

            return ErrorNumber.UnexpectedException;
        }
    }

    /// <inheritdoc />
    public ErrorNumber ReadMediaTag(MediaTagType tag, out byte[] buffer)
    {
        buffer = null;

        switch(tag)
        {
            case MediaTagType.CD_MCN:
            {
                if(_discImage.Mcn == null) return ErrorNumber.NoData;

                buffer = Encoding.ASCII.GetBytes(_discImage.Mcn);

                return ErrorNumber.NoError;
            }
            case MediaTagType.CD_TEXT:
            {
                // TODO: Check binary text file exists, open it, read it, send it to caller.
                return _discImage.CdTextFile != null ? ErrorNumber.NotImplemented : ErrorNumber.NoData;
            }
            default:
                return ErrorNumber.NotSupported;
        }
    }

    /// <inheritdoc />
    public ErrorNumber ReadSector(ulong sectorAddress, bool negative, out byte[] buffer, out SectorStatus sectorStatus)
    {
        sectorStatus = SectorStatus.Dumped;

        return ReadSectors(sectorAddress, negative, 1, out buffer, out _);
    }

    /// <inheritdoc />
    public ErrorNumber ReadSectorTag(ulong sectorAddress, bool negative, SectorTagType tag, out byte[] buffer) =>
        ReadSectorsTag(sectorAddress, negative, 1, tag, out buffer);

    /// <inheritdoc />
    public ErrorNumber ReadSector(ulong sectorAddress, uint track, out byte[] buffer, out SectorStatus sectorStatus)
    {
        sectorStatus = SectorStatus.Dumped;

        return ReadSectors(sectorAddress, 1, track, out buffer, out _);
    }

    /// <inheritdoc />
    public ErrorNumber ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag, out byte[] buffer) =>
        ReadSectorsTag(sectorAddress, 1, track, tag, out buffer);

    /// <inheritdoc />
    public ErrorNumber ReadSectors(ulong              sectorAddress, bool negative, uint length, out byte[] buffer,
                                   out SectorStatus[] sectorStatus)
    {
        buffer       = null;
        sectorStatus = null;

        if(negative) return ErrorNumber.NotSupported;

        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, out buffer, out _);

        return ErrorNumber.SectorNotFound;
    }

    /// <inheritdoc />
    public ErrorNumber ReadSectorsTag(ulong      sectorAddress, bool negative, uint length, SectorTagType tag,
                                      out byte[] buffer)
    {
        buffer = null;

        if(negative) return ErrorNumber.NotSupported;

        if(tag is SectorTagType.CdTrackFlags or SectorTagType.CdTrackIsrc)
            return ReadSectorsTag(sectorAddress, length, 0, tag, out buffer);

        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, out buffer);

        return ErrorNumber.SectorNotFound;
    }

    /// <inheritdoc />
    public ErrorNumber ReadSectors(ulong              sectorAddress, uint length, uint track, out byte[] buffer,
                                   out SectorStatus[] sectorStatus)
    {
        buffer       = null;
        sectorStatus = null;

        CdrWinTrack aaruTrack = _discImage.Tracks.FirstOrDefault(cdrwinTrack => cdrwinTrack.Sequence == track);

        if(aaruTrack is null) return ErrorNumber.SectorNotFound;

        if(length > aaruTrack.Sectors) return ErrorNumber.OutOfRange;

        sectorStatus = new SectorStatus[length];
        for(uint i = 0; i < length; i++) sectorStatus[i] = SectorStatus.Dumped;

        uint sectorOffset;
        uint sectorSize;
        uint sectorSkip;
        var  mode2 = false;

        switch(aaruTrack.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:
            {
                mode2        = true;
                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:
            case CDRWIN_TRACK_TYPE_CDI_RAW:
            {
                mode2        = true;
                sectorOffset = 0;
                sectorSize   = 2352;
                sectorSkip   = 0;

                break;
            }
            case CDRWIN_TRACK_TYPE_CDG:
            {
                sectorOffset = 0;
                sectorSize   = 2352;
                sectorSkip   = 96;

                break;
            }
            default:
                return ErrorNumber.NotSupported;
        }

        buffer = new byte[sectorSize * length];

        // If it's the lost pregap
        if(track == 1 && _lostPregap > 0)
        {
            if(sectorAddress < _lostPregap)
            {
                // If we need to mix lost with present data
                if(sectorAddress + length <= _lostPregap) return ErrorNumber.NoError;

                ulong pregapPos = _lostPregap - sectorAddress;

                ErrorNumber errno = ReadSectors(_lostPregap,
                                                (uint)(length - pregapPos),
                                                track,
                                                out byte[] presentData,
                                                out sectorStatus);

                if(errno != ErrorNumber.NoError) return errno;

                Array.Copy(presentData, 0, buffer, (long)(pregapPos * sectorSize), presentData.Length);

                return ErrorNumber.NoError;
            }

            sectorAddress -= _lostPregap;
        }

        if(_discImage.IsRedumpGigadisc                      &&
           aaruTrack.Session    == 2                        &&
           aaruTrack.Indexes[0] >= 45000 - aaruTrack.Pregap &&
           aaruTrack.Indexes[1] <= 45000)
        {
            if(sectorAddress < (ulong)(aaruTrack.Indexes[1] - aaruTrack.Indexes[0]))
            {
                if(sectorAddress + length + (ulong)aaruTrack.Indexes[0] <= (ulong)aaruTrack.Indexes[1])
                    return ErrorNumber.NoError;

                ulong pregapPos = (ulong)(aaruTrack.Indexes[1] - aaruTrack.Indexes[0]) - sectorAddress;

                ErrorNumber errno = ReadSectors((ulong)(aaruTrack.Indexes[1] - aaruTrack.Indexes[0]),
                                                (uint)(length                - pregapPos),
                                                track,
                                                out byte[] presentData,
                                                out sectorStatus);

                if(errno != ErrorNumber.NoError) return errno;

                Array.Copy(presentData, 0, buffer, (long)(pregapPos * sectorSize), presentData.Length);

                return ErrorNumber.NoError;
            }

            sectorAddress -= (ulong)(aaruTrack.Indexes[1] - aaruTrack.Indexes[0]);
        }

        _imageStream = aaruTrack.TrackFile.DataFilter.GetDataForkStream();
        var br = new BinaryReader(_imageStream);

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

        if(mode2)
        {
            var mode2Ms = new MemoryStream((int)(sectorSize * length));

            buffer = br.ReadBytes((int)(sectorSize * length));

            for(var i = 0; i < length; i++)
            {
                var sector = new byte[sectorSize];
                Array.Copy(buffer, sectorSize * i, sector, 0, sectorSize);
                sector = Sector.GetUserDataFromMode2(sector);
                mode2Ms.Write(sector, 0, sector.Length);
            }

            buffer = mode2Ms.ToArray();
        }
        else if(sectorOffset == 0 && sectorSkip == 0)
            buffer = br.ReadBytes((int)(sectorSize * length));
        else
        {
            for(var 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 ErrorNumber.NoError;
    }

    /// <inheritdoc />
    public ErrorNumber ReadSectorsTag(ulong      sectorAddress, uint length, uint track, SectorTagType tag,
                                      out byte[] buffer)
    {
        buffer = null;

        if(tag is SectorTagType.CdTrackFlags or SectorTagType.CdTrackIsrc) track = (uint)sectorAddress;

        CdrWinTrack aaruTrack = _discImage.Tracks.FirstOrDefault(cdrwinTrack => cdrwinTrack.Sequence == track);

        if(aaruTrack is null) return ErrorNumber.SectorNotFound;

        if(length > aaruTrack.Sectors) return ErrorNumber.OutOfRange;

        uint sectorOffset = 0;
        uint sectorSize   = 0;
        uint sectorSkip   = 0;

        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(aaruTrack.TrackType != CDRWIN_TRACK_TYPE_AUDIO && aaruTrack.TrackType != CDRWIN_TRACK_TYPE_CDG)
                    flags |= CdFlags.DataTrack;

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

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

                if(aaruTrack.Flag4Ch) flags |= CdFlags.FourChannel;

                buffer = [(byte)flags];

                return ErrorNumber.NoError;
            }
            case SectorTagType.CdTrackIsrc:
                if(aaruTrack.Isrc == null) return ErrorNumber.NoData;

                buffer = Encoding.UTF8.GetBytes(aaruTrack.Isrc);

                return ErrorNumber.NoError;
            case SectorTagType.CdTrackText:
                return ErrorNumber.NotImplemented;
            default:
                return ErrorNumber.NotSupported;
        }

        switch(aaruTrack.TrackType)
        {
            case CDRWIN_TRACK_TYPE_MODE1:
            case CDRWIN_TRACK_TYPE_MODE2_FORM1:
            case CDRWIN_TRACK_TYPE_MODE2_FORM2:
                if(tag != SectorTagType.CdSectorSubchannel                                   ||
                   !_imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSubchannel) ||
                   _discImage.Tracks.All(static t => t.TrackType != CDRWIN_TRACK_TYPE_CDG))
                    return ErrorNumber.NoData;

                buffer = new byte[length * 96];

                return ErrorNumber.NoError;

            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:
                        if(tag != SectorTagType.CdSectorSubchannel                                   ||
                           !_imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSubchannel) ||
                           _discImage.Tracks.All(static t => t.TrackType != CDRWIN_TRACK_TYPE_CDG))
                            return ErrorNumber.NotSupported;

                        buffer = new byte[length * 96];

                        return ErrorNumber.NoError;

                    case SectorTagType.CdSectorSubHeader:
                    {
                        sectorOffset = 0;
                        sectorSize   = 8;
                        sectorSkip   = 2328;

                        break;
                    }
                    case SectorTagType.CdSectorEdc:
                    {
                        sectorOffset = 2332;
                        sectorSize   = 4;
                        sectorSkip   = 0;

                        break;
                    }
                }

                break;
            }
            case CDRWIN_TRACK_TYPE_AUDIO:
                return ErrorNumber.NoData;
            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:
                        if(tag != SectorTagType.CdSectorSubchannel                                   ||
                           !_imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSubchannel) ||
                           _discImage.Tracks.All(static t => t.TrackType != CDRWIN_TRACK_TYPE_CDG))
                            return ErrorNumber.NotSupported;

                        buffer = new byte[length * 96];

                        return ErrorNumber.NoError;

                    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;
                    }
                }

                break;
            }
            case CDRWIN_TRACK_TYPE_MODE2_RAW: // Requires reading sector
            case CDRWIN_TRACK_TYPE_CDI_RAW:
                return ErrorNumber.NotImplemented;
            case CDRWIN_TRACK_TYPE_CDG:
            {
                if(tag != SectorTagType.CdSectorSubchannel) return ErrorNumber.NotSupported;

                sectorOffset = 2352;
                sectorSize   = 96;
                sectorSkip   = 0;

                break;
            }
            default:
                return ErrorNumber.NotSupported;
        }

        buffer = new byte[sectorSize * length];

        // If it's the lost pregap
        if(track == 1 && _lostPregap > 0)
        {
            if(sectorAddress < _lostPregap)
            {
                // If we need to mix lost with present data
                if(sectorAddress + length <= _lostPregap) return ErrorNumber.NoError;

                ulong pregapPos = _lostPregap - sectorAddress;

                ErrorNumber errno = ReadSectors(_lostPregap,
                                                (uint)(length - pregapPos),
                                                track,
                                                out byte[] presentData,
                                                out _);

                if(errno != ErrorNumber.NoError) return errno;

                Array.Copy(presentData, 0, buffer, (long)(pregapPos * sectorSize), presentData.Length);

                return ErrorNumber.NoError;
            }

            sectorAddress -= _lostPregap;
        }

        _imageStream = aaruTrack.TrackFile.DataFilter.GetDataForkStream();
        var br = new BinaryReader(_imageStream);

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

        if(sectorOffset == 0 && sectorSkip == 0)
            buffer = br.ReadBytes((int)(sectorSize * length));
        else
        {
            for(var 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 ErrorNumber.NoError;
    }

    /// <inheritdoc />
    public ErrorNumber ReadSectorLong(ulong            sectorAddress, bool negative, out byte[] buffer,
                                      out SectorStatus sectorStatus)
    {
        sectorStatus = SectorStatus.Dumped;

        return ReadSectorsLong(sectorAddress, negative, 1, out buffer, out _);
    }

    /// <inheritdoc />
    public ErrorNumber ReadSectorLong(ulong sectorAddress, uint track, out byte[] buffer, out SectorStatus sectorStatus)
    {
        sectorStatus = SectorStatus.Dumped;

        return ReadSectorsLong(sectorAddress, 1, track, out buffer, out _);
    }

    /// <inheritdoc />
    public ErrorNumber ReadSectorsLong(ulong              sectorAddress, bool negative, uint length, out byte[] buffer,
                                       out SectorStatus[] sectorStatus)
    {
        buffer       = null;
        sectorStatus = null;

        if(negative) return ErrorNumber.NotSupported;

        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, out buffer, out sectorStatus);

        return ErrorNumber.SectorNotFound;
    }

    /// <inheritdoc />
    public ErrorNumber ReadSectorsLong(ulong              sectorAddress, uint length, uint track, out byte[] buffer,
                                       out SectorStatus[] sectorStatus)
    {
        buffer       = null;
        sectorStatus = null;

        if(!_isCd) return ReadSectors(sectorAddress, length, track, out buffer, out sectorStatus);

        CdrWinTrack aaruTrack = _discImage.Tracks.FirstOrDefault(cdrwinTrack => cdrwinTrack.Sequence == track);

        if(aaruTrack is null) return ErrorNumber.SectorNotFound;

        if(length > aaruTrack.Sectors) return ErrorNumber.OutOfRange;

        sectorStatus = new SectorStatus[length];
        for(uint i = 0; i < length; i++) sectorStatus[i] = SectorStatus.Dumped;

        uint sectorOffset;
        uint sectorSize;
        uint sectorSkip;

        switch(aaruTrack.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   = 2352;
                sectorSkip   = 96;

                break;
            }
            default:
                return ErrorNumber.NotSupported;
        }

        buffer = new byte[sectorSize * length];

        // If it's the lost pregap
        if(track == 1 && _lostPregap > 0)
        {
            if(sectorAddress < _lostPregap)
            {
                // If we need to mix lost with present data
                if(sectorAddress + length <= _lostPregap) return ErrorNumber.NoError;

                ulong pregapPos = _lostPregap - sectorAddress;

                ErrorNumber errno = ReadSectors(_lostPregap,
                                                (uint)(length - pregapPos),
                                                track,
                                                out byte[] presentData,
                                                out sectorStatus);

                if(errno != ErrorNumber.NoError) return errno;

                Array.Copy(presentData, 0, buffer, (long)(pregapPos * sectorSize), presentData.Length);

                return ErrorNumber.NoError;
            }

            sectorAddress -= _lostPregap;
        }

        if(_discImage.IsRedumpGigadisc                      &&
           aaruTrack.Session    == 2                        &&
           aaruTrack.Indexes[0] >= 45000 - aaruTrack.Pregap &&
           aaruTrack.Indexes[1] <= 45000)
        {
            if(sectorAddress < (ulong)(aaruTrack.Indexes[1] - aaruTrack.Indexes[0]))
            {
                if(sectorAddress + length + (ulong)aaruTrack.Indexes[0] <= (ulong)aaruTrack.Indexes[1])
                    return ErrorNumber.NoError;

                ulong pregapPos = (ulong)(aaruTrack.Indexes[1] - aaruTrack.Indexes[0]) - sectorAddress;

                ErrorNumber errno = ReadSectorsLong((ulong)(aaruTrack.Indexes[1] - aaruTrack.Indexes[0]),
                                                    (uint)(length                - pregapPos),
                                                    track,
                                                    out byte[] presentData,
                                                    out sectorStatus);

                if(errno != ErrorNumber.NoError) return errno;

                Array.Copy(presentData, 0, buffer, (long)(pregapPos * sectorSize), presentData.Length);

                return ErrorNumber.NoError;
            }

            sectorAddress -= (ulong)(aaruTrack.Indexes[1] - aaruTrack.Indexes[0]);
        }

        _imageStream = aaruTrack.TrackFile.DataFilter.GetDataForkStream();
        var br = new BinaryReader(_imageStream);

        br.BaseStream.Seek((long)aaruTrack.TrackFile.Offset + (long)(sectorAddress * (sectorSize + sectorSkip)),
                           SeekOrigin.Begin);

        if(sectorSkip == 0)
            buffer = br.ReadBytes((int)(sectorSize * length));
        else
        {
            for(var 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);
            }
        }

        switch(aaruTrack.TrackType)
        {
            case CDRWIN_TRACK_TYPE_MODE1:
            {
                var fullSector = new byte[2352];
                var fullBuffer = new byte[2352 * length];

                for(uint i = 0; i < length; i++)
                {
                    Array.Copy(buffer, i * 2048, fullSector, 16, 2048);
                    _sectorBuilder.ReconstructPrefix(ref fullSector, TrackType.CdMode1, (long)(sectorAddress + i));
                    _sectorBuilder.ReconstructEcc(ref fullSector, TrackType.CdMode1);
                    Array.Copy(fullSector, 0, fullBuffer, i * 2352, 2352);
                }

                buffer = fullBuffer;

                break;
            }
            case CDRWIN_TRACK_TYPE_MODE2_FORM1:
            {
                var fullSector = new byte[2352];
                var fullBuffer = new byte[2352 * length];

                for(uint i = 0; i < length; i++)
                {
                    Array.Copy(buffer, i * 2048, fullSector, 24, 2048);

                    _sectorBuilder.ReconstructPrefix(ref fullSector, TrackType.CdMode2Form1, (long)(sectorAddress + i));

                    _sectorBuilder.ReconstructEcc(ref fullSector, TrackType.CdMode2Form1);
                    Array.Copy(fullSector, 0, fullBuffer, i * 2352, 2352);
                }

                buffer = fullBuffer;

                break;
            }
            case CDRWIN_TRACK_TYPE_MODE2_FORM2:
            {
                var fullSector = new byte[2352];
                var fullBuffer = new byte[2352 * length];

                for(uint i = 0; i < length; i++)
                {
                    Array.Copy(buffer, i * 2324, fullSector, 24, 2324);

                    _sectorBuilder.ReconstructPrefix(ref fullSector, TrackType.CdMode2Form2, (long)(sectorAddress + i));

                    _sectorBuilder.ReconstructEcc(ref fullSector, TrackType.CdMode2Form2);
                    Array.Copy(fullSector, 0, fullBuffer, i * 2352, 2352);
                }

                buffer = fullBuffer;

                break;
            }
            case CDRWIN_TRACK_TYPE_MODE2_FORMLESS:
            case CDRWIN_TRACK_TYPE_CDI:
            {
                var fullSector = new byte[2352];
                var fullBuffer = new byte[2352 * length];

                for(uint i = 0; i < length; i++)
                {
                    _sectorBuilder.ReconstructPrefix(ref fullSector,
                                                     TrackType.CdMode2Formless,
                                                     (long)(sectorAddress + i));

                    Array.Copy(buffer,     i * 2336, fullSector, 16,       2336);
                    Array.Copy(fullSector, 0,        fullBuffer, i * 2352, 2352);
                }

                buffer = fullBuffer;

                break;
            }
        }

        return ErrorNumber.NoError;
    }

    /// <inheritdoc />
    public List<Track> GetSessionTracks(Session session) =>
        _discImage.Sessions.Contains(session) ? GetSessionTracks(session.Sequence) : null;

    /// <inheritdoc />
    public List<Track> GetSessionTracks(ushort session) =>
        Tracks.Where(t => t.Session == session).OrderBy(static t => t.Sequence).ToList();

#endregion
}