using System;
using System.Collections.Concurrent;
using System.IO;
using BurnOutSharp.Interfaces;
using BurnOutSharp.Tools;
using StormLibSharp;

namespace BurnOutSharp.FileType
{
    public class MPQ : IScannable
    {
        /// <inheritdoc/>
        public bool ShouldScan(byte[] magic)
        {
            if (magic.StartsWith(new byte?[] { 0x4d, 0x50, 0x51, 0x1a }))
                return true;

            return false;
        }

        /// <inheritdoc/>
        public ConcurrentDictionary<string, ConcurrentQueue<string>> Scan(Scanner scanner, string file)
        {
            if (!File.Exists(file))
                return null;

            using (var fs = File.OpenRead(file))
            {
                return Scan(scanner, fs, file);
            }
        }

        // TODO: Add stream opening support
        /// <inheritdoc/>
        public ConcurrentDictionary<string, ConcurrentQueue<string>> Scan(Scanner scanner, Stream stream, string file)
        {
            // If the mpq file itself fails
            try
            {
                string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
                Directory.CreateDirectory(tempPath);

                using (MpqArchive mpqArchive = new MpqArchive(file, FileAccess.Read))
                {
                    // Try to open the listfile
                    string listfile = null;
                    MpqFileStream listStream = mpqArchive.OpenFile("(listfile)");
                   
                    // If we can't read the listfile, we just return
                    if (!listStream.CanRead)
                        return null;

                    // Read the listfile in for processing
                    using (StreamReader sr = new StreamReader(listStream))
                    {
                        listfile = sr.ReadToEnd();
                    }

                    // Split the listfile by newlines
                    string[] listfileLines = listfile.Replace("\r\n", "\n").Split('\n');

                    // Loop over each entry
                    foreach (string sub in listfileLines)
                    {
                        // If an individual entry fails
                        try
                        {
                            string tempFile = Path.Combine(tempPath, sub);
                            Directory.CreateDirectory(Path.GetDirectoryName(tempFile));
                            mpqArchive.ExtractFile(sub, tempFile);
                        }
                        catch (Exception ex)
                        {
                            if (scanner.IncludeDebug) Console.WriteLine(ex);
                        }
                    }
                }

                // Collect and format all found protections
                var protections = scanner.GetProtections(tempPath);

                // If temp directory cleanup fails
                try
                {
                    Directory.Delete(tempPath, true);
                }
                catch (Exception ex)
                {
                    if (scanner.IncludeDebug) Console.WriteLine(ex);
                }

                // Remove temporary path references
                Utilities.StripFromKeys(protections, tempPath);

                return protections;
            }
            catch (Exception ex)
            {
                if (scanner.IncludeDebug) Console.WriteLine(ex);
            }

            return null;
        }

        // http://zezula.net/en/mpq/mpqformat.html
        #region TEMPORARY AREA FOR MPQ FORMAT

        /// <summary>
        /// MPQ (MoPaQ) is an archive format developed by Blizzard Entertainment,
        /// purposed for storing data files, images, sounds, music and videos for
        /// their games. The name MoPaQ comes from the author of the format,
        /// Mike O'Brien (Mike O'brien PaCK).
        /// </summary>
        internal class MoPaQArchive
        {
            #region Constants

            #region Header Sizes

            public const int HeaderVersion1Size = 0x20;

            public const int HeaderVersion2Size = 0x2C;

            public const int HeaderVersion3Size = 0x44;

            public const int HeaderVersion4Size = 0xD0;

            #endregion

            #region Signatures

            /// <summary>
            /// Human-readable signature
            /// </summary>
            public static readonly string SignatureString = $"MPQ{(char)0x1A}";

            /// <summary>
            /// Signature as an unsigned Int32 value
            /// </summary>
            public const uint SignatureValue = 0x1A51504D;

            /// <summary>
            /// Signature as a byte array
            /// </summary>
            public static readonly byte[] SignatureBytes = new byte[] { 0x4D, 0x50, 0x51, 0x1A };

            #endregion

            #endregion

            #region Properties

            // Data before archive, ignored

            /// <summary>
            /// MPQ User Data (optional)
            /// </summary>
            public MoPaQUserData UserData { get; private set; }

            /// <summary>
            /// MPQ Header (required)
            /// </summary>
            public MoPaQArchiveHeader ArchiveHeader { get; private set; }

