/* ====================================================================
   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for Additional information regarding copyright ownership.
   The ASF licenses this file to You under the Apache License, Version 2.0
   (the "License"); you may not use this file except in compliance with
   the License.  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
==================================================================== */


namespace HH.WMS.Utils.NPOI.DDF
{
    using System;
    using System.Text;
    using System.Collections;
    using HH.WMS.Utils.NPOI.Util;
    using System.IO;
    using HH.WMS.Utils.NPOI.HSSF.Record;
    using HH.WMS.Utils.Ionic.Zlib;


    /// <summary>
    /// The blip record is used to hold details about large binary objects that occur in escher such
    /// as JPEG, GIF, PICT and WMF files.  The contents of the stream is usually compressed.  Inflate
    /// can be used to decompress the data.
    /// @author Glen Stampoultzis
    /// </summary>
    public class EscherBlipWMFRecord : EscherBlipRecord
    {
        //    public static short  RECORD_ID_START    = (short) 0xF018;
        //    public static short  RECORD_ID_END      = (short) 0xF117;
        public new const String RECORD_DESCRIPTION = "msofbtBlip";
        private const int HEADER_SIZE = 8;

        private byte[] field_1_secondaryUID;
        private int field_2_cacheOfSize;
        private int field_3_boundaryTop;
        private int field_4_boundaryLeft;
        private int field_5_boundaryWidth;
        private int field_6_boundaryHeight;
        private int field_7_width;
        private int field_8_height;
        private int field_9_cacheOfSavedSize;
        private byte field_10_compressionFlag;
        private byte field_11_filter;
        private byte[] field_12_data;


        /// <summary>
        /// This method deserializes the record from a byte array.
        /// </summary>
        /// <param name="data">The byte array containing the escher record information</param>
        /// <param name="offset">The starting offset into</param>
        /// <param name="recordFactory">May be null since this is not a container record.</param>
        /// <returns>
        /// The number of bytes Read from the byte array.
        /// </returns>
        public override int FillFields(byte[] data, int offset,
                                  EscherRecordFactory recordFactory
                                  )
        {
            int bytesAfterHeader = ReadHeader(data, offset);
            int pos = offset + HEADER_SIZE;

            int size = 0;
            field_1_secondaryUID = new byte[16];
            Array.Copy(data, pos + size, field_1_secondaryUID, 0, 16); size += 16;
            field_2_cacheOfSize = LittleEndian.GetInt(data, pos + size); size += 4;
            field_3_boundaryTop = LittleEndian.GetInt(data, pos + size); size += 4;
            field_4_boundaryLeft = LittleEndian.GetInt(data, pos + size); size += 4;
            field_5_boundaryWidth = LittleEndian.GetInt(data, pos + size); size += 4;
            field_6_boundaryHeight = LittleEndian.GetInt(data, pos + size); size += 4;
            field_7_width = LittleEndian.GetInt(data, pos + size); size += 4;
            field_8_height = LittleEndian.GetInt(data, pos + size); size += 4;
            field_9_cacheOfSavedSize = LittleEndian.GetInt(data, pos + size); size += 4;
            field_10_compressionFlag = data[pos + size]; size++;
            field_11_filter = data[pos + size]; size++;

            int bytesRemaining = bytesAfterHeader - size;
            field_12_data = new byte[bytesRemaining];
            Array.Copy(data, pos + size, field_12_data, 0, bytesRemaining);
            size += bytesRemaining;

            return HEADER_SIZE + size;
        }


