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
    {
        private void WriteHeader()
        {
            this.FileStorage.Position = 0;
            WriteHeader(this.Writer, this.Header);
        }

        private static void WriteHeader(BinaryWriter writer, FileHeader header)
        {
            // header size is 512 bytes
            writer.Write(header.FileTypeIdentifier);
            writer.Write(header.FileIdentifier.ToByteArray());
            writer.Write(header.RevisionNumber);
            writer.Write(header.VersionNumber);
            writer.Write(header.ByteOrderMark);
            writer.Write(header.SectorSizeInPot);
            writer.Write(header.ShortSectorSizeInPot);
            writer.Write(header.UnUsed10);
            writer.Write(header.NumberOfSATSectors);
            writer.Write(header.FirstSectorIDofDirectoryStream);
            writer.Write(header.UnUsed4);
            writer.Write(header.MinimumStreamSize);
            writer.Write(header.FirstSectorIDofShortSectorAllocationTable);
            writer.Write(header.NumberOfShortSectors);
            writer.Write(header.FirstSectorIDofMasterSectorAllocationTable);
            writer.Write(header.NumberOfMasterSectors);
            WriteArrayOfInt32(writer, header.MasterSectorAllocationTable);
        }

        private static void WriteDirectoryEntry(BinaryWriter writer, DirectoryEntry entry)
        {
            writer.Write(entry.NameBuffer);
            writer.Write(entry.NameDataSize);
            writer.Write(entry.EntryType);
            writer.Write(entry.NodeColor);
            writer.Write(entry.LeftChildDID);
            writer.Write(entry.RightChildDID);
            writer.Write(entry.MembersTreeNodeDID);
            writer.Write(entry.UniqueIdentifier.ToByteArray());
            writer.Write(entry.UserFlags);
            writer.Write(entry.CreationTime.ToFileTime());
            writer.Write(entry.LastModificationTime.ToFileTime());
            writer.Write(entry.FirstSectorID);
            writer.Write(entry.StreamLength);
            writer.Write(entry.UnUsed);
        }

        //void WriteMasterSectorAllocationTable(BinaryWriter writer)
        //{
        //    int extraIDcount = MasterSectorAllocationTable.Count - Header.MasterSectorAllocationTable.Length;
        //    if (extraIDcount <= 0)
        //    {
        //        Header.FirstSectorIDofMasterSectorAllocationTable = SID.EOC;
        //        for (int i = 0; i < MasterSectorAllocationTable.Count; i++)
        //        {
        //            Header.MasterSectorAllocationTable[i] = MasterSectorAllocationTable[i];
        //        }
        //    }
        //    else
        //    {
        //        Header.FirstSectorIDofMasterSectorAllocationTable = 0;
        //        for (int i = 0; i < Header.MasterSectorAllocationTable.Length; i++)
        //        {
        //            Header.MasterSectorAllocationTable[i] = MasterSectorAllocationTable[i];
        //        }
        //        int sectorIDcount = SectorSize / 4 - 1;
        //        int sectorIndex = Header.MasterSectorAllocationTable.Length;
        //        int nextSectID = 1;
        //        while (extraIDcount > sectorIDcount)
        //        {
        //            for (int i = 0; i < sectorIDcount; i++)
        //            {
        //                writer.Write(MasterSectorAllocationTable[sectorIndex]);
        //                sectorIndex++;
        //            }
        //            writer.Write(nextSectID);
        //            nextSectID++;
        //            extraIDcount -= sectorIDcount;
        //        }
        //        for (int i = 0; i < extraIDcount; i++)
        //        {
        //            writer.Write(MasterSectorAllocationTable[sectorIndex]);
        //            sectorIndex++;
        //        }
        //        for (int i = 0; i < sectorIDcount - extraIDcount; i++)
        //        {
        //            writer.Write(-1);
        //        }
        //        writer.Write(SID.EOC);
        //    }
        //}

        public void WriteStreamData(string[] streamPath, byte[] data)
        {
            DirectoryEntry entry = GetOrCreateDirectoryEntry(streamPath);
            entry.EntryType = EntryType.Stream;
            entry.StreamLength = data.Length;
            if (entry.StreamLength < Header.MinimumStreamSize)
            {
                if (entry.FirstSectorID == SID.EOC)
                {
                    entry.FirstSectorID = AllocateShortSector();
                }
                WriteShortStreamData(entry.FirstSectorID, data);
            }
            else
            {
                if (entry.FirstSectorID == SID.EOC)
                {
                    entry.FirstSectorID = AllocateDataSector();
                }
                WriteStreamData(entry.FirstSectorID, data);
            }
        }

        internal void WriteStreamData(int startSID, byte[] data)
        {
            int prev_sid = SID.EOC;
            int sid = startSID;
            int index = 0;
            while (index < data.Length)
            {
                if (sid == SID.EOC)
                {
                    if (prev_sid == SID.EOC)
                    {
                        sid = this.AllocateDataSector();
                    }
                    else
                    {
                        sid = this.AllocateDataSectorAfter(prev_sid);
                    }
                }
                int offset = GetSectorOffset(sid);
                Writer.BaseStream.Position = offset;
                if (index + SectorSize < data.Length)
                {
                    Writer.Write(data, index, SectorSize);
                }
                else
                {
                    Writer.Write(data, index, data.Length - index);
                }
                index += SectorSize;
                prev_sid = sid;
                sid = this.SectorAllocation.GetNextSectorID(prev_sid);
            }
            if (sid != SID.EOC && prev_sid != SID.EOC)
            {
                SectorAllocation.LinkSectorID(prev_sid, SID.EOC);
                while (sid != SID.EOC)
                {
                    int next_sid = SectorAllocation.GetNextSectorID(sid);
                    SectorAllocation.LinkSectorID(sid, SID.Free);
                    sid = next_sid;
                }
            }
        }

        private void AppendStreamData(int startSID, int streamLength, byte[] data)
        {
            int sid = startSID;
            int next_sid = SectorAllocation.GetNextSectorID(sid);
            int index = 0;
            while (next_sid != SID.EOC)
            {
                sid = next_sid;
                next_sid = SectorAllocation.GetNextSectorID(sid);
                index += SectorSize;
            }
            if (index < streamLength)
            {
                int position = streamLength - index;
                int length = SectorSize - position;
                if (data.Length <= length)
                {
                    WriteInSector(sid, position, data, 0, data.Length);
                }
                else
                {
                    WriteInSector(sid, position, data, 0, length);
                    next_sid = AllocateDataSectorAfter(sid);
                    byte[] remained_data = new byte[data.Length - length];
                    Array.Copy(data, length, remained_data, 0, remained_data.Length);
                    WriteStreamData(next_sid, remained_data);
                }
            }
            else
            {
                next_sid = AllocateDataSectorAfter(sid);
                WriteStreamData(next_sid, data);
            }
        }

        internal void WriteShortStreamData(int startSID, byte[] data)
        {
            int prev_sid = SID.EOC;
            int sid = startSID;
            int index = 0;
            while (index < data.Length)
            {
                if (sid == SID.EOC)
                {
                    if (prev_sid == SID.EOC)
                    {
                        sid = this.ShortSectorAllocation.AllocateSector();
                    }
                    else
                    {
                        sid = this.ShortSectorAllocation.AllocateSectorAfter(prev_sid);
                    }
                }
                int offset = GetShortSectorOffset(sid);
                ShortStreamContainer.Position = offset;
                if (index + ShortSectorSize < data.Length)
                {
                    ShortStreamContainer.Write(data, index, ShortSectorSize);
                }
                else
                {
                    ShortStreamContainer.Write(data, index, data.Length - index);
                }
                index += ShortSectorSize;
                prev_sid = sid;
                sid = this.ShortSectorAllocation.GetNextSectorID(prev_sid);
            }
            if (sid != SID.EOC && prev_sid != SID.EOC)
            {
                ShortSectorAllocation.LinkSectorID(prev_sid, SID.EOC);
                while (sid != SID.EOC)
                {
                    int next_sid = ShortSectorAllocation.GetNextSectorID(sid);
                    ShortSectorAllocation.LinkSectorID(sid, SID.Free);
                    sid = next_sid;
                }
            }
        }

        private DirectoryEntry GetOrCreateDirectoryEntry(string[] streamPath)
        {
            DirectoryEntry entry = this.RootStorage;
            foreach (string entryName in streamPath)
            {
                if (!entry.Members.ContainsKey(entryName))
                {
                    DirectoryEntry newEntry = new DirectoryEntry(this, entryName);
                    newEntry.ID = this.DirectoryEntries.Count;
                    this.DirectoryEntries.Add(newEntry.ID, newEntry);
                    entry.AddChild(newEntry);
                }
                entry = entry.Members[entryName];
            }
            return entry;
        }

        public void DeleteDirectoryEntry(string[] streamPath)
        {
            DirectoryEntry entry = GetOrCreateDirectoryEntry(streamPath);
            DeleteDirectoryEntry(entry);
        }

        public void DeleteDirectoryEntry(DirectoryEntry entry)
        {
            entry.EntryType = EntryType.Empty;
            entry.StreamLength = 0;
            entry.Parent.Members.Remove(entry.Name);
        }
    }
}