            // Files (optional)
            // Special files (optional)

            /// <summary>
            /// HET Table (optional)
            /// </summary>
            public MoPaQHetTable HetTable { get; private set; }

            /// <summary>
            /// BET Table (optional)
            /// </summary>
            public MoPaQBetTable BetTable { get; private set; }

            /// <summary>
            /// Hash Table (optional)
            /// </summary>
            public MoPaQHashEntry[] HashTable { get; private set; }

            /// <summary>
            /// Block Table (optional)
            /// </summary>
            public MoPaQBlockEntry[] BlockTable { get; private set; }

            /// <summary>
            /// Hi-Block Table (optional)
            /// </summary>
            /// <remarks>
            /// Since World of Warcraft - The Burning Crusade, Blizzard extended
            /// the MPQ format to support archives larger than 4GB. The hi-block
            /// table holds the higher 16-bits of the file position in the MPQ.
            /// Hi-block table is plain array of 16-bit values. This table is
            /// not encrypted.
            /// </remarks>
            public short[] HiBlockTable { get; private set; }

            // Strong digital signature

            #endregion
        }

        /// <summary>
        /// MPQ User Data are optional, and is commonly used in custom maps for
        /// Starcraft II. If MPQ User Data header is present, it contains an offset,
        /// from where the MPQ header should be searched.
        /// </summary>
        internal class MoPaQUserData
        {
            #region Constants

            public const int Size = 0x10;

            /// <summary>
            /// Human-readable signature
            /// </summary>
            public static readonly string SignatureString = $"MPQ{(char)0x1B}";

            /// <summary>
            /// Signature as an unsigned Int32 value
            /// </summary>
            public const uint SignatureValue = 0x1B51504D;

            /// <summary>
            /// Signature as a byte array
            /// </summary>
            public static readonly byte[] SignatureBytes = new byte[] { 0x4D, 0x50, 0x51, 0x1B };

            #endregion

            #region Properties

            /// <summary>
            /// The user data signature
            /// </summary>
            /// <see cref="SignatureValue"/>
            public uint Signature { get; private set; }

            /// <summary>
            /// Maximum size of the user data
            /// </summary>
            public int UserDataSize { get; private set; }

            /// <summary>
            /// Offset of the MPQ header, relative to the beginning of this header
            /// </summary>
            public int HeaderOffset { get; private set; }

            /// <summary>
            /// Appears to be size of user data header (Starcraft II maps)
            /// </summary>
            public int UserDataHeadersize { get; private set; }

            // TODO: Does this area contain extra data that should be read in?

            #endregion
        }

        /// <summary>
        /// MoPaQ archive header
        /// </summary>
        internal class MoPaQArchiveHeader
        {
            #region V1 Properties

            /// <summary>
            /// The MPQ archive signature
            /// </summary>
            public uint Signature { get; private set; }

            /// <summary>
            /// Size of the archive header
            /// </summary>
            public int HeaderSize { get; private set; }

            /// <summary>
            /// Size of MPQ archive
            /// </summary>
            /// <remarks>
            /// This field is deprecated in the Burning Crusade MoPaQ format, and the size of the archive
            /// is calculated as the size from the beginning of the archive to the end of the hash table,
            /// block table, or extended block table (whichever is largest).
            /// </remarks>
            public int ArchiveSize { get; private set; }

            /// <summary>
            /// 0 = Format 1 (up to The Burning Crusade)
            /// 1 = Format 2 (The Burning Crusade and newer)
            /// 2 = Format 3 (WoW - Cataclysm beta or newer)
            /// 3 = Format 4 (WoW - Cataclysm beta or newer)
            /// </summary>
            public short FormatVersion { get; private set; }

            /// <summary>
            /// Power of two exponent specifying the number of 512-byte disk sectors in each logical sector
            /// in the archive. The size of each logical sector in the archive is 512 * 2 ^ BlockSize.
            /// </summary>
            public short BlockSize { get; private set; }

            /// <summary>
            /// Offset to the beginning of the hash table, relative to the beginning of the archive.
            /// </summary>
            public int HashTablePosition { get; private set; }

            /// <summary>
            /// Offset to the beginning of the block table, relative to the beginning of the archive.
            /// </summary>
            public int BlockTablePosition { get; private set; }

