//******************************************************************************************************
//  StateRecordDataPoint.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:
//  ----------------------------------------------------------------------------------------------------
//  05/04/2009 - Pinal C. Patel
//       Generated original version of code based on DatAWare system specifications by Brian B. Fox, GSF.
//  09/15/2009 - Stephen C. Wills
//       Added new header and license agreement.
//  10/11/2010 - Mihir Brahmbhatt
//       Updated header and license agreement.
//  11/30/2011 - J. Ritchie Carroll
//       Modified to support buffer optimized ISupportBinaryImage.
//  12/14/2012 - Starlynn Danyelle Gilliam
//       Modified Header.
//
//******************************************************************************************************

using System;

namespace GSF.Historian.Files
{
    /// <summary>
    /// Represents time-series data stored in <see cref="StateFile"/>.
    /// </summary>
    /// <seealso cref="StateFile"/>
    /// <seealso cref="StateRecord"/>
    /// <seealso cref="StateRecordSummary"/>
    public class StateRecordDataPoint : ArchiveDataPoint
    {
        // **************************************************************************************************
        // *                                        Binary Structure                                        *
        // **************************************************************************************************
        // * # Of Bytes Byte Index Data Type  Property Name                                                 *
        // * ---------- ---------- ---------- --------------------------------------------------------------*
        // * 8          0-7        Double     Time                                                          *
        // * 4          8-11       Int32      Flags (Quality, TimeZoneIndex & DaylightSavingsTime)          *
        // * 4          12-15      Single     Value                                                         *
        // **************************************************************************************************

        #region [ Members ]

        // Constants

        /// <summary>
        /// Specifies the number of bytes in the binary image of <see cref="StateRecordDataPoint"/>.
        /// </summary>
        public new const int FixedLength = 16;

        /// <summary>
        /// Specifies the bit-mask for <see cref="TimeZoneIndex"/> stored in <see cref="ArchiveDataPoint.Flags"/>.
        /// </summary>
        protected const Bits TziMask = Bits.Bit05 | Bits.Bit06 | Bits.Bit07 | Bits.Bit08 | Bits.Bit09 | Bits.Bit10;

