//

// © Copyright Henrik Ravn 2004

//

// Use, modification and distribution are subject to the Boost Software License, Version 1.0. 

// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//



using System;

using System.IO;

using System.Runtime.InteropServices;

using System.Text;





namespace DotZLib

{



    #region Internal types



    /// <summary>

    /// Defines constants for the various flush types used with zlib

    /// </summary>

    internal enum FlushTypes 

    {

        None,  Partial,  Sync,  Full,  Finish,  Block

    }



    #region ZStream structure

    // internal mapping of the zlib zstream structure for marshalling

    [StructLayoutAttribute(LayoutKind.Sequential, Pack=4, Size=0, CharSet=CharSet.Ansi)]

    internal struct ZStream

    {

        public IntPtr next_in;

        public uint avail_in;

        public uint total_in;



        public IntPtr next_out;

        public uint avail_out;

        public uint total_out;



        [MarshalAs(UnmanagedType.LPStr)]

        string msg; 

        uint state;



        uint zalloc;

        uint zfree;

        uint opaque;



        int data_type;

        public uint adler;

        uint reserved;

    }



    #endregion

    

    #endregion



    #region Public enums

    /// <summary>

    /// Defines constants for the available compression levels in zlib

    /// </summary>

    public enum CompressLevel : int

    {

        /// <summary>

        /// The default compression level with a reasonable compromise between compression and speed

        /// </summary>

        Default = -1,   

        /// <summary>

        /// No compression at all. The data are passed straight through.

        /// </summary>

        None = 0,

        /// <summary>

        /// The maximum compression rate available.

        /// </summary>

        Best = 9,   

        /// <summary>

        /// The fastest available compression level.

        /// </summary>

        Fastest = 1

    }

    #endregion



    #region Exception classes

    /// <summary>

    /// The exception that is thrown when an error occurs on the zlib dll

    /// </summary>

    public class ZLibException : ApplicationException

    {

        /// <summary>

        /// Initializes a new instance of the <see cref="ZLibException"/> class with a specified 

        /// error message and error code

        /// </summary>

        /// <param name="errorCode">The zlib error code that caused the exception</param>

        /// <param name="msg">A message that (hopefully) describes the error</param>

        public ZLibException(int errorCode, string msg) : base(String.Format("ZLib error {0} {1}", errorCode, msg))

        {

        }



        /// <summary>

        /// Initializes a new instance of the <see cref="ZLibException"/> class with a specified 

        /// error code

        /// </summary>

        /// <param name="errorCode">The zlib error code that caused the exception</param>

        public ZLibException(int errorCode) : base(String.Format("ZLib error {0}", errorCode))

        {

        }

    }

    #endregion



    #region Interfaces



    /// <summary>

    /// Declares methods and properties that enables a running checksum to be calculated 

    /// </summary>

    public interface ChecksumGenerator

    {

        /// <summary>

        /// Gets the current value of the checksum

        /// </summary>

        uint Value { get; }



        /// <summary>

        /// Clears the current checksum to 0

        /// </summary>

        void Reset();



        /// <summary>

        /// Updates the current checksum with an array of bytes

        /// </summary>

        /// <param name="data">The data to update the checksum with</param>

        void Update(byte[] data);



        /// <summary>

        /// Updates the current checksum with part of an array of bytes

        /// </summary>

        /// <param name="data">The data to update the checksum with</param>

        /// <param name="offset">Where in <c>data</c> to start updating</param>

        /// <param name="count">The number of bytes from <c>data</c> to use</param>

        /// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>

        /// <exception cref="ArgumentNullException"><c>data</c> is a null reference</exception>

        /// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>

        void Update(byte[] data, int offset, int count);



        /// <summary>

        /// Updates the current checksum with the data from a string

        /// </summary>

        /// <param name="data">The string to update the checksum with</param>

        /// <remarks>The characters in the string are converted by the UTF-8 encoding</remarks>

        void Update(string data);