            /// <summary>
            /// Number of entries in the hash table. Must be a power of two, and must be less than 2^16 for
            /// the original MoPaQ format, or less than 2^20 for the Burning Crusade format.
            /// </summary>
            public int HashTableSize { get; private set; }

            /// <summary>
            /// Number of entries in the block table
            /// </summary>
            public int BlockTableSize { get; private set; }

            #endregion

            #region V2 Properties

            /// <summary>
            /// Offset to the beginning of array of 16-bit high parts of file offsets.
            /// </summary>
            public long HiBlockTablePosition { get; private set; }

            /// <summary>
            /// High 16 bits of the hash table offset for large archives.
            /// </summary>
            public short HashTablePositionHi { get; private set; }

            /// <summary>
            /// High 16 bits of the block table offset for large archives.
            /// </summary>
            public short BlockTablePositionHi { get; private set; }

            #endregion

            #region V3 Properties

            /// <summary>
            /// 64-bit version of the archive size
            /// </summary>
            public long ArchiveSizeLong { get; private set; }

            /// <summary>
            /// 64-bit position of the BET table
            /// </summary>
            public long BetTablePosition { get; private set; }

            /// <summary>
            /// 64-bit position of the HET table
            /// </summary>
            public long HetTablePosition { get; private set; }

            #endregion

            #region V4 Properties

            /// <summary>
            /// Compressed size of the hash table
            /// </summary>
            public long HashTableSizeLong { get; private set; }

            /// <summary>
            /// Compressed size of the block table
            /// </summary>
            public long BlockTableSizeLong { get; private set; }

            /// <summary>
            /// Compressed size of the hi-block table
            /// </summary>
            public long HiBlockTableSize { get; private set; }

            /// <summary>
            /// Compressed size of the HET block
            /// </summary>
            public long HetTableSize { get; private set; }

            /// <summary>
            /// Compressed size of the BET block
            /// </summary>
            public long BetTablesize { get; private set; }

            /// <summary>
            /// Size of raw data chunk to calculate MD5.
            /// </summary>
            /// <remarks>MD5 of each data chunk follows the raw file data.</remarks>
            public int RawChunkSize { get; private set; }

            // TODO: Is there a byte[] here of size RawChunkSize?

            /// <summary>
            /// MD5 of the block table before decryption
            /// </summary>
            public byte[] BlockTableMD5 { get; private set; } = new byte[0x10];

            /// <summary>
            /// MD5 of the hash table before decryption
            /// </summary>
            public byte[] HashTableMD5 { get; private set; } = new byte[0x10];

            /// <summary>
            /// MD5 of the hi-block table
            /// </summary>
            public byte[] HiBlockTableMD5 { get; private set; } = new byte[0x10];

            /// <summary>
            /// MD5 of the BET table before decryption
            /// </summary>
            public byte[] BetTableMD5 { get; private set; } = new byte[0x10];

            /// <summary>
            /// MD5 of the HET table before decryption
            /// </summary>
            public byte[] HetTableMD5 { get; private set; } = new byte[0x10];

            /// <summary>
            /// MD5 of the MPQ header from signature to (including) HetTableMD5
            /// </summary>
            public byte[] MpqHeaderMD5 { get; private set; } = new byte[0x10];

            #endregion
        }

        /// <summary>
        /// The HET table is present if the HetTablePos64 member of MPQ header is
        /// set to nonzero. This table can fully replace hash table. Depending on
        /// MPQ size, the pair of HET&BET table can be more efficient than Hash&Block
        /// table. HET table can be encrypted and compressed.
        /// </summary>
        internal class MoPaQHetTable
        {
            #region Constants

            public const int Size = 0x44;

            /// <summary>
            /// Human-readable signature
            /// </summary>
            public static readonly string SignatureString = $"HET{(char)0x1A}";

            /// <summary>
            /// Signature as an unsigned Int32 value
            /// </summary>
            public const uint SignatureValue = 0x1A544548;

            /// <summary>
            /// Signature as a byte array
            /// </summary>
            public static readonly byte[] SignatureBytes = new byte[] { 0x48, 0x45, 0x54, 0x1A };

            #endregion

            // TODO: Extract this out and make in common between HET and BET
            #region Common Table Headers

            /// <summary>
            /// 'HET\x1A'
            /// </summary>
            public uint Signature { get; private set; }

