using System;
using NewLife.IO;
using System.IO;
using System.Text;
using NewLife.Compression.LZMA;
using System.Collections.Generic;
using NewLife.Security;
using System.Linq;

namespace NewLife.Compression
{
    /// <summary>7z压缩包</summary>
    public class SevenZip
    {
        #region 属性
        private static readonly byte[] SIGNATURE = new byte[] { (byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C };

        private String _Name;
        /// <summary>名称</summary>
        public String Name { get { return _Name; } set { _Name = value; } }

        private String _Comment;
        /// <summary>注释</summary>
        public String Comment { get { EnsureRead(); return _Comment; } set { _Comment = value; } }

        private Encoding _Encoding;
        /// <summary>字符串编码</summary>
        public Encoding Encoding { get { return _Encoding ?? Encoding.Default; } set { _Encoding = value; } }

        private Version _Version;
        /// <summary>版本</summary>
        public Version Version { get { return _Version; } set { _Version = value; } }

        private UInt32 _Crc;
        /// <summary>校验</summary>
        public UInt32 Crc { get { return _Crc; } set { _Crc = value; } }
        #endregion

        #region 构造
        /// <summary>实例化一个Zip文件对象</summary>
        public SevenZip() { }

        /// <summary>实例化一个Zip文件对象。延迟到第一次使用<see cref="Entries"/>时读取</summary>
        /// <param name="fileName"></param>
        public SevenZip(String fileName) : this(fileName, null) { }

        /// <summary>实例化一个Zip文件对象。延迟到第一次使用<see cref="Entries"/>时读取</summary>
        /// <param name="fileName">文件名</param>
        /// <param name="encoding">字符串编码</param>
        public SevenZip(String fileName, Encoding encoding)
        {
            Name = fileName;
            Encoding = encoding;
            _file = fileName;
        }

        /// <summary>实例化一个Zip文件对象。延迟到第一次使用<see cref="Entries"/>时读取</summary>
        /// <param name="stream"></param>
        /// <param name="encoding"></param>
        public SevenZip(Stream stream, Encoding encoding)
        {
            Encoding = encoding;
            _stream = stream;
        }
        #endregion

        #region 读取
        String _file;
        Stream _stream;

        /// <summary>使用文件和数据流时，延迟到第一次使用<see cref="Entries"/>时读取</summary>
        void EnsureRead()
        {
            // 这里必须把_file=null这行注释，否则进不去，不知道为什么
            if (!_file.IsNullOrWhiteSpace())
            {
                var f = _file;
                _file = null;
                var fs = File.OpenRead(f);
#if !DEBUG
                try
#endif
                {
                    Read(fs);
                }
#if !DEBUG
                catch (Exception ex)
                {
                    fs.Dispose();
                    throw new ZipException("不是有效的Zip格式！", ex);
                }
#endif
            }
            else if (_stream != null)
            {
                var fs = _stream;
                _stream = null;
                try
                {
                    Read(fs);
                }
                catch (Exception ex)
                {
                    throw new ZipException("不是有效的Zip格式！", ex);
                }
            }
        }

        /// <summary>从数据流中读取Zip格式数据</summary>
        /// <param name="stream">数据流</param>
        public Boolean Read(Stream stream)
        {
            // 检查签名
            var sign = stream.ReadBytes(SIGNATURE.Length);
            if (sign.CompareTo(SIGNATURE) != 0) return false;

            var reader = new BinaryReader(stream);

            Version = new Version(reader.ReadByte(), reader.ReadByte());

            // 连续24字节，前4字节是CRC，后面8+8+4字节是数据
            var crc = reader.ReadUInt32();
            var p = stream.Position;
            Int64 nextHeaderOffset = reader.ReadInt64();
            Int64 nextHeaderSize = reader.ReadInt64();
            Int32 nextHeaderCRC = reader.ReadInt32();

            // 检查校验
            var crc2 = Crc32.ComputeRange(stream, p, 0);
            if (crc2 != crc) return false;

            stream.Seek(nextHeaderOffset, SeekOrigin.Current);
            ReadArchive(stream, nextHeaderOffset, nextHeaderSize);
            //PostProcess();

            return true;
        }

        private void ReadArchive(Stream stream, Int64 offset, Int64 length)
        {
            while (true)
            {
                var prop = (HeaderProperty)stream.ReadByte();
                switch (prop)
                {
                    case HeaderProperty.kEnd:
                        {
                            //ReadFileHeader(headerBytes);
                            return;
                        }
                    case HeaderProperty.kEncodedHeader:
                        {
                            var size = stream.ReadByte();
                            //var p = stream.Position + size;
                            stream.Seek(size, SeekOrigin.Current);

                            ReadPackedStreams(stream);
                            //stream.Seek(offset + ArchiveInfo.PackPosition, SeekOrigin.Begin);
                            //var firstFolder = ArchiveInfo.Folders.First();

                            //ulong unpackSize = firstFolder.GetUnpackSize();

                            //ulong packSize = ArchiveInfo.PackedStreams.Select(x => x.PackedSize)
                            //    .Aggregate((ulong)0, (sum, size) => sum + size);

                            //byte[] unpackedBytes = new byte[(int)unpackSize];
                            //var decoder = new Decoder();
                            //decoder.SetDecoderProperties(firstFolder.Coders[0].Properties);
                            //using (MemoryStream outStream = new MemoryStream(unpackedBytes))
                            //{
                            //    decoder.Code(stream, outStream, (long)(packSize), (long)unpackSize, null);
                            //}

                            //headerBytes = new HeaderBuffer { Bytes = unpackedBytes };

                            //stream.Position = p;
                        }
                        break;
                    case HeaderProperty.kHeader:
                        {
                            //ReadFileHeader(headerBytes);
                            return;
                        }
                    default:
                        {
                            //throw new NotSupportedException("7Zip header " + prop);

                            var size = stream.ReadByte();
                            stream.Seek(size, SeekOrigin.Current);

                            break;
                        }
                }
            }
        }

        //private void ReadFileHeader(HeaderBuffer headerBytes)
        //{
        //    while (true)
        //    {
        //        var prop = headerBytes.ReadProperty();
        //        switch (prop)
        //        {
        //            case HeaderProperty.kMainStreamsInfo:
        //                {
        //                    FilesInfo = ReadPackedStreams(headerBytes);
        //                }
        //                break;
        //            case HeaderProperty.kFilesInfo:
        //                {
        //                    Entries = ReadFilesInfo(FilesInfo, headerBytes);
        //                }
        //                break;
        //            case HeaderProperty.kEnd:
        //                return;
        //            default:
        //                throw new InvalidFormatException(prop.ToString());
        //        }
        //    }
        //}
        //private static HeaderEntry[] ReadFilesInfo(StreamsInfo info, HeaderBuffer headerBytes)
        //{
        //    var entries = headerBytes.CreateArray<HeaderEntry>();
        //    int numEmptyStreams = 0;
        //    while (true)
        //    {
        //        var type = headerBytes.ReadProperty();
        //        if (type == HeaderProperty.kEnd)
        //        {
        //            break;
        //        }

        //        var size = (int)headerBytes.ReadEncodedInt64();

        //        switch (type)
        //        {
        //            case HeaderProperty.kName:
        //                {
        //                    if (headerBytes.ReadByte() != 0)
        //                    {
        //                        throw new InvalidFormatException("Cannot be external");
        //                    }
        //                    entries.ForEach(f => f.Name = headerBytes.ReadName());
        //                    break;
        //                }
        //            case HeaderProperty.kEmptyStream:
        //                {
        //                    info.EmptyStreamFlags = headerBytes.ReadBoolFlags(entries.Length);
        //                    numEmptyStreams = info.EmptyStreamFlags.Where(x => x).Count();
        //                    break;
        //                }
        //            case HeaderProperty.kEmptyFile: //just read bytes
        //            case HeaderProperty.kAnti:
        //                {
        //                    info.EmptyFileFlags = headerBytes.ReadBoolFlags(numEmptyStreams);
        //                    break;
        //                }
        //            default:
        //                {
        //                    headerBytes.ReadBytes(size);
        //                    break;
        //                }
        //        }
        //    }
        //    int emptyFileIndex = 0;
        //    int sizeIndex = 0;
        //    for (int i = 0; i < entries.Length; i++)
        //    {
        //        HeaderEntry file = entries[i];
        //        file.IsAnti = false;
        //        if (info.EmptyStreamFlags == null)
        //        {
        //            file.HasStream = true;
        //        }
        //        else
        //        {
        //            file.HasStream = !info.EmptyStreamFlags[i];
        //        }
        //        if (file.HasStream)
        //        {
        //            file.IsDirectory = false;
        //            file.Size = info.UnpackedStreams[sizeIndex].UnpackedSize;
        //            file.FileCRC = info.UnpackedStreams[sizeIndex].Digest;
        //            sizeIndex++;
        //        }
        //        else
        //        {
        //            if (info.EmptyFileFlags == null)
        //            {
        //                file.IsDirectory = true;
        //            }
        //            else
        //            {
        //                file.IsDirectory = !info.EmptyFileFlags[emptyFileIndex];
        //            }
        //            emptyFileIndex++;
        //            file.Size = 0;
        //        }
        //    }
        //    return entries;
        //}

        private StreamsInfo ReadPackedStreams(Stream stream)
        {
            var info = new StreamsInfo();
            while (true)
            {
                var prop = (HeaderProperty)stream.ReadByte();
                switch (prop)
                {
                    case HeaderProperty.kUnpackInfo:
                        {
                            ReadUnPackInfo(info, stream);
                        }
                        break;
                    case HeaderProperty.kPackInfo:
                        {
                            var reader = new BinaryReader(stream);
                            info.Offset = reader.ReadInt64();
                            ReadPackInfo(info, stream);
                        }
                        break;
                    case HeaderProperty.kSubStreamsInfo:
                        {
                            //ReadSubStreamsInfo(info, headerBytes);
                        }
                        break;
                    case HeaderProperty.kEnd:
                        return info;
                    default:
                        throw new Exception(prop.ToString());
                }
            }

            return info;
        }

        //private static void ReadSubStreamsInfo(StreamsInfo info, HeaderBuffer headerBytes)
        //{
        //    info.UnpackedStreams = new List<UnpackedStreamInfo>();
        //    foreach (var folder in info.Folders)
        //    {
        //        folder.UnpackedStreams = new UnpackedStreamInfo[1];
        //        folder.UnpackedStreams[0] = new UnpackedStreamInfo();
        //        info.UnpackedStreams.Add(folder.UnpackedStreams[0]);
        //    }

        //    bool loop = true;
        //    var prop = HeaderProperty.kEnd;
        //    while (loop)
        //    {
        //        prop = headerBytes.ReadProperty();
        //        switch (prop)
        //        {
        //            case HeaderProperty.kNumUnPackStream:
        //                {
        //                    info.UnpackedStreams.Clear();
        //                    foreach (var folder in info.Folders)
        //                    {
        //                        var numStreams = (int)headerBytes.ReadEncodedInt64();
        //                        folder.UnpackedStreams = new UnpackedStreamInfo[numStreams];
        //                        folder.UnpackedStreams.Initialize(() => new UnpackedStreamInfo());
        //                        info.UnpackedStreams.AddRange(folder.UnpackedStreams);
        //                    }
        //                }
        //                break;
        //            case HeaderProperty.kCRC:
        //            case HeaderProperty.kSize:
        //            case HeaderProperty.kEnd:
        //                {
        //                    loop = false;
        //                }
        //                break;
        //            default:
        //                throw new InvalidFormatException(prop.ToString());
        //        }
        //    }

        //    int si = 0;
        //    for (int i = 0; i < info.Folders.Length; i++)
        //    {
        //        var folder = info.Folders[i];
        //        ulong sum = 0;
        //        if (folder.UnpackedStreams.Length == 0)
        //        {
        //            continue;
        //        }
        //        if (prop == HeaderProperty.kSize)
        //        {
        //            for (int j = 1; j < folder.UnpackedStreams.Length; j++)
        //            {
        //                ulong size = headerBytes.ReadEncodedInt64();
        //                info.UnpackedStreams[si].UnpackedSize = size;
        //                sum += size;
        //                si++;
        //            }
        //        }
        //        info.UnpackedStreams[si].UnpackedSize = folder.GetUnpackSize() - sum;
        //        si++;
        //    }
        //    if (prop == HeaderProperty.kSize)
        //    {
        //        prop = headerBytes.ReadProperty();
        //    }

        //    int numDigests = 0;
        //    foreach (var folder in info.Folders)
        //    {
        //        if (folder.UnpackedStreams.Length != 1 || !folder.UnpackCRC.HasValue)
        //        {
        //            numDigests += folder.UnpackedStreams.Length;
        //        }
        //    }

        //    si = 0;
        //    while (true)
        //    {
        //        if (prop == HeaderProperty.kCRC)
        //        {
        //            int digestIndex = 0;
        //            uint?[] digests2;
        //            UnPackDigests(headerBytes, numDigests, out digests2);
        //            for (uint i = 0; i < info.Folders.Length; i++)
        //            {
        //                Folder folder = info.Folders[i];
        //                if (folder.UnpackedStreams.Length == 1 && folder.UnpackCRC.HasValue)
        //                {
        //                    info.UnpackedStreams[si].Digest = folder.UnpackCRC;
        //                    si++;
        //                }
        //                else
        //                {
        //                    for (uint j = 0; j < folder.UnpackedStreams.Length; j++, digestIndex++)
        //                    {
        //                        info.UnpackedStreams[si].Digest = digests2[digestIndex];
        //                        si++;
        //                    }
        //                }
        //            }
        //        }
        //        else if (prop == HeaderProperty.kEnd)
        //            return;
        //        prop = headerBytes.ReadProperty();
        //    }
        //}

        private void ReadUnPackInfo(StreamsInfo info, Stream stream)
        {
            var prop = (HeaderProperty)stream.ReadByte();
            if (prop != HeaderProperty.kFolder) return;

            // 目录个数
            var count = stream.ReadEncodedInt64();

            var list = new List<Folder>();
            if (stream.ReadByte() != 0) throw new NotSupportedException("External flag");

            for (int i = 0; i < count; i++)
            {
                var fd = new Folder();
                fd.Read(stream);
                list.Add(fd);
            }

            prop = (HeaderProperty)stream.ReadByte();
            if (prop != HeaderProperty.kCodersUnpackSize) throw new Exception("Expected Size Property");

            var numOutStreams = list.Sum(e => e.Coders == null ? 0 : e.Coders.Length);
            info.CoderUnpackSizes = new Int64[numOutStreams];
            for (uint j = 0; j < numOutStreams; j++)
            {
                info.CoderUnpackSizes[j] = stream.ReadEncodedInt64();
            }

            prop = (HeaderProperty)stream.ReadByte();
            if (prop != HeaderProperty.kCRC) return;

            var crcs = new UInt32[list.Count];
            //UnPackDigests(stream, list.Count, out crcs);
            for (int i = 0; i < list.Count; i++)
            {
                list[i].UnpackCRC = crcs[i];
            }

            prop = (HeaderProperty)stream.ReadByte();
            if (prop != HeaderProperty.kEnd) throw new Exception("Expected End property");

            //return list;
        }

        //private static void UnPackDigests(Stream stream, int numItems, out uint[] digests)
        //{
        //    // 读取一个字节，分割多个位
        //    var digestsDefined = headerBytes.ReadBoolFlagsDefaultTrue(numItems);
        //    digests = new uint?[numItems];
        //    for (int i = 0; i < numItems; i++)
        //    {
        //        if (digestsDefined[i])
        //        {
        //            digests[i] = headerBytes.ReadUInt32();
        //        }
        //    }
        //}

        //private Folder ReadFolder(HeaderBuffer headerBytes)
        //{
        //    Folder folder = new Folder(this);
        //    folder.Coders = headerBytes.CreateArray<CodersInfo>();

        //    int numInStreams = 0;
        //    int numOutStreams = 0;

        //    foreach (var coder in folder.Coders)
        //    {
        //        byte mainByte = headerBytes.ReadByte();
        //        int size = (byte)(mainByte & 0xF);
        //        coder.Method = headerBytes.ReadBytes(size);
        //        if ((mainByte & 0x10) != 0)
        //        {
        //            coder.NumberOfInStreams = headerBytes.ReadEncodedInt64();
        //            coder.NumberOfOutStreams = headerBytes.ReadEncodedInt64();
        //        }
        //        else
        //        {
        //            coder.NumberOfInStreams = 1;
        //            coder.NumberOfOutStreams = 1;
        //        }
        //        if ((mainByte & 0x20) != 0)
        //        {
        //            ulong propertiesSize = headerBytes.ReadEncodedInt64();
        //            coder.Properties = headerBytes.ReadBytes((int)propertiesSize);
        //        }
        //        while ((mainByte & 0x80) != 0)
        //        {
        //            mainByte = headerBytes.ReadByte();
        //            headerBytes.ReadBytes(mainByte & 0xF);
        //            if ((mainByte & 0x10) != 0)
        //            {
        //                headerBytes.ReadEncodedInt64();
        //                headerBytes.ReadEncodedInt64();
        //            }
        //            if ((mainByte & 0x20) != 0)
        //            {
        //                ulong propertiesSize = headerBytes.ReadEncodedInt64();
        //                headerBytes.ReadBytes((int)propertiesSize);
        //            }
        //        }
        //        numInStreams += (int)coder.NumberOfInStreams;
        //        numOutStreams += (int)coder.NumberOfOutStreams;
        //    }

        //    int numBindPairs = numOutStreams - 1;
        //    folder.BindPairs = new BindPair[numBindPairs];

        //    for (int i = 0; i < numBindPairs; i++)
        //    {
        //        BindPair bindpair = new BindPair();
        //        folder.BindPairs[i] = bindpair;
        //        bindpair.InIndex = headerBytes.ReadEncodedInt64();
        //        bindpair.OutIndex = headerBytes.ReadEncodedInt64();
        //    }


        //    int numPackedStreams = numInStreams - numBindPairs;

        //    folder.PackedStreamIndices = new ulong[numPackedStreams];

        //    if (numPackedStreams == 1)
        //    {
        //        uint pi = 0;
        //        for (uint j = 0; j < numInStreams; j++)
        //        {
        //            if (!folder.BindPairs.Where(x => x.InIndex == j).Any())
        //            {
        //                folder.PackedStreamIndices[pi++] = j;
        //                break;
        //            }
        //        }
        //    }
        //    else
        //    {
        //        for (uint i = 0; i < numPackedStreams; i++)
        //        {
        //            folder.PackedStreamIndices[i] = headerBytes.ReadEncodedInt64();
        //        }
        //    }
        //    return folder;
        //}

        private static void ReadPackInfo(StreamsInfo info, Stream stream)
        {
            var reader = new BinaryReader(stream);

            info.PackPosition = stream.ReadEncodedInt64();
            int count = (int)stream.ReadEncodedInt64();

            for (int i = 0; i < count; i++)
            {
                info.PackedStreams.Add(new PackedStreamInfo());
            }
            var prop = (HeaderProperty)stream.ReadByte();
            if (prop != HeaderProperty.kSize) throw new Exception("Expected Size Property");

            for (int i = 0; i < count; i++)
            {
                info.PackedStreams[i].PackedSize = stream.ReadEncodedInt64();

            }
            for (int i = 0; i < count; i++)
            {
                prop = (HeaderProperty)stream.ReadByte();
                if (prop != HeaderProperty.kCRC) break;

                info.PackedStreams[i].Crc = stream.ReadEncodedInt64();
            }
        }
        #endregion

        #region 写入
        /// <summary>把Zip格式数据写入到数据流中</summary>
        /// <param name="stream"></param>
        public void Write(Stream stream)
        {
            if (stream == null) throw new ArgumentNullException("stream");

            //writer.Flush();
        }

        /// <summary>把Zip格式数据写入到文件中</summary>
        /// <param name="fileName"></param>
        public void Write(String fileName)
        {
            if (String.IsNullOrEmpty(fileName)) throw new ArgumentNullException("fileName");

            //// 根据文件后缀决定采用的压缩算法
            //var method = CompressionMethod.Stored;
            //var ext = Path.GetExtension(fileName);
            //if (ext == ".7z" || ext == ".lzma")
            //    method = CompressionMethod.LZMA;
            //else
            //    method = CompressionMethod.Deflated;

            //if (method != CompressionMethod.Stored)
            //{
            //    foreach (var item in Entries.Values)
            //    {
            //        item.CompressionMethod = method;
            //    }
            //}

            using (var fs = File.Create(fileName))
            {
                Write(fs);
            }
        }
        #endregion

        #region 内部
        class StreamsInfo
        {
            public Int64 Offset { get; set; }
            public Int64 PackPosition { get; set; }

            private List<PackedStreamInfo> _PackedStreams = new List<PackedStreamInfo>();
            /// <summary>属性说明</summary>
            public List<PackedStreamInfo> PackedStreams { get { return _PackedStreams; } set { _PackedStreams = value; } }

            private Int64[] _CoderUnpackSizes;
            /// <summary>属性说明</summary>
            public Int64[] CoderUnpackSizes { get { return _CoderUnpackSizes; } set { _CoderUnpackSizes = value; } }
        }

        class PackedStreamInfo
        {
            public Int64 PackedSize { get; set; }
            public Int64 Crc { get; set; }
        }

        class Folder
        {
            private Int32[] _Coders;
            /// <summary>属性说明</summary>
            public Int32[] Coders { get { return _Coders; } set { _Coders = value; } }

            private UInt64[] _UnpackedStreamSizes;
            /// <summary>属性说明</summary>
            public UInt64[] UnpackedStreamSizes { get { return _UnpackedStreamSizes; } set { _UnpackedStreamSizes = value; } }

            private UInt32 _UnpackCRC;
            /// <summary>属性说明</summary>
            public UInt32 UnpackCRC { get { return _UnpackCRC; } set { _UnpackCRC = value; } }

            public Boolean Read(Stream stream)
            {
                var count = stream.ReadEncodedInt64();
                Coders = new Int32[count];

                var numInStreams = 0;
                for (int i = 0; i < count; i++)
                {
                    Byte mainByte = (Byte)stream.ReadByte();
                    if ((mainByte & 0xC0) != 0) throw new Exception("Unsupported");

                    Int32 idSize = (mainByte & 0xF);
                    if (idSize > 8) throw new Exception("Unsupported");
                    if (idSize > stream.Length - stream.Position) throw new Exception("EndOfData");

                    //const Byte* longID = inByte->GetPtr();
                    //UInt64 id = 0;
                    //for (Int32 j = 0; j < idSize; j++)
                    //    id = ((id << 8) | longID[j]);
                    //var id = stream.ReadEncodedInt64();
                    var id = stream.ReadBytes(idSize).ToUInt32(0, false);
                    //inByte->SkipDataNoCheck(idSize);
                    //stream.Seek(idSize, SeekOrigin.Current);
                    //if (folders.ParsedMethods.IDs.Size() < 128)
                    //    folders.ParsedMethods.IDs.AddToUniqueSorted(id);

                    var coderInStreams = 1;
                    if ((mainByte & 0x10) != 0)
                    {
                        coderInStreams = stream.ReadByte();
                        if (coderInStreams > 64) throw new Exception("Unsupported");
                        if (stream.ReadByte() != 1) throw new Exception("Unsupported");
                    }
                    Coders[i] = coderInStreams;

                    numInStreams += coderInStreams;
                    if (numInStreams > 64) throw new Exception("Unsupported");

                    if ((mainByte & 0x20) != 0)
                    {
                        var propsSize = stream.ReadByte();
                        if (propsSize > stream.Length - stream.Position) throw new Exception("EndOfData");
                        const Int32 k_LZMA2 = 0x21000000;
                        const Int32 k_LZMA = 0x3010100;
                        if (id == k_LZMA2 && propsSize == 1)
                        {
                            //Byte v = *_inByteBack->GetPtr();
                            //if (folders.ParsedMethods.Lzma2Prop < v)
                            //    folders.ParsedMethods.Lzma2Prop = v;
                        }
                        else if (id == k_LZMA && propsSize == 5)
                        {
                            //UInt32 dicSize = GetUi32(_inByteBack->GetPtr() + 1);
                            //if (folders.ParsedMethods.LzmaDic < dicSize)
                            //    folders.ParsedMethods.LzmaDic = dicSize;
                        }
                        //inByte->SkipDataNoCheck((size_t)propsSize);
                        stream.Seek(propsSize, SeekOrigin.Current);
                    }
                }

                if (count == 1 && numInStreams == 1)
                {
                    //indexOfMainStream = 0;
                    //numPackStreams = 1;
                }
                else
                {
                    UInt32 i;
                    var numBonds = count - 1;
                    if (numInStreams < numBonds) throw new Exception("Unsupported");

                    //BoolVector_Fill_False(StreamUsed, numInStreams);
                    //BoolVector_Fill_False(CoderUsed, count);
                    var StreamUsed = new Boolean[numInStreams];
                    var CoderUsed = new Boolean[count];

                    for (i = 0; i < numBonds; i++)
                    {
                        var index = stream.ReadByte();
                        if (index >= numInStreams || StreamUsed[index]) throw new Exception("Unsupported");

                        StreamUsed[index] = true;

                        index = stream.ReadByte();
                        if (index >= count || CoderUsed[index]) throw new Exception("Unsupported");
                        CoderUsed[index] = true;
                    }

                    var numPackStreams = numInStreams - numBonds;

                    if (numPackStreams != 1)
                        for (i = 0; i < numPackStreams; i++)
                        {
                            var index = stream.ReadByte();
                            if (index >= numInStreams || StreamUsed[index]) throw new Exception("Unsupported");
                            StreamUsed[index] = true;
                        }

                    for (i = 0; i < count; i++)
                        if (!CoderUsed[i])
                        {
                            //indexOfMainStream = i;
                            break;
                        }

                    if (i == count) throw new Exception("Unsupported");
                }

                //folders.FoToCoderUnpackSizes[fo] = numCodersOutStreams;
                //numCodersOutStreams += count;
                //folders.FoStartPackStreamIndex[fo] = packStreamIndex;
                //packStreamIndex += numPackStreams;
                //folders.FoToMainUnpackSizeIndex[fo] = (Byte)indexOfMainStream;

                return true;
            }
        }
        #endregion
    }