        /// <summary>

        /// Updates the current checksum with the data from a string, using a specific encoding

        /// </summary>

        /// <param name="data">The string to update the checksum with</param>

        /// <param name="encoding">The encoding to use</param>

        void Update(string data, Encoding encoding);

    }





    /// <summary>

    /// Represents the method that will be called from a codec when new data

    /// are available.

    /// </summary>

    /// <paramref name="data">The byte array containing the processed data</paramref>

    /// <paramref name="startIndex">The index of the first processed byte in <c>data</c></paramref>

    /// <paramref name="count">The number of processed bytes available</paramref>

    /// <remarks>On return from this method, the data may be overwritten, so grab it while you can. 

    /// You cannot assume that startIndex will be zero.

    /// </remarks>

    public delegate void DataAvailableHandler(byte[] data, int startIndex, int count);



    /// <summary>

    /// Declares methods and events for implementing compressors/decompressors

    /// </summary>

    public interface Codec

    {

        /// <summary>

        /// Occurs when more processed data are available.

        /// </summary>

        event DataAvailableHandler DataAvailable;



        /// <summary>

        /// Adds more data to the codec to be processed.

        /// </summary>

        /// <param name="data">Byte array containing the data to be added to the codec</param>

        /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>

        void Add(byte[] data);



        /// <summary>

        /// Adds more data to the codec to be processed.

        /// </summary>

        /// <param name="data">Byte array containing the data to be added to the codec</param>

        /// <param name="offset">The index of the first byte to add from <c>data</c></param>

        /// <param name="count">The number of bytes to add</param>

        /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>

        void Add(byte[] data, int offset, int count);



        /// <summary>

        /// Finishes up any pending data that needs to be processed and handled.

        /// </summary>

        void Finish();



        /// <summary>

        /// Gets the checksum of the data that has been added so far

        /// </summary>

        uint Checksum { get; }





    }



    #endregion



    #region Classes

    /// <summary>

    /// Encapsulates general information about the ZLib library

    /// </summary>

    public class Info

    {

        #region DLL imports

        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]

        private static extern uint zlibCompileFlags();



        [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]

        private static extern string zlibVersion();

        #endregion



        #region Private stuff

        private uint _flags;



        // helper function that unpacks a bitsize mask

        private static int bitSize(uint bits)

        {

            switch (bits)

            {

                case 0: return 16;

                case 1: return 32;

                case 2: return 64;

            }

            return -1;

        }

        #endregion



        /// <summary>

        /// Constructs an instance of the <c>Info</c> class.

        /// </summary>

        public Info()

        {

            _flags = zlibCompileFlags();

        }



        /// <summary>

        /// True if the library is compiled with debug info

        /// </summary>

        public bool HasDebugInfo { get { return 0 != (_flags & 0x100); } }



        /// <summary>

        /// True if the library is compiled with assembly optimizations

        /// </summary>

        public bool UsesAssemblyCode { get { return 0 != (_flags & 0x200); } }



        /// <summary>

        /// Gets the size of the unsigned int that was compiled into Zlib

        /// </summary>

        public int SizeOfUInt { get { return bitSize(_flags & 3); } }



        /// <summary>

        /// Gets the size of the unsigned long that was compiled into Zlib

        /// </summary>

        public int SizeOfULong { get { return bitSize((_flags >> 2) & 3); } }



        /// <summary>

        /// Gets the size of the pointers that were compiled into Zlib

        /// </summary>

        public int SizeOfPointer { get { return bitSize((_flags >> 4) & 3); } }



        /// <summary>

        /// Gets the size of the z_off_t type that was compiled into Zlib

        /// </summary>

        public int SizeOfOffset { get { return bitSize((_flags >> 6) & 3); } }



        /// <summary>

        /// Gets the version of ZLib as a string, e.g. "1.2.1"

        /// </summary>

        public static string Version { get { return zlibVersion(); } }

    }



    #endregion



}

