// /***************************************************************************
// Aaru Data Preservation Suite
// ----------------------------------------------------------------------------
//
// Filename       : Info.cs
// Author(s)      : Natalia Portillo <claunia@claunia.com>
//
// Component      : CP/M filesystem plugin.
//
// --[ Description ] ----------------------------------------------------------
//
//     Identifies the CP/M filesystem and shows information.
//
// --[ 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.IO;
using System.Linq;
using System.Text;
using Aaru.CommonTypes;
using Aaru.CommonTypes.AaruMetadata;
using Aaru.CommonTypes.Enums;
using Aaru.CommonTypes.Interfaces;
using Aaru.Helpers;
using Aaru.Logging;
using Sentry;
using Partition = Aaru.CommonTypes.Partition;

namespace Aaru.Filesystems;

public sealed partial class CPM
{
#region IReadOnlyFilesystem Members

    /// <inheritdoc />
    public bool Identify(IMediaImage imagePlugin, Partition partition)
    {
        // This will only continue on devices with a chance to have ever been used by CP/M while failing on all others
        // It's ugly, but will stop a lot of false positives
        switch(imagePlugin.Info.MediaType)
        {
            case MediaType.Unknown:
            case MediaType.Apple32SS:
            case MediaType.Apple32DS:
            case MediaType.Apple33SS:
            case MediaType.Apple33DS:
            case MediaType.DOS_525_SS_DD_8:
            case MediaType.DOS_525_SS_DD_9:
            case MediaType.DOS_525_DS_DD_8:
            case MediaType.DOS_525_DS_DD_9:
            case MediaType.DOS_525_HD:
            case MediaType.DOS_35_SS_DD_8:
            case MediaType.DOS_35_SS_DD_9:
            case MediaType.DOS_35_DS_DD_8:
            case MediaType.DOS_35_DS_DD_9:
            case MediaType.DOS_35_HD:
            case MediaType.DOS_35_ED:
            case MediaType.IBM23FD:
            case MediaType.IBM33FD_128:
            case MediaType.IBM33FD_256:
            case MediaType.IBM33FD_512:
            case MediaType.IBM43FD_128:
            case MediaType.IBM43FD_256:
            case MediaType.IBM53FD_256:
            case MediaType.IBM53FD_512:
            case MediaType.IBM53FD_1024:
            case MediaType.RX01:
            case MediaType.RX02:
            case MediaType.RX03:
            case MediaType.RX50:
            case MediaType.ACORN_525_SS_SD_40:
            case MediaType.ACORN_525_SS_SD_80:
            case MediaType.ACORN_525_SS_DD_40:
            case MediaType.ACORN_525_SS_DD_80:
            case MediaType.ACORN_525_DS_DD:
            case MediaType.ATARI_525_SD:
            case MediaType.ATARI_525_ED:
            case MediaType.ATARI_525_DD:
            case MediaType.CBM_35_DD:
            case MediaType.CBM_1540:
            case MediaType.CBM_1540_Ext:
            case MediaType.CBM_1571:
            case MediaType.NEC_8_SD:
            case MediaType.NEC_8_DD:
            case MediaType.NEC_525_SS:
            case MediaType.NEC_525_DS:
            case MediaType.NEC_525_HD:
            case MediaType.NEC_35_HD_8:
            case MediaType.NEC_35_HD_15:
            case MediaType.SHARP_525_9:
            case MediaType.SHARP_35_9:
            case MediaType.ECMA_99_8:
            case MediaType.ECMA_99_15:
            case MediaType.ECMA_99_26:
            case MediaType.ECMA_54:
            case MediaType.ECMA_59:
            case MediaType.ECMA_66:
            case MediaType.ECMA_69_8:
            case MediaType.ECMA_69_15:
            case MediaType.ECMA_69_26:
            case MediaType.ECMA_70:
            case MediaType.ECMA_78:
            case MediaType.ECMA_78_2:
            case MediaType.Apricot_35:
            case MediaType.CompactFloppy:
            case MediaType.DemiDiskette:
            case MediaType.QuickDisk:
            case MediaType.Wafer:
            case MediaType.ZXMicrodrive:
            case MediaType.AppleProfile:
            case MediaType.AppleWidget:
            case MediaType.AppleHD20:
            case MediaType.RA60:
            case MediaType.RA80:
            case MediaType.RA81:
            case MediaType.RC25:
            case MediaType.RD31:
            case MediaType.RD32:
            case MediaType.RD51:
            case MediaType.RD52:
            case MediaType.RD53:
            case MediaType.RD54:
            case MediaType.RK06:
            case MediaType.RK06_18:
            case MediaType.RK07:
            case MediaType.RK07_18:
            case MediaType.RM02:
            case MediaType.RM03:
            case MediaType.RM05:
            case MediaType.RP02:
            case MediaType.RP02_18:
            case MediaType.RP03:
            case MediaType.RP03_18:
            case MediaType.RP04:
            case MediaType.RP04_18:
            case MediaType.RP05:
            case MediaType.RP05_18:
            case MediaType.RP06:
            case MediaType.RP06_18:
            case MediaType.GENERIC_HDD:
            case MediaType.FlashDrive:
            case MediaType.MetaFloppy_Mod_I:
            case MediaType.MetaFloppy_Mod_II:
                break;
            default:
                return false;
        }

        // This will try to identify a CP/M filesystem
        // However as it contains no identification marks whatsoever it's more something of trial-and-error
        // As anything can happen, better try{}catch{} than sorry ;)
        try
        {
            byte[] sector;
            ulong  sectorSize;
            ulong  firstDirectorySector;
            byte[] directory = null;
            _workingDefinition = null;
            _label             = null;

            // Try Amstrad superblock
            ErrorNumber errno;

            if(!_cpmFound)
            {
                // Read CHS = {0,0,1}
                errno = imagePlugin.ReadSector(0 + partition.Start, false, out sector, out _);

                if(errno == ErrorNumber.NoError)
                {
                    var amsSbOffset = 0;

                    var  sig1 = BitConverter.ToUInt32(sector, 0x2B);
                    uint sig2 = BitConverter.ToUInt32(sector, 0x33) & 0x00FFFFFF;
                    var  sig3 = BitConverter.ToUInt32(sector, 0x7C);

                    // PCW16 extended boot record
                    if(sig1 == 0x4D2F5043 && sig2 == 0x004B5344 && sig3 == sig1) amsSbOffset = 0x80;

                    // Read the superblock
                    AmstradSuperBlock amsSb =
                        Marshal.ByteArrayToStructureLittleEndian<AmstradSuperBlock>(sector, amsSbOffset, 16);

                    // Check that format byte and sidedness indicate the same number of sizes
                    if(amsSb.format == 0 && (amsSb.sidedness & 0x02) == 0 ||
                       amsSb.format == 2 && (amsSb.sidedness & 0x02) == 1 ||
                       amsSb.format == 2 && (amsSb.sidedness & 0x02) == 2)
                    {
                        // Calculate device limits
                        var sides       = (ulong)(amsSb.format == 0 ? 1 : 2);
                        var sectorCount = (ulong)(amsSb.tps * amsSb.spt * (byte)sides);
                        sectorSize = (ulong)(128 << amsSb.psh);

                        // Compare device limits from superblock to real limits
                        if(sectorSize == imagePlugin.Info.SectorSize && sectorCount == imagePlugin.Info.Sectors)
                        {
                            _cpmFound            = true;
                            firstDirectorySector = (ulong)(amsSb.off * amsSb.spt);

                            // Build a DiscParameterBlock
                            _dpb = new DiscParameterBlock
                            {
                                al0 = sectorCount == 1440 ? (byte)0xF0 : (byte)0xC0,
                                spt = amsSb.spt,
                                bsh = amsSb.bsh
                            };

                            for(var i = 0; i < _dpb.bsh; i++) _dpb.blm += (byte)Math.Pow(2, i);

                            if(sectorCount >= 1440)
                            {
                                _dpb.cks = 0x40;
                                _dpb.drm = 0xFF;
                            }
                            else
                            {
                                _dpb.cks = 0x10;
                                _dpb.drm = 0x3F;
                            }

                            _dpb.dsm = 0; // I don't care
                            _dpb.exm = sectorCount == 2880 ? (byte)1 : (byte)0;
                            _dpb.off = amsSb.off;
                            _dpb.psh = amsSb.psh;

                            for(var i = 0; i < _dpb.psh; i++) _dpb.phm += (byte)Math.Pow(2, i);

                            _dpb.spt = (ushort)(amsSb.spt * (sectorSize             / 128));
                            var directoryLength = (uint)(((ulong)_dpb.drm + 1) * 32 / sectorSize);

                            imagePlugin.ReadSectors(firstDirectorySector + partition.Start,
                                                    false,
                                                    directoryLength,
                                                    out directory,
                                                    out _);

                            // Build a CP/M disk definition
                            _workingDefinition = new CpmDefinition
                            {
                                al0             = _dpb.al0,
                                al1             = _dpb.al1,
                                bitrate         = "LOW",
                                blm             = _dpb.blm,
                                bsh             = _dpb.bsh,
                                bytesPerSector  = 512,
                                cylinders       = amsSb.tps,
                                drm             = _dpb.drm,
                                dsm             = _dpb.dsm,
                                encoding        = "MFM",
                                evenOdd         = false,
                                exm             = _dpb.exm,
                                label           = null,
                                comment         = "Amstrad PCW superblock",
                                ofs             = _dpb.off,
                                sectorsPerTrack = amsSb.spt,
                                side1 = new Side
                                {
                                    sideId    = 0,
                                    sectorIds = new int[amsSb.spt]
                                }
                            };

                            for(var si = 0; si < amsSb.spt; si++) _workingDefinition.side1.sectorIds[si] = si + 1;

                            if(amsSb.format == 2)
                            {
                                _workingDefinition.order = (amsSb.sidedness & 0x02) switch
                                                           {
                                                               1 => "SIDES",
                                                               2 => "CYLINDERS",
                                                               _ => null
                                                           };

                                _workingDefinition.side2 = new Side
                                {
                                    sideId    = 1,
                                    sectorIds = new int[amsSb.spt]
                                };

                                for(var si = 0; si < amsSb.spt; si++) _workingDefinition.side2.sectorIds[si] = si + 1;
                            }
                            else
                                _workingDefinition.order = null;

                            _workingDefinition.skew = 2;
                            _workingDefinition.sofs = 0;

                            AaruLogging.Debug(MODULE_NAME, Localization.Found_Amstrad_superblock);
                        }
                    }
                }
            }

            // Try CP/M-86 superblock for hard disks
            if(!_cpmFound)
            {
                // Read CHS = {0,0,4}
                errno = imagePlugin.ReadSector(3 + partition.Start, false, out sector, out _);

                if(errno == ErrorNumber.NoError)
                {
                    ushort sum = 0;

                    // Sum of all 16-bit words that make this sector must be 0
                    for(var i = 0; i < sector.Length; i += 2) sum += BitConverter.ToUInt16(sector, i);

                    // It may happen that there is a corrupted superblock
                    // Better to ignore corrupted than to false positive the rest
                    if(sum == 0)
                    {
                        // Read the superblock
                        HardDiskSuperBlock hddSb = Marshal.ByteArrayToStructureLittleEndian<HardDiskSuperBlock>(sector);

                        // Calculate volume size
                        sectorSize = (ulong)(hddSb.recordsPerSector * 128);
                        var sectorsInPartition = (ulong)(hddSb.cylinders * hddSb.heads * hddSb.sectorsPerTrack);

                        var startingSector =
                            (ulong)((hddSb.firstCylinder * hddSb.heads + hddSb.heads) * hddSb.sectorsPerTrack);

                        // If volume size corresponds with working partition (this variant will be inside MBR partitioning)
                        if(sectorSize                           == imagePlugin.Info.SectorSize &&
                           startingSector                       == partition.Start             &&
                           sectorsInPartition + partition.Start <= partition.End)
                        {
                            _cpmFound            = true;
                            firstDirectorySector = (ulong)(hddSb.off * hddSb.sectorsPerTrack);

                            // Build a DiscParameterBlock
                            _dpb = new DiscParameterBlock
                            {
                                al0 = (byte)hddSb.al0,
                                al1 = (byte)hddSb.al1,
                                blm = hddSb.blm,
                                bsh = hddSb.bsh,
                                cks = hddSb.cks,
                                drm = hddSb.drm,
                                dsm = hddSb.dsm,
                                exm = hddSb.exm,
                                off = hddSb.off,

                                // Needed?
                                phm = 0,

                                // Needed?
                                psh = 0,
                                spt = hddSb.spt
                            };

                            var directoryLength = (uint)(((ulong)_dpb.drm + 1) * 32 / sectorSize);

                            imagePlugin.ReadSectors(firstDirectorySector + partition.Start,
                                                    false,
                                                    directoryLength,
                                                    out directory,
                                                    out _);

                            AaruLogging.Debug(MODULE_NAME, Localization.Found_CPM_86_hard_disk_superblock);

                            // Build a CP/M disk definition
                            _workingDefinition = new CpmDefinition
                            {
                                al0             = _dpb.al0,
                                al1             = _dpb.al1,
                                bitrate         = "HIGH",
                                blm             = _dpb.blm,
                                bsh             = _dpb.bsh,
                                bytesPerSector  = 512,
                                cylinders       = hddSb.cylinders,
                                drm             = _dpb.drm,
                                dsm             = _dpb.dsm,
                                encoding        = "MFM",
                                evenOdd         = false,
                                exm             = _dpb.exm,
                                label           = null,
                                comment         = "CP/M-86 hard disk superblock",
                                ofs             = _dpb.off,
                                sectorsPerTrack = hddSb.sectorsPerTrack,
                                side1 = new Side
                                {
                                    sideId    = 0,
                                    sectorIds = new int[hddSb.sectorsPerTrack]
                                },
                                order = "SIDES",
                                side2 = new Side
                                {
                                    sideId    = 1,
                                    sectorIds = new int[hddSb.sectorsPerTrack]
                                },
                                skew = 0,
                                sofs = 0
                            };

                            for(var si = 0; si < hddSb.sectorsPerTrack; si++)
                                _workingDefinition.side1.sectorIds[si] = si + 1;

                            for(var si = 0; si < hddSb.spt; si++) _workingDefinition.side2.sectorIds[si] = si + 1;
                        }
                    }
                }
            }

            // Try CP/M-86 format ID for floppies
            if(!_cpmFound)
            {
                // Read CHS = {0,0,1}
                errno = imagePlugin.ReadSector(0 + partition.Start, false, out sector, out _);

                if(errno == ErrorNumber.NoError)
                {
                    byte formatByte;

                    // Check for alternate location of format ID
                    if(sector.Last() == 0x00 || sector.Last() == 0xFF)
                    {
                        if(sector[0x40] == 0x94 || sector[0x40] == 0x26)
                            formatByte = sector[0x40];
                        else
                            formatByte = sector.Last();
                    }
                    else
                        formatByte = sector.Last();

                    uint firstDirectorySector86 = 0;

                    // Check format ID
                    // If it is one of the known IDs, check disk size corresponds to the one we expect
                    // If so, build a DiscParameterBlock and a CP/M disk definition
                    // Will not work on over-formatted disks (40 cylinder volume on an 80 cylinder disk,
                    // something that happens a lot in IBM PC 5.25" disks)
                    switch((FormatByte)formatByte)
                    {
                        case FormatByte.k160:
                            if(imagePlugin.Info is { SectorSize: 512, Sectors: 320 })
                            {
                                _cpmFound              = true;
                                firstDirectorySector86 = 8;

                                _dpb = new DiscParameterBlock
                                {
                                    al0 = 0xC0,
                                    al1 = 0,
                                    blm = 7,
                                    bsh = 3,
                                    cks = 0x10,
                                    drm = 0x3F,
                                    dsm = 0x9B,
                                    exm = 0,
                                    off = 1,
                                    phm = 3,
                                    psh = 2,
                                    spt = 8 * 4
                                };

                                _workingDefinition = new CpmDefinition
                                {
                                    al0             = _dpb.al0,
                                    al1             = _dpb.al1,
                                    bitrate         = "LOW",
                                    blm             = _dpb.blm,
                                    bsh             = _dpb.bsh,
                                    bytesPerSector  = 512,
                                    cylinders       = 40,
                                    drm             = _dpb.drm,
                                    dsm             = _dpb.dsm,
                                    encoding        = "MFM",
                                    evenOdd         = false,
                                    exm             = _dpb.exm,
                                    label           = null,
                                    comment         = "CP/M-86 floppy identifier",
                                    ofs             = _dpb.off,
                                    sectorsPerTrack = 8,
                                    side1 = new Side
                                    {
                                        sideId    = 0,
                                        sectorIds = new int[8]
                                    },
                                    skew = 0,
                                    sofs = 0
                                };

                                for(var si = 0; si < 8; si++) _workingDefinition.side1.sectorIds[si] = si + 1;
                            }

                            break;
                        case FormatByte.k320:
                            if(imagePlugin.Info is { SectorSize: 512, Sectors: 640 })
                            {
                                _cpmFound              = true;
                                firstDirectorySector86 = 16;

                                _dpb = new DiscParameterBlock
                                {
                                    al0 = 0x80,
                                    al1 = 0,
                                    blm = 0x0F,
                                    bsh = 4,
                                    cks = 0x10,
                                    drm = 0x3F,
                                    dsm = 0x9D,
                                    exm = 1,
                                    off = 2,
                                    phm = 3,
                                    psh = 2,
                                    spt = 8 * 4
                                };

                                _workingDefinition = new CpmDefinition
                                {
                                    al0             = _dpb.al0,
                                    al1             = _dpb.al1,
                                    bitrate         = "LOW",
                                    blm             = _dpb.blm,
                                    bsh             = _dpb.bsh,
                                    bytesPerSector  = 512,
                                    cylinders       = 40,
                                    drm             = _dpb.drm,
                                    dsm             = _dpb.dsm,
                                    encoding        = "MFM",
                                    evenOdd         = false,
                                    exm             = _dpb.exm,
                                    label           = null,
                                    comment         = "CP/M-86 floppy identifier",
                                    ofs             = _dpb.off,
                                    sectorsPerTrack = 8,
                                    side1 = new Side
                                    {
                                        sideId    = 0,
                                        sectorIds = new int[8]
                                    },
                                    order = "SIDES",
                                    side2 = new Side
                                    {
                                        sideId    = 1,
                                        sectorIds = new int[8]
                                    },
                                    skew = 0,
                                    sofs = 0
                                };

                                for(var si = 0; si < 8; si++) _workingDefinition.side1.sectorIds[si] = si + 1;

                                for(var si = 0; si < 8; si++) _workingDefinition.side2.sectorIds[si] = si + 1;
                            }

                            break;
                        case FormatByte.k360:
                        case FormatByte.k360Alt:
                        case FormatByte.k360Alt2:
                            if(imagePlugin.Info is { SectorSize: 512, Sectors: 720 })
                            {
                                _cpmFound              = true;
                                firstDirectorySector86 = 36;

                                _dpb = new DiscParameterBlock
                                {
                                    al0 = 0x80,
                                    al1 = 0,
                                    blm = 0x0F,
                                    bsh = 4,
                                    cks = 0x10,
                                    drm = 0x3F,
                                    dsm = 0, // Unknown. Needed?
                                    exm = 1,
                                    off = 4,
                                    phm = 3,
                                    psh = 2,
                                    spt = 9 * 4
                                };

                                _workingDefinition = new CpmDefinition
                                {
                                    al0             = _dpb.al0,
                                    al1             = _dpb.al1,
                                    bitrate         = "LOW",
                                    blm             = _dpb.blm,
                                    bsh             = _dpb.bsh,
                                    bytesPerSector  = 512,
                                    cylinders       = 40,
                                    drm             = _dpb.drm,
                                    dsm             = _dpb.dsm,
                                    encoding        = "MFM",
                                    evenOdd         = false,
                                    exm             = _dpb.exm,
                                    label           = null,
                                    comment         = "CP/M-86 floppy identifier",
                                    ofs             = _dpb.off,
                                    sectorsPerTrack = 9,
                                    side1 = new Side
                                    {
                                        sideId    = 0,
                                        sectorIds = new int[9]
                                    },
                                    order = "SIDES",
                                    side2 = new Side
                                    {
                                        sideId    = 1,
                                        sectorIds = new int[9]
                                    },
                                    skew = 0,
                                    sofs = 0
                                };

                                for(var si = 0; si < 9; si++) _workingDefinition.side1.sectorIds[si] = si + 1;

                                for(var si = 0; si < 9; si++) _workingDefinition.side2.sectorIds[si] = si + 1;
                            }

                            break;
                        case FormatByte.k720:
                        case FormatByte.k720Alt:
                            if(imagePlugin.Info is { SectorSize: 512, Sectors: 1440 })
                            {
                                _cpmFound              = true;
                                firstDirectorySector86 = 36;

                                _dpb = new DiscParameterBlock
                                {
                                    al0 = 0xF0,
                                    al1 = 0,
                                    blm = 0x0F,
                                    bsh = 4,
                                    cks = 0x40,
                                    drm = 0xFF,
                                    dsm = 0x15E,
                                    exm = 0,
                                    off = 4,
                                    phm = 3,
                                    psh = 2,
                                    spt = 9 * 4
                                };

                                _workingDefinition = new CpmDefinition
                                {
                                    al0             = _dpb.al0,
                                    al1             = _dpb.al1,
                                    bitrate         = "LOW",
                                    blm             = _dpb.blm,
                                    bsh             = _dpb.bsh,
                                    bytesPerSector  = 512,
                                    cylinders       = 80,
                                    drm             = _dpb.drm,
                                    dsm             = _dpb.dsm,
                                    encoding        = "MFM",
                                    evenOdd         = false,
                                    exm             = _dpb.exm,
                                    label           = null,
                                    comment         = "CP/M-86 floppy identifier",
                                    ofs             = _dpb.off,
                                    sectorsPerTrack = 9,
                                    side1 = new Side
                                    {
                                        sideId    = 0,
                                        sectorIds = new int[9]
                                    },
                                    order = "SIDES",
                                    side2 = new Side
                                    {
                                        sideId    = 1,
                                        sectorIds = new int[9]
                                    },
                                    skew = 0,
                                    sofs = 0
                                };

                                for(var si = 0; si < 9; si++) _workingDefinition.side1.sectorIds[si] = si + 1;

                                for(var si = 0; si < 9; si++) _workingDefinition.side2.sectorIds[si] = si + 1;
                            }

                            break;
                        case FormatByte.f720:
                            if(imagePlugin.Info is { SectorSize: 512, Sectors: 1440 })
                            {
                                _cpmFound              = true;
                                firstDirectorySector86 = 18;

                                _dpb = new DiscParameterBlock
                                {
                                    al0 = 0xF0,
                                    al1 = 0,
                                    blm = 0x0F,
                                    bsh = 4,
                                    cks = 0x40,
                                    drm = 0xFF,
                                    dsm = 0x162,
                                    exm = 0,
                                    off = 2,
                                    phm = 3,
                                    psh = 2,
                                    spt = 9 * 4
                                };

                                _workingDefinition = new CpmDefinition
                                {
                                    al0             = _dpb.al0,
                                    al1             = _dpb.al1,
                                    bitrate         = "LOW",
                                    blm             = _dpb.blm,
                                    bsh             = _dpb.bsh,
                                    bytesPerSector  = 512,
                                    cylinders       = 80,
                                    drm             = _dpb.drm,
                                    dsm             = _dpb.dsm,
                                    encoding        = "MFM",
                                    evenOdd         = false,
                                    exm             = _dpb.exm,
                                    label           = null,
                                    comment         = "CP/M-86 floppy identifier",
                                    ofs             = _dpb.off,
                                    sectorsPerTrack = 9,
                                    side1 = new Side
                                    {
                                        sideId    = 0,
                                        sectorIds = new int[9]
                                    },
                                    order = "CYLINDERS",
                                    side2 = new Side
                                    {
                                        sideId    = 1,
                                        sectorIds = new int[9]
                                    },
                                    skew = 0,
                                    sofs = 0
                                };

                                for(var si = 0; si < 9; si++) _workingDefinition.side1.sectorIds[si] = si + 1;

                                for(var si = 0; si < 9; si++) _workingDefinition.side2.sectorIds[si] = si + 1;
                            }

                            break;
                        case FormatByte.f1200:
                            if(imagePlugin.Info is { SectorSize: 512, Sectors: 2400 })
                            {
                                _cpmFound              = true;
                                firstDirectorySector86 = 30;

                                _dpb = new DiscParameterBlock
                                {
                                    al0 = 0xC0,
                                    al1 = 0,
                                    blm = 0x1F,
                                    bsh = 5,
                                    cks = 0x40,
                                    drm = 0xFF,
                                    dsm = 0x127,
                                    exm = 1,
                                    off = 2,
                                    phm = 3,
                                    psh = 2,
                                    spt = 15 * 4
                                };

                                _workingDefinition = new CpmDefinition
                                {
                                    al0             = _dpb.al0,
                                    al1             = _dpb.al1,
                                    bitrate         = "HIGH",
                                    blm             = _dpb.blm,
                                    bsh             = _dpb.bsh,
                                    bytesPerSector  = 512,
                                    cylinders       = 80,
                                    drm             = _dpb.drm,
                                    dsm             = _dpb.dsm,
                                    encoding        = "MFM",
                                    evenOdd         = false,
                                    exm             = _dpb.exm,
                                    label           = null,
                                    comment         = "CP/M-86 floppy identifier",
                                    ofs             = _dpb.off,
                                    sectorsPerTrack = 15,
                                    side1 = new Side
                                    {
                                        sideId    = 0,
                                        sectorIds = new int[15]
                                    },
                                    order = "CYLINDERS",
                                    side2 = new Side
                                    {
                                        sideId    = 1,
                                        sectorIds = new int[15]
                                    },
                                    skew = 0,
                                    sofs = 0
                                };

                                for(var si = 0; si < 15; si++) _workingDefinition.side1.sectorIds[si] = si + 1;

                                for(var si = 0; si < 15; si++) _workingDefinition.side2.sectorIds[si] = si + 1;
                            }

                            break;
                        case FormatByte.f1440:
                            if(imagePlugin.Info is { SectorSize: 512, Sectors: 2880 })
                            {
                                _cpmFound              = true;
                                firstDirectorySector86 = 36;

                                _dpb = new DiscParameterBlock
                                {
                                    al0 = 0xC0,
                                    al1 = 0,
                                    blm = 0x1F,
                                    bsh = 5,
                                    cks = 0x40,
                                    drm = 0xFF,
                                    dsm = 0x162,
                                    exm = 1,
                                    off = 2,
                                    phm = 3,
                                    psh = 2,
                                    spt = 18 * 4
                                };

                                _workingDefinition = new CpmDefinition
                                {
                                    al0             = _dpb.al0,
                                    al1             = _dpb.al1,
                                    bitrate         = "LOW",
                                    blm             = _dpb.blm,
                                    bsh             = _dpb.bsh,
                                    bytesPerSector  = 512,
                                    cylinders       = 80,
                                    drm             = _dpb.drm,
                                    dsm             = _dpb.dsm,
                                    encoding        = "MFM",
                                    evenOdd         = false,
                                    exm             = _dpb.exm,
                                    label           = null,
                                    comment         = "CP/M-86 floppy identifier",
                                    ofs             = _dpb.off,
                                    sectorsPerTrack = 18,
                                    side1 = new Side
                                    {
                                        sideId    = 0,
                                        sectorIds = new int[18]
                                    },
                                    order = "CYLINDERS",
                                    side2 = new Side
                                    {
                                        sideId    = 1,
                                        sectorIds = new int[18]
                                    },
                                    skew = 0,
                                    sofs = 0
                                };

                                for(var si = 0; si < 18; si++) _workingDefinition.side1.sectorIds[si] = si + 1;

                                for(var si = 0; si < 18; si++) _workingDefinition.side2.sectorIds[si] = si + 1;
                            }

                            break;
                    }

                    if(_cpmFound)
                    {
                        var directoryLength = (uint)(((ulong)_dpb.drm + 1) * 32 / imagePlugin.Info.SectorSize);

                        imagePlugin.ReadSectors(firstDirectorySector86 + partition.Start,
                                                false,
                                                directoryLength,
                                                out directory,
                                                out _);

                        AaruLogging.Debug(MODULE_NAME, Localization.Found_CPM_86_floppy_identifier);
                    }
                }
            }

            // One of the few CP/M filesystem marks has been found, try for correcteness checking the whole directory
            if(_cpmFound)
            {
                if(CheckDir(directory))
                {
                    AaruLogging.Debug(MODULE_NAME, Localization.First_directory_block_seems_correct);

                    return true;
                }

                _cpmFound = false;
            }

            // Try all definitions
            if(!_cpmFound)
            {
                // Load all definitions
                AaruLogging.Debug(MODULE_NAME, Localization.Trying_to_load_definitions);

                if(LoadDefinitions() && _definitions?.definitions is { Count: > 0 })
                {
                    AaruLogging.Debug(MODULE_NAME, Localization.Trying_all_known_definitions);

                    foreach(CpmDefinition def in from def in _definitions.definitions
                                                 let sectors = (ulong)(def.cylinders * def.sides * def.sectorsPerTrack)
                                                 where sectors            == imagePlugin.Info.Sectors &&
                                                       def.bytesPerSector == imagePlugin.Info.SectorSize
                                                 select def)
                    {
                        // Definition seems to describe current disk, at least, same number of volume sectors and bytes per sector
                        AaruLogging.Debug(MODULE_NAME, Localization.Trying_definition_0, def.comment);
                        ulong offset;

                        if(def.sofs != 0)
                            offset = (ulong)def.sofs;
                        else
                            offset = (ulong)(def.ofs * def.sectorsPerTrack);

                        int dirLen = (def.drm + 1) * 32 / def.bytesPerSector;

                        if(def.sides == 1)
                        {
                            _sectorMask = new int[def.side1.sectorIds.Length];

                            for(var m = 0; m < _sectorMask.Length; m++)
                                _sectorMask[m] = def.side1.sectorIds[m] - def.side1.sectorIds[0];
                        }
                        else
                        {
                            // Head changes after every track
                            if(string.Equals(def.order, "SIDES", StringComparison.InvariantCultureIgnoreCase))
                            {
                                _sectorMask = new int[def.side1.sectorIds.Length + def.side2.sectorIds.Length];

                                for(var m = 0; m < def.side1.sectorIds.Length; m++)
                                    _sectorMask[m] = def.side1.sectorIds[m] - def.side1.sectorIds[0];

                                // Skip first track (first side)
                                for(var m = 0; m < def.side2.sectorIds.Length; m++)
                                {
                                    _sectorMask[m + def.side1.sectorIds.Length] =
                                        def.side2.sectorIds[m] - def.side2.sectorIds[0] + def.side1.sectorIds.Length;
                                }
                            }

                            // Head changes after whole side
                            else if(string.Equals(def.order, "CYLINDERS", StringComparison.InvariantCultureIgnoreCase))
                            {
                                for(var m = 0; m < def.side1.sectorIds.Length; m++)
                                    _sectorMask[m] = def.side1.sectorIds[m] - def.side1.sectorIds[0];

                                // Skip first track (first side) and first track (second side)
                                for(var m = 0; m < def.side1.sectorIds.Length; m++)
                                {
                                    _sectorMask[m + def.side1.sectorIds.Length] =
                                        def.side1.sectorIds[m] -
                                        def.side1.sectorIds[0]     +
                                        def.side1.sectorIds.Length +
                                        def.side2.sectorIds.Length;
                                }
                            }

                            // TODO: Implement COLUMBIA ordering
                            else if(string.Equals(def.order, "COLUMBIA", StringComparison.InvariantCultureIgnoreCase))
                            {
                                AaruLogging.Debug(MODULE_NAME,
                                                  Localization
                                                     .Dont_know_how_to_handle_COLUMBIA_ordering_not_proceeding_with_this_definition);

                                continue;
                            }

                            // TODO: Implement EAGLE ordering
                            else if(string.Equals(def.order, "EAGLE", StringComparison.InvariantCultureIgnoreCase))
                            {
                                AaruLogging.Debug(MODULE_NAME,
                                                  Localization
                                                     .Don_know_how_to_handle_EAGLE_ordering_not_proceeding_with_this_definition);

                                continue;
                            }
                            else
                            {
                                AaruLogging.Debug(MODULE_NAME,
                                                  Localization.Unknown_order_type_0_not_proceeding_with_this_definition,
                                                  def.order);

                                continue;
                            }
                        }

                        // Read the directory marked by this definition
                        var ms = new MemoryStream();

                        for(var p = 0; p < dirLen; p++)
                        {
                            errno = imagePlugin.ReadSector((ulong)((int)offset                                 +
                                                                   (int)partition.Start                        +
                                                                   p / _sectorMask.Length * _sectorMask.Length +
                                                                   _sectorMask[p % _sectorMask.Length]),
                                                           false,
                                                           out byte[] dirSector,
                                                           out _);

                            if(errno != ErrorNumber.NoError) break;

                            ms.Write(dirSector, 0, dirSector.Length);
                        }

                        directory = ms.ToArray();

                        if(def.evenOdd)
                        {
                            AaruLogging.Debug(MODULE_NAME,
                                              Localization
                                                 .Definition_contains_EVEN_ODD_field_with_unknown_meaning_detection_may_be_wrong);
                        }

                        // Complement of the directory bytes if needed
                        if(def.complement)
                        {
                            for(var b = 0; b < directory.Length; b++) directory[b] = (byte)(~directory[b] & 0xFF);
                        }

                        // Check the directory
                        if(CheckDir(directory))
                        {
                            AaruLogging.Debug(MODULE_NAME,
                                              Localization.Definition_0_has_a_correct_directory,
                                              def.comment);

                            // Build a Disc Parameter Block
                            _workingDefinition = def;

                            _dpb = new DiscParameterBlock
                            {
                                al0 = (byte)def.al0,
                                al1 = (byte)def.al1,
                                blm = (byte)def.blm,
                                bsh = (byte)def.bsh,

                                // Needed?
                                cks = 0,
                                drm = (ushort)def.drm,
                                dsm = (ushort)def.dsm,
                                exm = (byte)def.exm,
                                off = (ushort)def.ofs,
                                spt = (ushort)(def.sectorsPerTrack * def.bytesPerSector / 128)
                            };

                            switch(def.bytesPerSector)
                            {
                                case 128:
                                    _dpb.psh = 0;
                                    _dpb.phm = 0;

                                    break;
                                case 256:
                                    _dpb.psh = 1;
                                    _dpb.phm = 1;

                                    break;
                                case 512:
                                    _dpb.psh = 2;
                                    _dpb.phm = 3;

                                    break;
                                case 1024:
                                    _dpb.psh = 3;
                                    _dpb.phm = 7;

                                    break;
                                case 2048:
                                    _dpb.psh = 4;
                                    _dpb.phm = 15;

                                    break;
                                case 4096:
                                    _dpb.psh = 5;
                                    _dpb.phm = 31;

                                    break;
                                case 8192:
                                    _dpb.psh = 6;
                                    _dpb.phm = 63;

                                    break;
                                case 16384:
                                    _dpb.psh = 7;
                                    _dpb.phm = 127;

                                    break;
                                case 32768:
                                    _dpb.psh = 8;
                                    _dpb.phm = 255;

                                    break;
                            }

                            _cpmFound          = true;
                            _workingDefinition = def;

                            return true;
                        }

                        _label             = null;
                        _labelCreationDate = null;
                        _labelUpdateDate   = null;
                    }
                }
            }

            // Clear class variables
            _cpmFound             = false;
            _workingDefinition    = null;
            _dpb                  = null;
            _label                = null;
            _standardTimestamps   = false;
            _thirdPartyTimestamps = false;

            return false;
        }
        catch(Exception ex)
        {
            SentrySdk.CaptureException(ex);

            //throw ex;
            return false;
        }
    }

