// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename       : Super.cs
// Author(s)      : Natalia Portillo <claunia@claunia.com>
//
// Component      : ISO9660 filesystem plugin.
//
// --[ Description ] ----------------------------------------------------------
//
//     Mounts ISO9660, CD-i and High Sierra Format filesystems.
//
// --[ 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-2019 Natalia Portillo
// In the loving memory of Facunda "Tata" Suárez Domínguez, R.I.P. 2019/07/24
// ****************************************************************************/

using System;
using System.Collections.Generic;
using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Interfaces;
using DiscImageChef.CommonTypes.Structs;
using DiscImageChef.Console;
using DiscImageChef.Decoders.Sega;
using DiscImageChef.Helpers;
using Schemas;

namespace DiscImageChef.Filesystems.ISO9660
{
    public partial class ISO9660
    {
        public Errno Mount(IMediaImage                imagePlugin, Partition partition, Encoding encoding,
                           Dictionary<string, string> options,     string    @namespace)
        {
            Encoding = encoding ?? Encoding.GetEncoding(1252);
            byte[] vdMagic = new byte[5]; // Volume Descriptor magic "CD001"
            byte[] hsMagic = new byte[5]; // Volume Descriptor magic "CDROM"

            if(options == null) options = GetDefaultOptions();
            if(options.TryGetValue("debug", out string debugString)) bool.TryParse(debugString, out debug);
            if(options.TryGetValue("use_path_table", out string usePathTableString))
                bool.TryParse(usePathTableString, out usePathTable);
            if(options.TryGetValue("use_trans_tbl", out string useTransTblString))
                bool.TryParse(useTransTblString, out useTransTbl);
            if(options.TryGetValue("use_evd", out string useEvdString)) bool.TryParse(useEvdString, out useEvd);

            // Default namespace
            if(@namespace is null) @namespace = "joliet";

            switch(@namespace.ToLowerInvariant())
            {
                case "normal":
                    this.@namespace = Namespace.Normal;
                    break;
                case "vms":
                    this.@namespace = Namespace.Vms;
                    break;
                case "joliet":
                    this.@namespace = Namespace.Joliet;
                    break;
                case "rrip":
                    this.@namespace = Namespace.Rrip;
                    break;
                case "romeo":
                    this.@namespace = Namespace.Romeo;
                    break;
                default: return Errno.InvalidArgument;
            }

            PrimaryVolumeDescriptor?           pvd      = null;
            PrimaryVolumeDescriptor?           jolietvd = null;
            BootRecord?                        bvd      = null;
            HighSierraPrimaryVolumeDescriptor? hsvd     = null;
            FileStructureVolumeDescriptor?     fsvd     = null;

            // ISO9660 is designed for 2048 bytes/sector devices
            if(imagePlugin.Info.SectorSize < 2048) return Errno.InvalidArgument;

            // ISO9660 Primary Volume Descriptor starts at sector 16, so that's minimal size.
            if(partition.End < 16) return Errno.InvalidArgument;

            ulong counter = 0;

            byte[] vdSector = imagePlugin.ReadSector(16 + counter + partition.Start);
            int    xaOff    = vdSector.Length == 2336 ? 8 : 0;
            Array.Copy(vdSector, 0x009 + xaOff, hsMagic, 0, 5);
            highSierra = Encoding.GetString(hsMagic) == HIGH_SIERRA_MAGIC;
            int hsOff            = 0;
            if(highSierra) hsOff = 8;
            cdi = false;
            List<ulong> bvdSectors = new List<ulong>();
            List<ulong> pvdSectors = new List<ulong>();
            List<ulong> svdSectors = new List<ulong>();
            List<ulong> evdSectors = new List<ulong>();
            List<ulong> vpdSectors = new List<ulong>();

            while(true)
            {
                DicConsole.DebugWriteLine("ISO9660 plugin", "Processing VD loop no. {0}", counter);
                // Seek to Volume Descriptor
                DicConsole.DebugWriteLine("ISO9660 plugin", "Reading sector {0}", 16 + counter + partition.Start);
                byte[] vdSectorTmp = imagePlugin.ReadSector(16 + counter + partition.Start);
                vdSector = new byte[vdSectorTmp.Length - xaOff];
                Array.Copy(vdSectorTmp, xaOff, vdSector, 0, vdSector.Length);

                byte vdType = vdSector[0 + hsOff]; // Volume Descriptor Type, should be 1 or 2.
                DicConsole.DebugWriteLine("ISO9660 plugin", "VDType = {0}", vdType);

                if(vdType == 255) // Supposedly we are in the PVD.
                {
                    if(counter == 0) return Errno.InvalidArgument;

                    break;
                }

                Array.Copy(vdSector, 0x001, vdMagic, 0, 5);
                Array.Copy(vdSector, 0x009, hsMagic, 0, 5);

                if(Encoding.GetString(vdMagic) != ISO_MAGIC && Encoding.GetString(hsMagic) != HIGH_SIERRA_MAGIC &&
                   Encoding.GetString(vdMagic) != CDI_MAGIC
                ) // Recognized, it is an ISO9660, now check for rest of data.
                {
                    if(counter == 0) return Errno.InvalidArgument;

                    break;
                }

                cdi |= Encoding.GetString(vdMagic) == CDI_MAGIC;

                switch(vdType)
                {
                    case 0:
                    {
                        if(debug) bvdSectors.Add(16 + counter + partition.Start);

                        break;
                    }

                    case 1:
                    {
                        if(highSierra)
                            hsvd = Marshal
                               .ByteArrayToStructureLittleEndian<HighSierraPrimaryVolumeDescriptor>(vdSector);
                        else if(cdi)
                            fsvd = Marshal.ByteArrayToStructureBigEndian<FileStructureVolumeDescriptor>(vdSector);
                        else pvd = Marshal.ByteArrayToStructureLittleEndian<PrimaryVolumeDescriptor>(vdSector);

                        if(debug) pvdSectors.Add(16 + counter + partition.Start);

                        break;
                    }

                    case 2:
                    {
                        PrimaryVolumeDescriptor svd =
                            Marshal.ByteArrayToStructureLittleEndian<PrimaryVolumeDescriptor>(vdSector);

                        // TODO: Other escape sequences
                        // Check if this is Joliet
                        if(svd.version == 1)
                        {
                            if(svd.escape_sequences[0] == '%' && svd.escape_sequences[1] == '/')
                                if(svd.escape_sequences[2] == '@' || svd.escape_sequences[2] == 'C' ||
                                   svd.escape_sequences[2] == 'E') jolietvd = svd;
                                else
                                    DicConsole.WriteLine("ISO9660 plugin",
                                                         "Found unknown supplementary volume descriptor");
                            if(debug) svdSectors.Add(16 + counter + partition.Start);
                        }
                        else
                        {
                            if(debug) evdSectors.Add(16 + counter + partition.Start);

                            if(useEvd)
                            {
                                // Basically until escape sequences are implemented, let the user chose the encoding.
                                // This is the same as user chosing Romeo namespace, but using the EVD instead of the PVD
                                this.@namespace = Namespace.Romeo;
                                pvd             = svd;
                            }
                        }

                        break;
                    }

                    case 3:
                    {
                        if(debug) vpdSectors.Add(16 + counter + partition.Start);

                        break;
                    }
                }

                counter++;
            }

            DecodedVolumeDescriptor decodedVd;
            DecodedVolumeDescriptor decodedJolietVd = new DecodedVolumeDescriptor();

            XmlFsType = new FileSystemType();

            if(pvd == null && hsvd == null && fsvd == null)
            {
                DicConsole.ErrorWriteLine("ERROR: Could not find primary volume descriptor");
                return Errno.InvalidArgument;
            }

            if(highSierra) decodedVd = DecodeVolumeDescriptor(hsvd.Value);
            else if(cdi) decodedVd   = DecodeVolumeDescriptor(fsvd.Value);
            else decodedVd           = DecodeVolumeDescriptor(pvd.Value);

            if(jolietvd != null) decodedJolietVd = DecodeJolietDescriptor(jolietvd.Value);

            if(this.@namespace != Namespace.Romeo) Encoding = Encoding.ASCII;

            string fsFormat;
            byte[] pathTableData;
            uint   pathTableSizeInSectors;

            uint pathTableMsbLocation;
            uint pathTableLsbLocation = 0; // Initialize to 0 as ignored in CD-i

            image = imagePlugin;

            if(highSierra)
            {
                pathTableSizeInSectors = hsvd.Value.path_table_size / 2048;
                if(hsvd.Value.path_table_size                       % 2048 > 0) pathTableSizeInSectors++;

                pathTableData = ReadSectors(Swapping.Swap(hsvd.Value.mandatory_path_table_msb), pathTableSizeInSectors);

                fsFormat = "High Sierra Format";

                pathTableMsbLocation = hsvd.Value.mandatory_path_table_msb;
                pathTableLsbLocation = hsvd.Value.mandatory_path_table_lsb;
            }
            else if(cdi)
            {
                pathTableSizeInSectors = fsvd.Value.path_table_size / 2048;
                if(fsvd.Value.path_table_size                       % 2048 > 0) pathTableSizeInSectors++;

                pathTableData = ReadSectors(fsvd.Value.path_table_addr, pathTableSizeInSectors);

                fsFormat = "CD-i";

                pathTableMsbLocation = fsvd.Value.path_table_addr;

                // TODO: Until escape sequences are implemented this is the default CD-i encoding.
                Encoding = Encoding.GetEncoding("iso8859-1");
            }
            else
            {
                pathTableSizeInSectors = pvd.Value.path_table_size / 2048;
                if(pvd.Value.path_table_size                       % 2048 > 0) pathTableSizeInSectors++;

                pathTableData = ReadSectors(Swapping.Swap(pvd.Value.type_m_path_table), pathTableSizeInSectors);

                fsFormat = "ISO9660";

                pathTableMsbLocation = pvd.Value.type_m_path_table;
                pathTableLsbLocation = pvd.Value.type_l_path_table;
            }

            pathTable = highSierra ? DecodeHighSierraPathTable(pathTableData) : DecodePathTable(pathTableData);

            // High Sierra and CD-i do not support Joliet or RRIP
            if((highSierra || cdi) && this.@namespace != Namespace.Normal && this.@namespace != Namespace.Vms)
                this.@namespace = Namespace.Normal;

            if(jolietvd is null && this.@namespace == Namespace.Joliet) this.@namespace = Namespace.Normal;

            uint rootLocation;
            uint rootSize;
            byte rootXattrLength = 0;

            if(!cdi)
            {
                rootLocation = highSierra
                                   ? hsvd.Value.root_directory_record.extent
                                   : pvd.Value.root_directory_record.extent;

                rootXattrLength = highSierra
                                      ? hsvd.Value.root_directory_record.xattr_len
                                      : pvd.Value.root_directory_record.xattr_len;

                if(highSierra)
                {
                    rootSize = hsvd.Value.root_directory_record.size / hsvd.Value.logical_block_size;
                    if(hsvd.Value.root_directory_record.size         % hsvd.Value.logical_block_size > 0) rootSize++;
                }
                else
                {
                    rootSize = pvd.Value.root_directory_record.size / pvd.Value.logical_block_size;
                    if(pvd.Value.root_directory_record.size         % pvd.Value.logical_block_size > 0) rootSize++;
                }
            }
            else
            {
                rootLocation = pathTable[0].Extent;

                byte[] firstRootSector = ReadSectors(rootLocation, 1);
                CdiDirectoryRecord rootEntry =
                    Marshal.ByteArrayToStructureBigEndian<CdiDirectoryRecord>(firstRootSector);
                rootSize = rootEntry.size / fsvd.Value.logical_block_size;
                if(rootEntry.size         % fsvd.Value.logical_block_size > 0) rootSize++;

                usePathTable = usePathTable || pathTable.Length == 1;
                useTransTbl  = false;
            }

            // In case the path table is incomplete
            if(usePathTable && pathTableData.Length == 1) usePathTable = false;

            if(rootLocation + rootSize >= imagePlugin.Info.Sectors) return Errno.InvalidArgument;

            byte[] rootDir = ReadSectors(rootLocation, rootSize);

            byte[]           ipbinSector = ReadSectors(partition.Start, 1);
            CD.IPBin?        segaCd      = CD.DecodeIPBin(ipbinSector);
            Saturn.IPBin?    saturn      = Saturn.DecodeIPBin(ipbinSector);
            Dreamcast.IPBin? dreamcast   = Dreamcast.DecodeIPBin(ipbinSector);

            if(this.@namespace == Namespace.Joliet || this.@namespace == Namespace.Rrip)
            {
                usePathTable = false;
                useTransTbl  = false;
            }

            // Cannot traverse path table if we substitute the names for the ones in TRANS.TBL
            if(useTransTbl) usePathTable = false;

            if(this.@namespace != Namespace.Joliet)
                rootDirectoryCache = cdi
                                         ? DecodeCdiDirectory(rootLocation, rootSize, rootXattrLength)
                                         : highSierra
                                             ? DecodeHighSierraDirectory(rootLocation, rootSize, rootXattrLength)
                                             : DecodeIsoDirectory(rootLocation, rootSize, rootXattrLength);

            XmlFsType.Type = fsFormat;

            if(debug)
            {
                rootDirectoryCache.Add("$",
                                       new DecodedDirectoryEntry
                                       {
                                           Extents =
                                               new List<(uint extent, uint size)>
                                               {
                                                   (rootLocation, (uint)rootDir.Length)
                                               },
                                           Filename  = "$",
                                           Size      = (uint)rootDir.Length,
                                           Timestamp = decodedVd.CreationTime
                                       });

                if(!cdi)
                    rootDirectoryCache.Add("$PATH_TABLE.LSB",
                                           new DecodedDirectoryEntry
                                           {
                                               Extents = new List<(uint extent, uint size)>
                                               {
                                                   (pathTableLsbLocation, (uint)pathTableData.Length)
                                               },
                                               Filename  = "$PATH_TABLE.LSB",
                                               Size      = (uint)pathTableData.Length,
                                               Timestamp = decodedVd.CreationTime
                                           });

                rootDirectoryCache.Add("$PATH_TABLE.MSB",
                                       new DecodedDirectoryEntry
                                       {
                                           Extents =
                                               new List<(uint extent, uint size)>
                                               {
                                                   (pathTableMsbLocation, (uint)pathTableData.Length)
                                               },
                                           Filename  = "$PATH_TABLE.MSB",
                                           Size      = (uint)pathTableData.Length,
                                           Timestamp = decodedVd.CreationTime
                                       });

                for(int i = 0; i < bvdSectors.Count; i++)
                    rootDirectoryCache.Add(i == 0 ? "$BOOT" : $"$BOOT_{i}",
                                           new DecodedDirectoryEntry
                                           {
                                               Extents   = new List<(uint extent, uint size)> {((uint)i, 2048)},
                                               Filename  = i == 0 ? "$BOOT" : $"$BOOT_{i}",
                                               Size      = 2048,
                                               Timestamp = decodedVd.CreationTime
                                           });

                for(int i = 0; i < pvdSectors.Count; i++)
                    rootDirectoryCache.Add(i == 0 ? "$PVD" : $"$PVD{i}",
                                           new DecodedDirectoryEntry
                                           {
                                               Extents   = new List<(uint extent, uint size)> {((uint)i, 2048)},
                                               Filename  = i == 0 ? "$PVD" : $"PVD_{i}",
                                               Size      = 2048,
                                               Timestamp = decodedVd.CreationTime
                                           });

                for(int i = 0; i < svdSectors.Count; i++)
                    rootDirectoryCache.Add(i == 0 ? "$SVD" : $"$SVD_{i}",
                                           new DecodedDirectoryEntry
                                           {
                                               Extents   = new List<(uint extent, uint size)> {((uint)i, 2048)},
                                               Filename  = i == 0 ? "$SVD" : $"$SVD_{i}",
                                               Size      = 2048,
                                               Timestamp = decodedVd.CreationTime
                                           });

                for(int i = 0; i < evdSectors.Count; i++)
                    rootDirectoryCache.Add(i == 0 ? "$EVD" : $"$EVD_{i}",
                                           new DecodedDirectoryEntry
                                           {
                                               Extents   = new List<(uint extent, uint size)> {((uint)i, 2048)},
                                               Filename  = i == 0 ? "$EVD" : $"$EVD_{i}",
                                               Size      = 2048,
                                               Timestamp = decodedVd.CreationTime
                                           });

                for(int i = 0; i < vpdSectors.Count; i++)
                    rootDirectoryCache.Add(i == 0 ? "$VPD" : $"$VPD_{i}",
                                           new DecodedDirectoryEntry
                                           {
                                               Extents   = new List<(uint extent, uint size)> {((uint)i, 2048)},
                                               Filename  = i == 0 ? "$VPD" : $"$VPD_{i}",
                                               Size      = 2048,
                                               Timestamp = decodedVd.CreationTime
                                           });

                if(segaCd != null)
                    rootDirectoryCache.Add("$IP.BIN",
                                           new DecodedDirectoryEntry
                                           {
                                               Extents = new List<(uint extent, uint size)>
                                               {
                                                   ((uint)partition.Start, (uint)Marshal.SizeOf<CD.IPBin>())
                                               },
                                               Filename  = "$IP.BIN",
                                               Size      = (uint)Marshal.SizeOf<CD.IPBin>(),
                                               Timestamp = decodedVd.CreationTime
                                           });

                if(saturn != null)
                    rootDirectoryCache.Add("$IP.BIN",
                                           new DecodedDirectoryEntry
                                           {
                                               Extents = new List<(uint extent, uint size)>
                                               {
                                                   ((uint)partition.Start, (uint)Marshal.SizeOf<Saturn.IPBin>())
                                               },
                                               Filename  = "$IP.BIN",
                                               Size      = (uint)Marshal.SizeOf<Saturn.IPBin>(),
                                               Timestamp = decodedVd.CreationTime
                                           });

                if(dreamcast != null)
                    rootDirectoryCache.Add("$IP.BIN",
                                           new DecodedDirectoryEntry
                                           {
                                               Extents = new List<(uint extent, uint size)>
                                               {
                                                   ((uint)partition.Start,
                                                    (uint)Marshal.SizeOf<Dreamcast.IPBin>())
                                               },
                                               Filename  = "$IP.BIN",
                                               Size      = (uint)Marshal.SizeOf<Dreamcast.IPBin>(),
                                               Timestamp = decodedVd.CreationTime
                                           });
            }

            if(jolietvd != null && (this.@namespace == Namespace.Joliet || this.@namespace == Namespace.Rrip))
            {
                rootLocation    = jolietvd.Value.root_directory_record.extent;
                rootXattrLength = jolietvd.Value.root_directory_record.xattr_len;

                rootSize = jolietvd.Value.root_directory_record.size / jolietvd.Value.logical_block_size;
                if(pvd.Value.root_directory_record.size % jolietvd.Value.logical_block_size > 0)
                    rootSize++;

                if(rootLocation + rootSize >= imagePlugin.Info.Sectors) return Errno.InvalidArgument;

                joliet = true;

                rootDirectoryCache = DecodeIsoDirectory(rootLocation, rootSize, rootXattrLength);

                XmlFsType.VolumeName = decodedJolietVd.VolumeIdentifier;

                if(string.IsNullOrEmpty(decodedJolietVd.SystemIdentifier) ||
                   decodedVd.SystemIdentifier.Length > decodedJolietVd.SystemIdentifier.Length)
                    XmlFsType.SystemIdentifier = decodedVd.SystemIdentifier;
                else
                    XmlFsType.SystemIdentifier = string.IsNullOrEmpty(decodedJolietVd.SystemIdentifier)
                                                     ? null
                                                     : decodedJolietVd.SystemIdentifier;

                if(string.IsNullOrEmpty(decodedJolietVd.VolumeSetIdentifier) || decodedVd.VolumeSetIdentifier.Length >
                   decodedJolietVd.VolumeSetIdentifier.Length)
                    XmlFsType.VolumeSetIdentifier = decodedVd.VolumeSetIdentifier;
                else
                    XmlFsType.VolumeSetIdentifier = string.IsNullOrEmpty(decodedJolietVd.VolumeSetIdentifier)
                                                        ? null
                                                        : decodedJolietVd.VolumeSetIdentifier;

                if(string.IsNullOrEmpty(decodedJolietVd.PublisherIdentifier) || decodedVd.PublisherIdentifier.Length >
                   decodedJolietVd.PublisherIdentifier.Length)
                    XmlFsType.PublisherIdentifier = decodedVd.PublisherIdentifier;
                else
                    XmlFsType.PublisherIdentifier = string.IsNullOrEmpty(decodedJolietVd.PublisherIdentifier)
                                                        ? null
                                                        : decodedJolietVd.PublisherIdentifier;

                if(string.IsNullOrEmpty(decodedJolietVd.DataPreparerIdentifier) ||
                   decodedVd.DataPreparerIdentifier.Length > decodedJolietVd.DataPreparerIdentifier.Length)
                    XmlFsType.DataPreparerIdentifier = decodedVd.DataPreparerIdentifier;
                else
                    XmlFsType.DataPreparerIdentifier = string.IsNullOrEmpty(decodedJolietVd.DataPreparerIdentifier)
                                                           ? null
                                                           : decodedJolietVd.DataPreparerIdentifier;

                if(string.IsNullOrEmpty(decodedJolietVd.ApplicationIdentifier) ||
                   decodedVd.ApplicationIdentifier.Length > decodedJolietVd.ApplicationIdentifier.Length)
                    XmlFsType.ApplicationIdentifier = decodedVd.ApplicationIdentifier;
                else
                    XmlFsType.ApplicationIdentifier = string.IsNullOrEmpty(decodedJolietVd.ApplicationIdentifier)
                                                          ? null
                                                          : decodedJolietVd.ApplicationIdentifier;

                XmlFsType.CreationDate          = decodedJolietVd.CreationTime;
                XmlFsType.CreationDateSpecified = true;
                if(decodedJolietVd.HasModificationTime)
                {
                    XmlFsType.ModificationDate          = decodedJolietVd.ModificationTime;
                    XmlFsType.ModificationDateSpecified = true;
                }

                if(decodedJolietVd.HasExpirationTime)
                {
                    XmlFsType.ExpirationDate          = decodedJolietVd.ExpirationTime;
                    XmlFsType.ExpirationDateSpecified = true;
                }

                if(decodedJolietVd.HasEffectiveTime)
                {
                    XmlFsType.EffectiveDate          = decodedJolietVd.EffectiveTime;
                    XmlFsType.EffectiveDateSpecified = true;
                }
            }
            else
            {
                XmlFsType.SystemIdentifier       = decodedVd.SystemIdentifier;
                XmlFsType.VolumeName             = decodedVd.VolumeIdentifier;
                XmlFsType.VolumeSetIdentifier    = decodedVd.VolumeSetIdentifier;
                XmlFsType.PublisherIdentifier    = decodedVd.PublisherIdentifier;
                XmlFsType.DataPreparerIdentifier = decodedVd.DataPreparerIdentifier;
                XmlFsType.ApplicationIdentifier  = decodedVd.ApplicationIdentifier;
                XmlFsType.CreationDate           = decodedVd.CreationTime;
                XmlFsType.CreationDateSpecified  = true;
                if(decodedVd.HasModificationTime)
                {
                    XmlFsType.ModificationDate          = decodedVd.ModificationTime;
                    XmlFsType.ModificationDateSpecified = true;
                }

                if(decodedVd.HasExpirationTime)
                {
                    XmlFsType.ExpirationDate          = decodedVd.ExpirationTime;
                    XmlFsType.ExpirationDateSpecified = true;
                }

                if(decodedVd.HasEffectiveTime)
                {
                    XmlFsType.EffectiveDate          = decodedVd.EffectiveTime;
                    XmlFsType.EffectiveDateSpecified = true;
                }
            }

            XmlFsType.Bootable    |= bvd != null || segaCd != null || saturn != null || dreamcast != null;
            XmlFsType.Clusters    =  decodedVd.Blocks;
            XmlFsType.ClusterSize =  decodedVd.BlockSize;

            statfs = new FileSystemInfo
            {
                Blocks = decodedVd.Blocks,
                FilenameLength = (ushort)(jolietvd != null
                                              ? this.@namespace == Namespace.Joliet
                                                    ? 110
                                                    : 255
                                              : 255),
                PluginId = Id,
                Type     = fsFormat
            };

            directoryCache = new Dictionary<string, Dictionary<string, DecodedDirectoryEntry>>();

            if(usePathTable)
                foreach(DecodedDirectoryEntry subDirectory in cdi
                                                                  ? GetSubdirsFromCdiPathTable("")
                                                                  : highSierra
                                                                      ? GetSubdirsFromHighSierraPathTable("")
                                                                      : GetSubdirsFromIsoPathTable(""))
                    rootDirectoryCache[subDirectory.Filename] = subDirectory;

            mounted = true;

            return Errno.NoError;
        }

        public Errno Unmount()
        {
            if(!mounted) return Errno.AccessDenied;

            rootDirectoryCache = null;
            directoryCache     = null;
            mounted            = false;

            return Errno.NoError;
        }

        public Errno StatFs(out FileSystemInfo stat)
        {
            stat = null;
            if(!mounted) return Errno.AccessDenied;

            stat = statfs.ShallowCopy();
            return Errno.NoError;
        }
    }
}