            /// <summary>
            /// Version. Seems to be always 1
            /// </summary>
            public int Version { get; private set; }

            /// <summary>
            /// Size of the contained table
            /// </summary>
            public int DataSize { get; private set; }

            #endregion

            #region Properties

            /// <summary>
            /// Size of the entire hash table, including the header (in bytes)
            /// </summary>
            public int TableSize { get; private set; }

            /// <summary>
            /// Maximum number of files in the MPQ
            /// </summary>
            public int MaxFileCount { get; private set; }

            /// <summary>
            /// Size of the hash table (in bytes)
            /// </summary>
            public int HashTableSize { get; private set; }

            /// <summary>
            /// Effective size of the hash entry (in bits)
            /// </summary>
            public int HashEntrySize { get; private set; }

            /// <summary>
            /// Total size of file index (in bits)
            /// </summary>
            public int TotalIndexSize { get; private set; }

            /// <summary>
            /// Extra bits in the file index
            /// </summary>
            public int IndexSizeExtra { get; private set; }

            /// <summary>
            /// Effective size of the file index (in bits)
            /// </summary>
            public int IndexSize { get; private set; }

            /// <summary>
            /// Size of the block index subtable (in bytes)
            /// </summary>
            public int BlockTableSize { get; private set; }

            /// <summary>
            /// HET hash table. Each entry is 8 bits.
            /// </summary>
            /// <remarks>Size is derived from HashTableSize</remarks>
            public byte[] HashTable { get; private set; }

            // TODO: Implement both of these on parse
            // Array of file indexes. Bit size of each entry is taken from dwTotalIndexSize.
            // Table size is taken from dwHashTableSize.

            #endregion
        }

        /// <summary>
        /// he BET table is present if the BetTablePos64 member of MPQ header is set
        /// to nonzero. BET table is a successor of classic block table, and can fully
        /// replace it. It is also supposed to be more effective.
        /// </summary>
        internal class MoPaQBetTable
        {
            #region Constants

            public const int Size = 0x88;

            /// <summary>
            /// Human-readable signature
            /// </summary>
            public static readonly string SignatureString = $"BET{(char)0x1A}";

            /// <summary>
            /// Signature as an unsigned Int32 value
            /// </summary>
            public const uint SignatureValue = 0x1A544542;

            /// <summary>
            /// Signature as a byte array
            /// </summary>
            public static readonly byte[] SignatureBytes = new byte[] { 0x42, 0x45, 0x54, 0x1A };

            #endregion

            // TODO: Extract this out and make in common between HET and BET
            #region Common Table Headers

            /// <summary>
            /// 'BET\x1A'
            /// </summary>
            public uint Signature { get; private set; }

            /// <summary>
            /// Version. Seems to be always 1
            /// </summary>
            public int Version { get; private set; }

            /// <summary>
            /// Size of the contained table
            /// </summary>
            public int DataSize { get; private set; }

            #endregion

            #region Properties

            /// <summary>
            /// Size of the entire hash table, including the header (in bytes)
            /// </summary>
            public int TableSize { get; private set; }

            /// <summary>
            /// Number of files in the BET table
            /// </summary>
            public int FileCount { get; private set; }

            /// <summary>
            /// Unknown, set to 0x10
            /// </summary>
            public int Unknown { get; private set; }

            /// <summary>
            /// Size of one table entry (in bits)
            /// </summary>
            public int TableEntrySize { get; private set; }

            /// <summary>
            /// Bit index of the file position (within the entry record)
            /// </summary>
            public int FilePositionBitIndex { get; private set; }

            /// <summary>
            /// Bit index of the file size (within the entry record)
            /// </summary>
            public int FileSizeBitIndex { get; private set; }

            /// <summary>
            /// Bit index of the compressed size (within the entry record)
            /// </summary>
            public int CompressedSizeBitIndex { get; private set; }

            /// <summary>
            /// Bit index of the flag index (within the entry record)
            /// </summary>
            public int FlagIndexBitIndex { get; private set; }

            /// <summary>
            /// Bit index of the ??? (within the entry record)
            /// </summary>
            public int UnknownBitIndex { get; private set; }

            /// <summary>
            /// Bit size of file position (in the entry record)
            /// </summary>
            public int FilePositionBitCount { get; private set; }