        /// <summary>
        /// This method Serializes this escher record into a byte array.
        /// @param offset   
        /// </summary>
        /// <param name="offset">The offset into data to start writing the record data to.</param>
        /// <param name="data">the data array to Serialize to</param>
        /// <param name="listener">a listener for begin and end serialization events.</param>
        /// <returns>the number of bytes written.</returns>
        public override int Serialize(int offset, byte[] data, EscherSerializationListener listener)
        {
            listener.BeforeRecordSerialize(offset, RecordId, this);

            LittleEndian.PutShort(data, offset, Options);
            LittleEndian.PutShort(data, offset + 2, RecordId);
            int remainingBytes = field_12_data.Length + 36;
            LittleEndian.PutInt(data, offset + 4, remainingBytes);

            int pos = offset + HEADER_SIZE;
            Array.Copy(field_1_secondaryUID, 0, data, pos, 16); pos += 16;
            LittleEndian.PutInt(data, pos, field_2_cacheOfSize); pos += 4;
            LittleEndian.PutInt(data, pos, field_3_boundaryTop); pos += 4;
            LittleEndian.PutInt(data, pos, field_4_boundaryLeft); pos += 4;
            LittleEndian.PutInt(data, pos, field_5_boundaryWidth); pos += 4;
            LittleEndian.PutInt(data, pos, field_6_boundaryHeight); pos += 4;
            LittleEndian.PutInt(data, pos, field_7_width); pos += 4;
            LittleEndian.PutInt(data, pos, field_8_height); pos += 4;
            LittleEndian.PutInt(data, pos, field_9_cacheOfSavedSize); pos += 4;
            data[pos++] = field_10_compressionFlag;
            data[pos++] = field_11_filter;
            Array.Copy(field_12_data, 0, data, pos, field_12_data.Length); pos += field_12_data.Length;

            listener.AfterRecordSerialize(pos, RecordId, pos - offset, this);
            return pos - offset;
        }

        /// <summary>
        /// Returns the number of bytes that are required to Serialize this record.
        /// </summary>
        /// <value>Number of bytes</value>
        public override int RecordSize
        {
            get { return 58 + field_12_data.Length; }
        }

        /// <summary>
        /// The short name for this record
        /// </summary>
        /// <value></value>
        public override String RecordName
        {
            get { return "Blip"; }
        }

        /// <summary>
        /// Gets or sets the secondary UID.
        /// </summary>
        /// <value>The secondary UID.</value>
        public byte[] SecondaryUID
        {
            get { return field_1_secondaryUID; }
            set { this.field_1_secondaryUID = value; }
        }


        /// <summary>
        /// Gets or sets the size of the cache of.
        /// </summary>
        /// <value>The size of the cache of.</value>
        public int CacheOfSize
        {
            get { return field_2_cacheOfSize; }
            set { this.field_2_cacheOfSize = value; }
        }

        /// <summary>
        /// Gets or sets the top boundary of the metafile drawing commands
        /// </summary>
        /// <value>The boundary top.</value>
        public int BoundaryTop
        {
            get { return field_3_boundaryTop; }
            set { this.field_3_boundaryTop = value; }
        }

        /// <summary>
        /// Gets or sets the left boundary of the metafile drawing commands
        /// </summary>
        /// <value>The boundary left.</value>
        public int BoundaryLeft
        {
            get { return field_4_boundaryLeft; }
            set { this.field_4_boundaryLeft = value; }
        }


        /// <summary>
        /// Gets or sets the boundary width of the metafile drawing commands
        /// </summary>
        /// <value>The width of the boundary.</value>
        public int BoundaryWidth
        {
            get { return field_5_boundaryWidth; }
            set { this.field_5_boundaryWidth = value; }
        }


        /// <summary>
        /// Gets or sets the boundary height of the metafile drawing commands
        /// </summary>
        /// <value>The height of the boundary.</value>
        public int BoundaryHeight
        {
            get { return field_6_boundaryHeight; }
            set { this.field_6_boundaryHeight = value; }
        }

        /// <summary>
        /// Gets or sets the width of the metafile in EMU's (English Metric Units).
        /// </summary>
        /// <value>The width.</value>
        public int Width
        {
            get { return field_7_width; }
            set { this.field_7_width = value; }
        }

        /// <summary>
        /// Gets or sets the height of the metafile in EMU's (English Metric Units).
        /// </summary>
        /// <value>The height.</value>
        public int Height
        {
            get { return field_8_height; }
            set { this.field_8_height = value; }
        }

        /// <summary>
        /// Gets or sets the cache of the saved size
        /// </summary>
        /// <value>the cache of the saved size.</value>
        public int CacheOfSavedSize
        {
            get{return field_9_cacheOfSavedSize;}
            set { this.field_9_cacheOfSavedSize = value; }
        }