    /// <summary>
    /// Class to pack data into archives supported by 7-Zip.
    /// </summary>
    /// <example>
    /// var compr = new SevenZipCompressor();
    /// compr.CompressDirectory(@"C:\Dir", @"C:\Archive.7z");
    /// </example>
    public sealed partial class SevenZipCompressor
    {
        private static volatile int _lzmaDictionarySize = 1 << 22;

        /// <summary>
        /// Checks if the specified stream supports compression.
        /// </summary>
        /// <param name="stream">The stream to check.</param>
        private static void ValidateStream(Stream stream)
        {
            if (!stream.CanWrite || !stream.CanSeek)
            {
                throw new ArgumentException("The specified stream can not seek or is not writable.", "stream");
            }
        }

        /// <summary>
        /// Gets or sets the dictionary size for the managed LZMA algorithm.
        /// </summary>
        public static int LzmaDictionarySize { get { return _lzmaDictionarySize; } set { _lzmaDictionarySize = value; } }

        internal static void WriteLzmaProperties(LzmaEncoder encoder)
        {
            #region LZMA properties definition

            CoderPropID[] propIDs =          
            {
                    CoderPropID.DictionarySize,
                    CoderPropID.PosStateBits,
                    CoderPropID.LitContextBits,
                    CoderPropID.LitPosBits,
                    CoderPropID.Algorithm,
                    CoderPropID.NumFastBytes,
                    CoderPropID.MatchFinder,
                    CoderPropID.EndMarker
                };
            object[] properties =
            {
                    _lzmaDictionarySize,
                    2,
                    3,
                    0,
                    2,
                    256,
                    "bt4",
                    false
                };

            #endregion

            encoder.SetCoderProperties(propIDs, properties);
        }