            /// <summary>
            /// Bit size of file size (in the entry record)
            /// </summary>
            public int FileSizeBitCount { get; private set; }

            /// <summary>
            /// Bit size of compressed file size (in the entry record)
            /// </summary>
            public int CompressedSizeBitCount { get; private set; }

            /// <summary>
            /// Bit size of flags index (in the entry record)
            /// </summary>
            public int FlagIndexBitCount { get; private set; }

            /// <summary>
            /// Bit size of ??? (in the entry record)
            /// </summary>
            public int UnknownBitCount { get; private set; }

            /// <summary>
            /// Total size of the BET hash
            /// </summary>
            public int TotalBetHashSize { get; private set; }

            /// <summary>
            /// Extra bits in the BET hash
            /// </summary>
            public int BetHashSizeExtra { get; private set; }

            /// <summary>
            /// Effective size of BET hash (in bits)
            /// </summary>
            public int BetHashSize { get; private set; }

            /// <summary>
            /// Size of BET hashes array, in bytes
            /// </summary>
            public int BetHashArraySize { get; private set; }

            /// <summary>
            /// Number of flags in the following array
            /// </summary>
            public int FlagCount { get; private set; }

            /// <summary>
            /// Followed by array of file flags. Each entry is 32-bit size and its meaning is the same like
            /// </summary>
            /// <remarks>Size from <see cref="FlagCount"/></remarks>
            public int[] FlagsArray { get; private set; }

            // File table. Size of each entry is taken from dwTableEntrySize.
            // Size of the table is (dwTableEntrySize * dwMaxFileCount), round up to 8.

            // Array of BET hashes. Table size is taken from dwMaxFileCount from HET table

            #endregion
        }

        /// <summary>
        /// Hash table is used for searching files by name. The file name is converted to
        /// two 32-bit hash values, which are then used for searching in the table. The size
        /// of the hash table must always be a power of two. Each entry in the hash table
        /// also contains file locale and offset into block table. Size of one entry of hash
        /// table is 16 bytes.
        /// </summary>
        internal class MoPaQHashEntry
        {
            #region Constants

            public const int Size = 0x10;

            #endregion

            #region Properties

            /// <summary>
            /// The hash of the full file name (part A)
            /// </summary>
            public uint NameHashPartA { get; private set; }

            /// <summary>
            /// The hash of the full file name (part B)
            /// </summary>
            public uint NameHashPartB { get; private set; }

            /// <summary>
            /// The language of the file. This is a Windows LANGID data type, and uses the same values.
            /// 0 indicates the default language (American English), or that the file is language-neutral.
            /// </summary>
            public MoPaQLocale Locale { get; private set; }

            /// <summary>
            /// The platform the file is used for. 0 indicates the default platform.
            /// No other values have been observed.
            /// </summary>
            public short Platform { get; private set; }

            /// <summary>
            /// If the hash table entry is valid, this is the index into the block table of the file.
            /// Otherwise, one of the following two values:
            ///  - FFFFFFFFh: Hash table entry is empty, and has always been empty.
            ///               Terminates searches for a given file.
            ///  - FFFFFFFEh: Hash table entry is empty, but was valid at some point (a deleted file).
            ///               Does not terminate searches for a given file.
            /// </summary>
            public uint BlockIndex { get; private set; }

            #endregion
        }

        internal enum MoPaQLocale : short
        {
            Neutral = 0,
            AmericanEnglish = 0,
            ChineseTaiwan = 0x404,
            Czech = 0x405,
            German = 0x407,
            English = 0x409,
            Spanish = 0x40A,
            French = 0x40C,
            Italian = 0x410,
            Japanese = 0x411,
            Korean = 0x412,
            Polish = 0x415,
            Portuguese = 0x416,
            Russian = 0x419,
            EnglishUK = 0x809,
        }

        /// <summary>
        /// Block table contains informations about file sizes and way of their storage within
        /// the archive. It also contains the position of file content in the archive. Size
        /// of block table entry is (like hash table entry). The block table is also encrypted.
        /// </summary>
        internal class MoPaQBlockEntry
        {
            #region Constants

            public const int Size = 0x10;

            #endregion

            #region Properties

            /// <summary>
            /// Offset of the beginning of the file data, relative to the beginning of the archive.
            /// </summary>
            public int FilePosition { get; private set; }