        /// <summary>
        /// Is the contents of the blip compressed?
        /// </summary>
        /// <value>The compression flag.</value>
        public byte CompressionFlag
        {
            get { return field_10_compressionFlag; }
            set { this.field_10_compressionFlag = value; }
        }

        /// <summary>
        /// Gets or sets the filter.
        /// </summary>
        /// <value>The filter.</value>
        public byte Filter
        {
            get { return field_11_filter; }
            set { this.field_11_filter = value; }
        }

        /// <summary>
        /// Gets or sets The BLIP data
        /// </summary>
        /// <value>The data.</value>
        public byte[] Data
        {
            get { return field_12_data; }
            set { this.field_12_data = value; }
        }


        /// <summary>
        /// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
        /// </summary>
        /// <returns>
        /// A <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
        /// </returns>
        public override String ToString()
        {
            String nl = Environment.NewLine;

            String extraData;
            using (MemoryStream b = new MemoryStream())
            {
                try
                {
                    HexDump.Dump(this.field_12_data, 0, b, 0);
                    extraData = b.ToString();
                }
                catch (Exception e)
                {
                    extraData = e.ToString();
                }
                return GetType().Name + ":" + nl +
                        "  RecordId: 0x" + HexDump.ToHex(RecordId) + nl +
                        "  Options: 0x" + HexDump.ToHex(Options) + nl +
                        "  Secondary UID: " + HexDump.ToHex(field_1_secondaryUID) + nl +
                        "  CacheOfSize: " + field_2_cacheOfSize + nl +
                        "  BoundaryTop: " + field_3_boundaryTop + nl +
                        "  BoundaryLeft: " + field_4_boundaryLeft + nl +
                        "  BoundaryWidth: " + field_5_boundaryWidth + nl +
                        "  BoundaryHeight: " + field_6_boundaryHeight + nl +
                        "  X: " + field_7_width + nl +
                        "  Y: " + field_8_height + nl +
                        "  CacheOfSavedSize: " + field_9_cacheOfSavedSize + nl +
                        "  CompressionFlag: " + field_10_compressionFlag + nl +
                        "  Filter: " + field_11_filter + nl;
                //"  Data:" + nl + extraData;
            }
        }

        /// <summary>
        /// Compress the contents of the provided array
        /// </summary>
        /// <param name="data">An uncompressed byte array</param>
        /// <returns></returns>
        public static byte[] Compress(byte[] data)
        {
            using (MemoryStream out1 = new MemoryStream())
            {
                ZlibStream deflaterOutputStream = new ZlibStream(out1, CompressionMode.Compress);
                try
                {
                    //for (int i = 0; i < data.Length; i++)
                    //deflaterOutputStream.WriteByte(data[i]);
                    deflaterOutputStream.Write(data, 0, data.Length);   //Tony Qu changed the code
                    return out1.ToArray();
                }
                catch (IOException e)
                {
                    throw new RecordFormatException(e.ToString());
                }
                finally
                {
                    out1.Close();
                    if (deflaterOutputStream != null)
                    {
                        deflaterOutputStream.Close();
                    }
                }
            }
        }

        /// <summary>
        /// Decompresses the specified data.
        /// </summary>
        /// <param name="data">The compressed byte array.</param>
        /// <param name="pos">The starting position into the byte array.</param>
        /// <param name="Length">The number of compressed bytes to decompress.</param>
        /// <returns>An uncompressed byte array</returns>
        public static byte[] Decompress(byte[] data, int pos, int Length)
        {
            byte[] compressedData = new byte[Length];
            Array.Copy(data, pos + 50, compressedData, 0, Length);
            using (MemoryStream ms = new MemoryStream(compressedData))
            {
                using (ZlibStream inflaterInputStream = new ZlibStream(ms, CompressionMode.Decompress))
                {
                    using (MemoryStream out1 = new MemoryStream())
                    {
                        int c;
                        try
                        {
                            while ((c = inflaterInputStream.ReadByte()) != -1)
                                out1.WriteByte((byte)c);
                            return out1.ToArray();
                        }
                        catch (IOException e)
                        {
                            throw new RecordFormatException(e.ToString());
                        }
                    }
                }
            }
        }

    }
}