        /// <summary>
        /// Specifies the bit-mask for <see cref="DaylightSavingsTime"/> stored in <see cref="ArchiveDataPoint.Flags"/>.
        /// </summary>
        protected const Bits DstMask = Bits.Bit11;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Initializes a new instance of the <see cref="StateRecordDataPoint"/> class.
        /// </summary>
        /// <param name="historianID">Historian identifier of <see cref="StateRecordDataPoint"/>.</param>
        public StateRecordDataPoint(int historianID)
            : base(historianID)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="StateRecordDataPoint"/> class.
        /// </summary>
        /// <param name="dataPoint">A time-series data point.</param>
        public StateRecordDataPoint(IDataPoint dataPoint)
            : base(dataPoint)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="StateRecordDataPoint"/> class.
        /// </summary>
        /// <param name="historianID">Historian identifier of <see cref="StateRecordDataPoint"/>.</param>
        /// <param name="time"><see cref="TimeTag"/> of <see cref="StateRecordDataPoint"/>.</param>
        /// <param name="value">Floating-point value of <see cref="StateRecordDataPoint"/>.</param>
        /// <param name="quality"><see cref="Quality"/> of <see cref="StateRecordDataPoint"/>.</param>
        public StateRecordDataPoint(int historianID, TimeTag time, float value, Quality quality)
            : base(historianID, time, value, quality)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="StateRecordDataPoint"/> class.
        /// </summary>
        /// <param name="historianID">Historian identifier of <see cref="StateRecordDataPoint"/>.</param>
        /// <param name="buffer">Binary image to be used for initializing <see cref="StateRecordDataPoint"/>.</param>
        /// <param name="startIndex">0-based starting index of initialization data in the <paramref name="buffer"/>.</param>
        /// <param name="length">Valid number of bytes in <paramref name="buffer"/> from <paramref name="startIndex"/>.</param>
        public StateRecordDataPoint(int historianID, byte[] buffer, int startIndex, int length)
            : this(historianID)
        {
            ParseBinaryImage(buffer, startIndex, length);
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets or sets the 0-based index of the time-zone for the <see cref="Time"/>.
        /// </summary>
        /// <exception cref="ArgumentException">The value being assigned is not positive or zero.</exception>
        public short TimeZoneIndex
        {
            get
            {
                return (short)(Flags.GetMaskedValue(TziMask) >> 5);
            }
            set
            {
                if (value < 0)
                    throw new ArgumentException("Value must be positive or zero");

                Flags = Flags.SetMaskedValue(TziMask, value << 5);
            }
        }

        /// <summary>
        /// Gets a boolean value that indicates whether daylight savings time is in effect.
        /// </summary>
        public bool DaylightSavingsTime
        {
            get
            {
                return Flags.CheckBits(DstMask);
            }
            set
            {
                Flags = value ? Flags.SetBits(DstMask) : Flags.ClearBits(DstMask);
            }
        }

        /// <summary>
        /// Gets or sets the <see cref="TimeTag"/> of <see cref="StateRecordDataPoint"/>.
        /// </summary>
        /// <exception cref="ArgumentException">The value being assigned is not between 01/01/1995 and 01/19/2063.</exception>
        public override TimeTag Time
        {
            get
            {
                return base.Time;
            }
            set
            {
                int flags = base.Flags; // Save existing flags.
                base.Time = value;      // Update base time (modifies flags).
                base.Flags = flags;     // Restore saved flags.
            }
        }

        /// <summary>
        /// Gets the length of the <see cref="StateRecordDataPoint"/>.
        /// </summary>
        public override int BinaryLength
        {
            get
            {
                return FixedLength;
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Initializes <see cref="StateRecordDataPoint"/> from the specified <paramref name="buffer"/>.
        /// </summary>
        /// <param name="buffer">Binary image to be used for initializing <see cref="StateRecordDataPoint"/>.</param>
        /// <param name="startIndex">0-based starting index of initialization data in the <paramref name="buffer"/>.</param>
        /// <param name="length">Valid number of bytes in <paramref name="buffer"/> from <paramref name="startIndex"/>.</param>
        /// <returns>Number of bytes used from the <paramref name="buffer"/> for initializing <see cref="StateRecordDataPoint"/>.</returns>
        public override int ParseBinaryImage(byte[] buffer, int startIndex, int length)
        {
            if (length >= FixedLength)
            {
                // Binary image has sufficient data.
                Time = new TimeTag((decimal)LittleEndian.ToDouble(buffer, startIndex));
                Flags = LittleEndian.ToInt32(buffer, startIndex + 8);
                Value = LittleEndian.ToSingle(buffer, startIndex + 12);

                return FixedLength;
            }
            else
            {
                // Binary image does not have sufficient data.
                return 0;
            }
        }

        /// <summary>
        /// Generates binary image of the <see cref="StateRecordDataPoint"/> and copies it into the given buffer, for <see cref="BinaryLength"/> bytes.
        /// </summary>
        /// <param name="buffer">Buffer used to hold generated binary image of the source object.</param>
        /// <param name="startIndex">0-based starting index in the <paramref name="buffer"/> to start writing.</param>
        /// <returns>The number of bytes written to the <paramref name="buffer"/>.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception>
        /// <exception cref="ArgumentOutOfRangeException">
        /// <paramref name="startIndex"/> or <see cref="BinaryLength"/> is less than 0 -or- 
        /// <paramref name="startIndex"/> and <see cref="BinaryLength"/> will exceed <paramref name="buffer"/> length.
        /// </exception>
        public override int GenerateBinaryImage(byte[] buffer, int startIndex)
        {
            int length = BinaryLength;

            buffer.ValidateParameters(startIndex, length);

            LittleEndian.CopyBytes((double)Time.Value, buffer, startIndex);
            LittleEndian.CopyBytes(Flags, buffer, startIndex + 8);
            LittleEndian.CopyBytes(Value, buffer, startIndex + 12);

            return length;
        }

        #endregion
    }
}