Port Quantum extraction (nw)

SabreTools.Serialization/Wrappers/BFPK.cs

@@ -15,9 +15,7 @@ namespace SabreTools.Serialization.Wrappers
 
         #region Extension Properties
 
-        /// <summary>
         /// <inheritdoc cref="Archive.Files"/>
-        /// </summary>
         public FileEntry[] Files => Model.Files ?? [];
 
         #endregion

SabreTools.Serialization/Wrappers/Quantum.cs

@@ -1,8 +1,9 @@
 using System.IO;
+using SabreTools.Models.Quantum;
 
 namespace SabreTools.Serialization.Wrappers
 {
-    public class Quantum : WrapperBase<Models.Quantum.Archive>
+    public class Quantum : WrapperBase<Archive>
     {
         #region Descriptive Properties
 
@@ -14,14 +15,14 @@ namespace SabreTools.Serialization.Wrappers
         #region Constructors
 
         /// <inheritdoc/>
-        public Quantum(Models.Quantum.Archive? model, byte[]? data, int offset)
+        public Quantum(Archive? model, byte[]? data, int offset)
             : base(model, data, offset)
         {
             // All logic is handled by the base class
         }
 
         /// <inheritdoc/>
-        public Quantum(Models.Quantum.Archive? model, Stream? data)
+        public Quantum(Archive? model, Stream? data)
             : base(model, data)
         {
             // All logic is handled by the base class
@@ -74,5 +75,130 @@ namespace SabreTools.Serialization.Wrappers
         }
 
         #endregion
+
+        #region Extension Properties
+
+        /// <inheritdoc cref="Archive.CompressedDataOffset"/>
+        public long CompressedDataOffset => Model.CompressedDataOffset;
+
+        /// <inheritdoc cref="Header.FileCount"/>
+        public ushort FileCount => Model.Header?.FileCount ?? 0;
+
+        /// <inheritdoc cref="Archive.FileList"/>
+        public FileDescriptor[] FileList => Model.FileList ?? [];
+
+        #endregion
+
+        #region Extraction
+
+        /// <summary>
+        /// Extract all files from the Quantum archive to an output directory
+        /// </summary>
+        /// <param name="outputDirectory">Output directory to write to</param>
+        /// <returns>True if all files extracted, false otherwise</returns>
+        public bool ExtractAll(string outputDirectory)
+        {
+            // If we have no files
+            if (FileList == null || FileList.Length == 0)
+                return false;
+
+            // Loop through and extract all files to the output
+            bool allExtracted = true;
+            for (int i = 0; i < FileList.Length; i++)
+            {
+                allExtracted &= ExtractFile(i, outputDirectory);
+            }
+
+            return allExtracted;
+        }
+
+        /// <summary>
+        /// Extract a file from the Quantum archive to an output directory by index
+        /// </summary>
+        /// <param name="index">File index to extract</param>
+        /// <param name="outputDirectory">Output directory to write to</param>
+        /// <returns>True if the file extracted, false otherwise</returns>
+        public bool ExtractFile(int index, string outputDirectory)
+        {
+            // If we have no files
+            if (Model.Header == null || FileCount == 0 || FileList == null || FileList.Length == 0)
+                return false;
+
+            // If we have an invalid index
+            if (index < 0 || index >= FileList.Length)
+                return false;
+
+            // Get the file information
+            var fileDescriptor = FileList[index];
+
+            // Read the entire compressed data
+            int compressedDataOffset = (int)CompressedDataOffset;
+            int compressedDataLength = GetEndOfFile() - compressedDataOffset;
+            var compressedData = ReadFromDataSource(compressedDataOffset, compressedDataLength);
+
+            // TODO: Figure out decompression
+            // - Single-file archives seem to work
+            // - Single-file archives with files that span a window boundary seem to work
+            // - The first files in each archive seem to work
+            return false;
+
+            // // Setup the decompression state
+            // State state = new State();
+            // Decompressor.InitState(state, TableSize, CompressionFlags);
+
+            // // Decompress the entire array
+            // int decompressedDataLength = (int)FileList.Sum(fd => fd.ExpandedFileSize);
+            // byte[] decompressedData = new byte[decompressedDataLength];
+            // Decompressor.Decompress(state, compressedData.Length, compressedData, decompressedData.Length, decompressedData);
+
+            // // Read the data
+            // int offset = (int)FileList.Take(index).Sum(fd => fd.ExpandedFileSize);
+            // byte[] data = new byte[fileDescriptor.ExpandedFileSize];
+            // Array.Copy(decompressedData, offset, data, 0, data.Length);
+
+            // // Loop through all files before the current
+            // for (int i = 0; i < index; i++)
+            // {
+            //     // Decompress the next block of data
+            //     byte[] tempData = new byte[FileList[i].ExpandedFileSize];
+            //     int lastRead = Decompressor.Decompress(state, compressedData.Length, compressedData, tempData.Length, tempData);
+            //     compressedData = new ReadOnlySpan<byte>(compressedData, (lastRead), compressedData.Length - (lastRead)).ToArray();
+            // }
+
+            // // Read the data
+            // byte[] data = new byte[fileDescriptor.ExpandedFileSize];
+            // _ = Decompressor.Decompress(state, compressedData.Length, compressedData, data.Length, data);
+
+            // // Create the filename
+            // string filename = fileDescriptor.FileName;
+
+            // // If we have an invalid output directory
+            // if (string.IsNullOrEmpty(outputDirectory))
+            //     return false;
+
+            // // Create the full output path
+            // filename = Path.Combine(outputDirectory, filename);
+
+            // // Ensure the output directory is created
+            // Directory.CreateDirectory(Path.GetDirectoryName(filename));
+
+            // // Try to write the data
+            // try
+            // {
+            //     // Open the output file for writing
+            //     using (Stream fs = File.OpenWrite(filename))
+            //     {
+            //         fs.Write(data, 0, data.Length);
+            //     }
+            // }
+            // catch
+            // {
+            //     return false;
+            // }
+
+            // return true;
+        }
+
+        #endregion
     }
 }