            /// <summary>
            /// Compressed file size
            /// </summary>
            public int CompressedSize { get; private set; }

            /// <summary>
            /// Size of uncompressed file
            /// </summary>
            public int UncompressedSize { get; private set; }

            /// <summary>
            /// Flags for the file.
            /// </summary>
            public MoPaQFileFlags Flags { get; private set; }

            #endregion
        }

        [Flags]
        internal enum MoPaQFileFlags : uint
        {
            /// <summary>
            /// File is compressed using PKWARE Data compression library
            /// </summary>
            MPQ_FILE_IMPLODE = 0x00000100,

            /// <summary>
            /// File is compressed using combination of compression methods
            /// </summary>
            MPQ_FILE_COMPRESS = 0x00000200,

            /// <summary>
            /// The file is encrypted
            /// </summary>
            MPQ_FILE_ENCRYPTED = 0x00010000,

            /// <summary>
            /// The decryption key for the file is altered according to the
            /// position of the file in the archive
            /// </summary>
            MPQ_FILE_FIX_KEY = 0x00020000,

            /// <summary>
            /// The file contains incremental patch for an existing file in base MPQ
            /// </summary>
            MPQ_FILE_PATCH_FILE = 0x00100000,

            /// <summary>
            /// Instead of being divided to 0x1000-bytes blocks, the file is stored
            /// as single unit
            /// </summary>
            MPQ_FILE_SINGLE_UNIT = 0x01000000,

            /// <summary>
            /// File is a deletion marker, indicating that the file no longer exists.
            /// This is used to allow patch archives to delete files present in
            /// lower-priority archives in the search chain. The file usually has
            /// length of 0 or 1 byte and its name is a hash
            /// </summary>
            MPQ_FILE_DELETE_MARKER = 0x02000000,

            /// <summary>
            /// File has checksums for each sector (explained in the File Data section).
            /// Ignored if file is not compressed or imploded.
            /// </summary>
            MPQ_FILE_SECTOR_CRC = 0x04000000,

            /// <summary>
            /// Set if file exists, reset when the file was deleted
            /// </summary>
            MPQ_FILE_EXISTS = 0x80000000,
        }

        /// <summary>
        /// This structure contains size of the patch, flags and also MD5 of the patch.
        /// </summary>
        internal class MoPaQPatchInfo
        {
            #region Properties

            /// <summary>
            /// Length of patch info header, in bytes
            /// </summary>
            public int Length { get; private set; }

            /// <summary>
            /// Flags. 0x80000000 = MD5 (?)
            /// </summary>
            public uint Flags { get; private set; }

            /// <summary>
            /// Uncompressed size of the patch file
            /// </summary>
            public int DataSize { get; private set; }

            /// <summary>
            /// MD5 of the entire patch file after decompression
            /// </summary>
            public byte[] MD5 { get; private set; } = new byte[0x10];

            /// <summary>
            /// The sector offset table (variable length)
            /// </summary>
            public int[] SectorOffsetTable { get; private set; }

            #endregion
        }

        /// <summary>
        /// Each incremental patch file in a patch MPQ starts with a header. It is supposed
        /// to be a structure with variable length.
        /// </summary>
        internal class MoPaQPatchHeader
        {
            #region Constants

            #region Signatures

            #region Patch Header

            /// <summary>
            /// Human-readable signature
            /// </summary>
            public static readonly string PatchSignatureString = $"PTCH";

            /// <summary>
            /// Signature as an unsigned Int32 value
            /// </summary>
            public const uint PatchSignatureValue = 0x48435450;

            /// <summary>
            /// Signature as a byte array
            /// </summary>
            public static readonly byte[] PatchSignatureBytes = new byte[] { 0x50, 0x54, 0x43, 0x48 };

            #endregion

            #region MD5 Block

            /// <summary>
            /// Human-readable signature
            /// </summary>
            public static readonly string Md5SignatureString = $"MD5_";

            /// <summary>
            /// Signature as an unsigned Int32 value
            /// </summary>
            public const uint Md5SignatureValue = 0x5F35444D;

            /// <summary>
            /// Signature as a byte array
            /// </summary>
            public static readonly byte[] Md5SignatureBytes = new byte[] { 0x4D, 0x44, 0x35, 0x5F };

            #endregion

            #region XFRM Block

