using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using QiHe.CodeLib;

namespace HH.WMS.Utils.ExcelLibrary.CompoundDocumentFormat
{
    public partial class CompoundDocument
    {
        public static CompoundDocument Load(string file)
        {
            CompoundDocument doc = CompoundDocument.Open(file);
            doc.ReadAllStreamData();
            doc.Close();
            return doc;
        }

        public static CompoundDocument Load(Stream stream)
        {
            CompoundDocument doc = CompoundDocument.Open(stream);
            doc.ReadAllStreamData();
            doc.Close();
            return doc;
        }

        private static FileHeader ReadHeader(BinaryReader reader)
        {
            FileHeader header = new FileHeader();
            header.FileTypeIdentifier = reader.ReadBytes(8);
            header.FileIdentifier = new Guid(reader.ReadBytes(16));
            header.RevisionNumber = reader.ReadUInt16();
            header.VersionNumber = reader.ReadUInt16();
            header.ByteOrderMark = reader.ReadBytes(2);
            header.SectorSizeInPot = reader.ReadUInt16();
            header.ShortSectorSizeInPot = reader.ReadUInt16();
            header.UnUsed10 = reader.ReadBytes(10);
            header.NumberOfSATSectors = reader.ReadInt32();
            header.FirstSectorIDofDirectoryStream = reader.ReadInt32();
            header.UnUsed4 = reader.ReadBytes(4);
            header.MinimumStreamSize = reader.ReadInt32();
            header.FirstSectorIDofShortSectorAllocationTable = reader.ReadInt32();
            header.NumberOfShortSectors = reader.ReadInt32();
            header.FirstSectorIDofMasterSectorAllocationTable = reader.ReadInt32();
            header.NumberOfMasterSectors = reader.ReadInt32();
            header.MasterSectorAllocationTable = ReadArrayOfInt32(reader, 109);
            return header;
        }

        private static DirectoryEntry ReadDirectoryEntry(BinaryReader reader)
        {
            DirectoryEntry entry = new DirectoryEntry();
            entry.NameBuffer = reader.ReadChars(32);
            entry.NameDataSize = reader.ReadUInt16();
            entry.EntryType = reader.ReadByte();
            entry.NodeColor = reader.ReadByte();
            entry.LeftChildDID = reader.ReadInt32();
            entry.RightChildDID = reader.ReadInt32();
            entry.MembersTreeNodeDID = reader.ReadInt32();
            entry.UniqueIdentifier = new Guid(reader.ReadBytes(16));
            entry.UserFlags = reader.ReadInt32();
            entry.CreationTime = DateTime.FromFileTime(reader.ReadInt64());
            entry.LastModificationTime = DateTime.FromFileTime(reader.ReadInt64());
            entry.FirstSectorID = reader.ReadInt32();
            entry.StreamLength = reader.ReadInt32();
            entry.UnUsed = reader.ReadInt32();
            return entry;
        }

        static bool ArrayEqual(byte[] bytes1, byte[] bytes2)
        {
            if (bytes1.Length != bytes2.Length) return false;
            for (int i = 0; i < bytes1.Length; i++)
            {
                if (bytes1[i] != bytes2[i]) return false;
            }
            return true;
        }

        private void ReadDirectoryEntries()
        {
            DirectoryStream = new MemoryStream(GetStreamDataAsBytes(Header.FirstSectorIDofDirectoryStream));
            BinaryReader reader = new BinaryReader(DirectoryStream, Encoding.Unicode);
            DirectoryEntries = new Dictionary<int, DirectoryEntry>();
            DirectoryEntry root = ReadDirectoryEntry(reader);
            root.Document = this;
            root.ID = 0;
            DirectoryEntries.Add(0, root);

            // The first sector has to be obtained from the root storage entry in the directory
            ShortStreamContainer = new MemoryStream(GetStreamDataAsBytes(root.FirstSectorID, root.StreamLength));

            ReadDirectoryEntry(reader, root.MembersTreeNodeDID, root);
        }

        private void ReadDirectoryEntry(BinaryReader reader, int DID, DirectoryEntry parent)
        {
            if (DID != -1 && !DirectoryEntries.ContainsKey(DID))
            {
                reader.BaseStream.Position = DID * 128;
                DirectoryEntry entry = ReadDirectoryEntry(reader);
                entry.Document = this;
                entry.ID = DID;
                DirectoryEntries[DID] = entry;
                parent.AddChild(entry);
                ReadDirectoryEntry(reader, entry.LeftChildDID, parent);
                ReadDirectoryEntry(reader, entry.RightChildDID, parent);
                ReadDirectoryEntry(reader, entry.MembersTreeNodeDID, entry);
            }
        }

