//******************************************************************************************************
//  Adler32.cs - Gbtc
//
//  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), 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.opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  04/11/2012 - Stephen C. Wills
//       Generated original version of source code.
//  12/14/2012 - Starlynn Danyelle Gilliam
//       Modified Header.
//
//******************************************************************************************************

using System;

namespace GSF.IO.Checksums
{
    /// <summary>
    /// Generates an Adler-32 checksum calculation.
    /// </summary>
    public sealed class Adler32
    {
        #region [ Members ]

        // Constants
        private const uint AdlerMod = 65521u;
        private const int MaxLoops = 5552;

        // Fields
        private uint m_a;
        private uint m_b;

        private int m_loopCount;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Creates a new instance of the <see cref="Adler32"/> class.
        /// </summary>
        public Adler32()
        {
            Reset();
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Returns the Adler-32 data checksum computed so far.
        /// </summary>
        public uint Value
        {
            get
            {
                ApplyMod();
                return m_a | (m_b << 16);
            }
            set
            {
                m_a = value & 0xFFFF;
                m_b = value >> 16;
                ApplyMod();
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Resets the Adler-32 data checksum as if no update was ever called.
        /// </summary>
        public void Reset()
        {
            m_a = 1;
            m_b = 0;
            m_loopCount = 0;
        }

        /// <summary>
        /// Updates the checksum with the byte value.
        /// </summary>
        /// <param name="value">The <see cref="byte"/> value to use for the update.</param>
        public void Update(byte value)
        {
            if (m_loopCount >= MaxLoops)
                ApplyMod();

            m_a += value;
            m_b += m_a;
            m_loopCount++;
        }

        /// <summary>
        /// Updates the checksum with the bytes taken from the array.
        /// </summary>
        /// <param name="buffer">buffer an array of bytes</param>
        public void Update(byte[] buffer)
        {
            Update(buffer, 0, buffer.Length);
        }

        /// <summary>
        /// Adds the byte array to the data checksum.
        /// </summary>
        /// <param name="buffer">The buffer which contains the data</param>
        /// <param name="offset">The offset in the buffer where the data starts</param>
        /// <param name="count">The number of data bytes to update the checksum with.</param>
        public void Update(byte[] buffer, int offset, int count)
        {
            int remainingLoops;
            int numLoops;
            int i = 0;

            while (i < count)
            {
                if (m_loopCount >= MaxLoops)
                    ApplyMod();

                remainingLoops = MaxLoops - m_loopCount;
                numLoops = Math.Min(remainingLoops, count - i);

                for (int loopCtr = 0; loopCtr < numLoops; loopCtr++)
                {
                    m_a += buffer[offset + i];
                    m_b += m_a;
                    i++;
                }

                m_loopCount += numLoops;
            }
        }

        // Applies the modulus operation
        // to the checksum components.
        private void ApplyMod()
        {
            m_a %= AdlerMod;
            m_b %= AdlerMod;
            m_loopCount = 0;
        }

        #endregion
    }
}