            /// <summary>
            /// Human-readable signature
            /// </summary>
            public static readonly string XFRMSignatureString = $"XFRM";

            /// <summary>
            /// Signature as an unsigned Int32 value
            /// </summary>
            public const uint XFRMSignatureValue = 0x4D524658;

            /// <summary>
            /// Signature as a byte array
            /// </summary>
            public static readonly byte[] XFRMSignatureBytes = new byte[] { 0x58, 0x46, 0x52, 0x4D };

            #endregion

            #region BSDIFF Patch Type

            /// <summary>
            /// Human-readable signature
            /// </summary>
            public static readonly string BSDIFF40SignatureString = $"BSDIFF40";

            /// <summary>
            /// Signature as an unsigned Int64 value
            /// </summary>
            public const ulong BSDIFF40SignatureValue = 0x3034464649445342;

            /// <summary>
            /// Signature as a byte array
            /// </summary>
            public static readonly byte[] BSDIFF40SignatureBytes = new byte[] { 0x42, 0x53, 0x44, 0x49, 0x46, 0x46, 0x34, 0x30 };


            #endregion

            #endregion

            #endregion

            #region Properties

            #region PATCH Header

            /// <summary>
            /// 'PTCH'
            /// </summary>
            public uint PatchSignature { get; private set; }

            /// <summary>
            /// Size of the entire patch (decompressed)
            /// </summary>
            public int SizeOfPatchData { get; private set; }

            /// <summary>
            /// Size of the file before patch
            /// </summary>
            public int SizeBeforePatch { get; private set; }

            /// <summary>
            /// Size of file after patch
            /// </summary>
            public int SizeAfterPatch { get; private set; }

            #endregion

            #region MD5 Block

            /// <summary>
            /// 'MD5_'
            /// </summary>
            public uint Md5Signature { get; private set; }

            /// <summary>
            /// Size of the MD5 block, including the signature and size itself
            /// </summary>
            public int Md5BlockSize { get; private set; }

            /// <summary>
            /// MD5 of the original (unpached) file
            /// </summary>
            public byte[] Md5BeforePatch { get; private set; } = new byte[0x10];

            /// <summary>
            /// MD5 of the patched file
            /// </summary>
            public byte[] Md5AfterPatch { get; private set; } = new byte[0x10];

            #endregion

            #region XFRM Block

            /// <summary>
            /// 'XFRM'
            /// </summary>
            public uint XfrmSignature { get; private set; }

            /// <summary>
            /// Size of the XFRM block, includes XFRM header and patch data
            /// </summary>
            public int XfrmBlockSize { get; private set; }

            /// <summary>
            /// Type of patch ('BSD0' or 'COPY')
            /// </summary>
            public MoPaQPatchType PatchType { get; private set; }

            #endregion

            #region Patch Data - BSD0

            /// <summary>
            /// 'BSDIFF40' signature
            /// </summary>
            public ulong BsdiffSignature { get; private set; }

            /// <summary>
            /// Size of CTRL block (in bytes)
            /// </summary>
            public long CtrlBlockSize { get; private set; }

            /// <summary>
            /// Size of DATA block (in bytes)
            /// </summary>
            public long DataBlockSize { get; private set; }

            /// <summary>
            /// Size of file after applying the patch (in bytes)
            /// </summary>
            public long NewFileSize { get; private set; }

            // TODO: Fill rest of data from http://zezula.net/en/mpq/patchfiles.html
            // CTRL block
            // DATA block
            // EXTRA block

            #endregion

            #region Patch Data - COPY

            /// <summary>
            /// File data are simply replaced by the data in the patch.
            /// </summary>
            public byte[] PatchDataCopy { get; private set; }

            #endregion

            #endregion
        }

        internal enum MoPaQPatchType : uint
        {
            /// <summary>
            /// Blizzard-modified version of BSDIFF40 incremental patch
            /// </summary>
            BSD0 = 0x30445342,

            /// <summary>
            /// Unknown
            /// </summary>
            BSDP = 0x50445342,

            /// <summary>
            /// Plain replace
            /// </summary>
            COPY = 0x59504F43,

            /// <summary>
            /// Unknown
            /// </summary>
            COUP = 0x50554F43,

            /// <summary>
            /// Unknown
            /// </summary>
            CPOG = 0x474F5043,
        }

        #endregion
    }
}