        private void ReadAllStreamData()
        {
            foreach (DirectoryEntry entry in this.DirectoryEntries.Values)
            {
                entry.Data = GetStreamData(entry);
            }
        }

        private int GetSectorOffset(int SID)
        {
            return 512 + SectorSize * SID;
        }

        private int GetShortSectorOffset(int SSID)
        {
            return ShortSectorSize * SSID;
        }

        internal int[] ReadSectorDataAsIntegers(int SID)
        {
            int offset = GetSectorOffset(SID);
            Reader.BaseStream.Position = offset;
            return ReadArrayOfInt32(Reader, SectorSize / 4);
        }

        private byte[] ReadSectorDataAsBytes(int SID)
        {
            int offset = GetSectorOffset(SID);
            Reader.BaseStream.Position = offset;
            return Reader.ReadBytes(SectorSize);
        }

        private byte[] ReadShortSectorDataAsBytes(int SSID)
        {
            int offset = GetShortSectorOffset(SSID);
            ShortStreamContainer.Seek(offset, SeekOrigin.Begin);
            return StreamHelper.ReadBytes(ShortStreamContainer, ShortSectorSize);
        }

        private byte[] GetStreamDataAsBytes(int StartSID)
        {
            List<int> chain = SectorAllocation.GetSIDChain(StartSID);
            List<byte> data = new List<byte>();
            foreach (int sid in chain)
            {
                data.AddRange(ReadSectorDataAsBytes(sid));
            }
            return data.ToArray();
        }

        private byte[] GetStreamDataAsBytes(int StartSID, int length)
        {
            List<int> chain = SectorAllocation.GetSIDChain(StartSID);
            List<byte> data = new List<byte>();
            foreach (int sid in chain)
            {
                data.AddRange(ReadSectorDataAsBytes(sid));
            }
            if (data.Count > length)
            {
                data.RemoveRange(length, data.Count - length);
            }
            return data.ToArray();
        }

        internal List<int> GetStreamDataAsIntegers(int StartSID)
        {
            List<int> chain = SectorAllocation.GetSIDChain(StartSID);
            List<int> data = new List<int>();
            foreach (int sid in chain)
            {
                data.AddRange(ReadSectorDataAsIntegers(sid));
            }
            return data;
        }

        private byte[] GetShortStreamDataAsBytes(int StartSSID)
        {
            List<int> chain = ShortSectorAllocation.GetSIDChain(StartSSID);
            List<byte> data = new List<byte>();
            foreach (int sid in chain)
            {
                data.AddRange(ReadShortSectorDataAsBytes(sid));
            }
            return data.ToArray();
        }

        private byte[] GetShortStreamDataAsBytes(int StartSSID, int length)
        {
            List<int> chain = ShortSectorAllocation.GetSIDChain(StartSSID);
            List<byte> data = new List<byte>();
            foreach (int sid in chain)
            {
                data.AddRange(ReadShortSectorDataAsBytes(sid));
            }
            if (data.Count > length)
            {
                data.RemoveRange(length, data.Count - length);
            }
            return data.ToArray();
        }

        public byte[] GetStreamData(DirectoryEntry entry)
        {
            if (entry.EntryType == EntryType.Stream)
            {
                if (entry.StreamLength < Header.MinimumStreamSize)
                {
                    return GetShortStreamDataAsBytes(entry.FirstSectorID, entry.StreamLength);
                }
                else
                {
                    return GetStreamDataAsBytes(entry.FirstSectorID, entry.StreamLength);
                }
            }
            return null;
        }

        public DirectoryEntry FindDirectoryEntry(DirectoryEntry entry, string entryName)
        {
            if (entry.Members.ContainsKey(entryName)) return entry.Members[entryName];
            foreach (DirectoryEntry subentry in entry.Members.Values)
            {
                return FindDirectoryEntry(subentry, entryName);
            }
            return null;
        }

        public byte[] GetStreamData(string streamName)
        {
            DirectoryEntry userstream = FindDirectoryEntry(RootStorage, streamName);
            if (userstream != null)
            {
                return userstream.Data;
            }
            return null;
        }
    }
}