        /// <summary>
        /// Compresses the specified stream with LZMA algorithm (C# inside)
        /// </summary>
        /// <param name="inStream">The source uncompressed stream</param>
        /// <param name="outStream">The destination compressed stream</param>
        /// <param name="inLength">The length of uncompressed data (null for inStream.Length)</param>
        /// <param name="codeProgressEvent">The event for handling the code progress</param>
        public static void CompressStream(Stream inStream, Stream outStream, int? inLength)
        {
            if (!inStream.CanRead || !outStream.CanWrite)
            {
                throw new ArgumentException("The specified streams are invalid.");
            }
            var encoder = new LzmaEncoder();
            WriteLzmaProperties(encoder);
            encoder.WriteCoderProperties(outStream);
            long streamSize = inLength.HasValue ? inLength.Value : inStream.Length;
            for (int i = 0; i < 8; i++)
            {
                outStream.WriteByte((byte)(streamSize >> (8 * i)));
            }
            encoder.Code(inStream, outStream, -1, -1, null);
        }

        /// <summary>
        /// Compresses byte array with LZMA algorithm (C# inside)
        /// </summary>
        /// <param name="data">Byte array to compress</param>
        /// <returns>Compressed byte array</returns>
        public static byte[] CompressBytes(byte[] data)
        {
            using (var inStream = new MemoryStream(data))
            {
                using (var outStream = new MemoryStream())
                {
                    var encoder = new LzmaEncoder();
                    WriteLzmaProperties(encoder);
                    encoder.WriteCoderProperties(outStream);
                    long streamSize = inStream.Length;
                    for (int i = 0; i < 8; i++)
                        outStream.WriteByte((byte)(streamSize >> (8 * i)));
                    encoder.Code(inStream, outStream, -1, -1, null);
                    return outStream.ToArray();
                }
            }
        }
    }

    enum HeaderProperty
    {
        kEnd,

        kHeader,

        kArchiveProperties,

        kAdditionalStreamsInfo,
        kMainStreamsInfo,
        kFilesInfo,

        kPackInfo,
        kUnpackInfo,
        kSubStreamsInfo,

        kSize,
        kCRC,

        kFolder,

        kCodersUnpackSize,
        kNumUnpackStream,

        kEmptyStream,
        kEmptyFile,
        kAnti,

        kName,
        kCTime,
        kATime,
        kMTime,
        kWinAttrib,
        kComment,

        kEncodedHeader,

        kStartPos,
        kDummy

        // kNtSecure,
        // kParent,
        // kIsAux
    };

}