    /// <inheritdoc />
    public void GetInformation(IMediaImage imagePlugin, Partition partition, Encoding encoding, out string information,
                               out FileSystem metadata)
    {
        information = "";
        metadata    = new FileSystem();

        // As the identification is so complex, just call Identify() and relay on its findings
        if(!Identify(imagePlugin, partition) || !_cpmFound || _workingDefinition == null || _dpb == null) return;

        var sb = new StringBuilder();
        sb.AppendLine(Localization.CPM_filesystem);

        if(!string.IsNullOrEmpty(_workingDefinition.comment))
            sb.AppendFormat(Localization.Identified_as_0, _workingDefinition.comment).AppendLine();

        sb.AppendFormat(Localization.Volume_block_is_0_bytes, 128 << _dpb.bsh).AppendLine();

        if(_dpb.dsm > 0)
        {
            sb.AppendFormat(Localization.Volume_contains_0_blocks_1_bytes, _dpb.dsm, _dpb.dsm * (128 << _dpb.bsh))
              .AppendLine();
        }

        sb.AppendFormat(Localization.Volume_contains_0_directory_entries, _dpb.drm + 1).AppendLine();

        if(_workingDefinition.sofs > 0)
            sb.AppendFormat(Localization.Volume_reserves_0_sectors_for_system, _workingDefinition.sofs).AppendLine();
        else
        {
            sb.AppendFormat(Localization.Volume_reserves_1_tracks_0_sectors_for_system,
                            _workingDefinition.ofs * _workingDefinition.sectorsPerTrack,
                            _workingDefinition.ofs)
              .AppendLine();
        }

        if(_workingDefinition.side1.sectorIds.Length >= 2)
        {
            int interleaveSide1 = _workingDefinition.side1.sectorIds[1] - _workingDefinition.side1.sectorIds[0];

            if(interleaveSide1 > 1)
                sb.AppendFormat(Localization.Side_zero_uses_0_one_software_interleaving, interleaveSide1).AppendLine();
        }

        if(_workingDefinition.sides == 2)
        {
            if(_workingDefinition.side2.sectorIds.Length >= 2)
            {
                int interleaveSide2 = _workingDefinition.side2.sectorIds[1] - _workingDefinition.side2.sectorIds[0];

                if(interleaveSide2 > 1)
                {
                    sb.AppendFormat(Localization.Side_one_uses_0_one_software_interleaving, interleaveSide2)
                      .AppendLine();
                }
            }

            switch(_workingDefinition.order)
            {
                case "SIDES":
                    sb.AppendLine(Localization.Head_changes_after_each_whole_track);

                    break;
                case "CYLINDERS":
                    sb.AppendLine(Localization.Head_changes_after_whole_side);

                    break;
                default:
                    sb.AppendFormat(Localization.Unknown_how_0_side_ordering_works, _workingDefinition.order)
                      .AppendLine();

                    break;
            }
        }

        if(_workingDefinition.skew > 0)
            sb.AppendFormat(Localization.Device_uses_0_one_hardware_interleaving, _workingDefinition.skew).AppendLine();

        if(_workingDefinition.sofs > 0)
        {
            sb.AppendLine($"BSH {_dpb.bsh} BLM {_dpb.blm} EXM {_dpb.exm} DSM {_dpb.dsm} DRM {_dpb.drm} AL0 {_dpb.al0
                :X2}H AL1 {_dpb.al1:X2}H SOFS {_workingDefinition.sofs}");
        }
        else
        {
            sb.AppendLine($"BSH {_dpb.bsh} BLM {_dpb.blm} EXM {_dpb.exm} DSM {_dpb.dsm} DRM {_dpb.drm} AL0 {_dpb.al0
                :X2}H AL1 {_dpb.al1:X2}H OFS {_workingDefinition.ofs}");
        }

        if(_label != null) sb.AppendFormat(Localization.Volume_label_0, _label).AppendLine();

        if(_standardTimestamps) sb.AppendLine(Localization.Volume_uses_standard_CPM_timestamps);

        if(_thirdPartyTimestamps) sb.AppendLine(Localization.Volume_uses_third_party_timestamps);

        if(_labelCreationDate != null)
        {
            sb.AppendFormat(Localization.Volume_created_on_0, DateHandlers.CpmToDateTime(_labelCreationDate))
              .AppendLine();
        }

        if(_labelUpdateDate != null)
        {
            sb.AppendFormat(Localization.Volume_updated_on_0, DateHandlers.CpmToDateTime(_labelUpdateDate))
              .AppendLine();
        }

        metadata             =  new FileSystem();
        metadata.Bootable    |= _workingDefinition.sofs > 0 || _workingDefinition.ofs > 0;
        metadata.ClusterSize =  (uint)(128 << _dpb.bsh);

        if(_dpb.dsm > 0)
            metadata.Clusters = _dpb.dsm;
        else
            metadata.Clusters = partition.End - partition.Start;

        if(_labelCreationDate != null) metadata.CreationDate = DateHandlers.CpmToDateTime(_labelCreationDate);

        if(_labelUpdateDate != null) metadata.ModificationDate = DateHandlers.CpmToDateTime(_labelUpdateDate);

        metadata.Type       = FS_TYPE;
        metadata.VolumeName = _label;

        information = sb.ToString();
    }

#endregion
}