//*******************************************************************************************************
//  InputAdapter.cs
//  Copyright © 2009 - TVA, all rights reserved - Gbtc
//
//  Build Environment: C#, Visual Studio 2008
//  Primary Developer: James R. Carroll
//      Office: PSO PCS, CHATTANOOGA - MR BK-C
//       Phone: 423/751-4165
//       Email: jrcarrol@tva.gov
//
//  Code Modification History:
//  -----------------------------------------------------------------------------------------------------
//  06/01/2006 - James R. Carroll
//       Generated original version of source code.
//
//*******************************************************************************************************

using System;
using System.Collections.Generic;
using System.Text;
using TVA.Communication;
using TVA.Historian.Packets;
using TVA.Measurements;
using TVA.Measurements.Routing;

namespace TVA.Historian
{
    /// <summary>
    /// Represents the class for parsing incoming measurements from a TVA historian data stream.
    /// </summary>
    [CLSCompliant(false)]
    public class InputAdapter : InputAdapterBase
	{
        #region [ Members ]

        // Fields
        private string m_historianID;
        private int m_archiverPort;
        private UdpClient m_client;
        private PacketParser m_parser;
        private bool m_disposed;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Creates a new <see cref="InputAdapter"/>.
        /// </summary>
        public InputAdapter()
        {
            m_archiverPort = 2001;
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets flag that determines if the data input connects asynchronously.
        /// </summary>
        protected override bool UseAsyncConnect
        {
            get
            {
                return true;
            }
        }

        /// <summary>
        /// Gets or sets the name of this <see cref="InputAdapter"/>.
        /// </summary>
        public override string Name
        {
            get
            {
                return "Archive Listener " + m_historianID + ":" + m_archiverPort;
            }
        }

        /// <summary>
        /// Returns the detailed status of the data input source.
        /// </summary>
        public override string Status
        {
            get
            {
                StringBuilder status = new StringBuilder();

                status.Append("    Historian parser state: ");

                if (m_parser == null)
                    status.Append("Inactive - not parsing");
                else
                    status.Append("Active");

                status.AppendLine();

                if (m_parser != null)
                    status.Append(m_parser.Status);

                if (m_client != null)
                    status.Append(m_client.Status);

                status.Append(base.Status);

                return status.ToString();
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Releases the unmanaged resources used by the <see cref="InputAdapter"/> object and optionally releases the managed resources.
        /// </summary>
        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
        protected override void Dispose(bool disposing)
        {
            if (!m_disposed)
            {
                try
                {
                    if (disposing)
                    {
                        if (m_client != null)
                        {
                            m_client.ConnectionEstablished -= m_client_ConnectionEstablished;
                            m_client.ConnectionTerminated -= m_client_ConnectionTerminated;
                            m_client.ConnectionException -= m_client_ConnectionException;
                            m_client.Dispose();
                        }
                        m_client = null;

                        if (m_parser != null)
                        {
                            m_parser.DataParsed -= m_parser_DataParsed;
                            m_parser.Dispose();
                        }
                        m_parser = null;
                    }
                }
                finally
                {
                    base.Dispose(disposing);    // Call base class Dispose().
                    m_disposed = true;          // Prevent duplicate dispose.
                }
            }
        }

        /// <summary>
        /// Intializes <see cref="InputAdapter"/>.
        /// </summary>
        public override void Initialize()
        {
            Dictionary<string, string> settings = Settings;
            string value;

            // Example connection string:
            // Port=1003; ServerID=P3
            if (settings.TryGetValue("port", out value))
                m_archiverPort = int.Parse(value);

            if (settings.TryGetValue("historianid", out value))
                m_historianID = value.Trim().ToUpper();

            // Create new data parser
            m_parser = new PacketParser();
            m_parser.DataParsed += m_parser_DataParsed;

            // Create UDP client to listen for messages
            m_client = new UdpClient("localport=" + m_archiverPort);
            m_client.ConnectionEstablished += m_client_ConnectionEstablished;
            m_client.ConnectionTerminated += m_client_ConnectionTerminated;
            m_client.ConnectionException += m_client_ConnectionException;
            m_client.Handshake = false;

            // Send data received over UDP port directly to packet parser
            m_client.ReceiveDataHandler = (buffer, offset, count) => m_parser.Parse(Guid.Empty, buffer, offset, count);
        }

        /// <summary>
        /// Gets a short one-line status of this <see cref="AdapterBase"/>.
        /// </summary>
        /// <param name="maxLength">Maximum number of available characters for display.</param>
        /// <returns>A short one-line summary of the current status of this <see cref="AdapterBase"/>.</returns>
        public override string GetShortStatus(int maxLength)
        {
            return ("Total received measurements " + ReceivedMeasurements.ToString("N0")).PadLeft(maxLength, '\xA0');
        }

        /// <summary>
        /// Attempts to connect to data input source.
        /// </summary>
        protected override void AttemptConnection()
        {
            // Starts historian packet parser
            m_parser.Start();

            // Starts listening for UDP data
            m_client.ConnectAsync();
        }

        /// <summary>
        /// Attempts to disconnect from data input source.
        /// </summary>
        protected override void AttemptDisconnection()
        {
            // Stops listening for UDP data
            if (m_client != null)
                m_client.Disconnect();

            // Stops historian packet parser
            if (m_parser != null)
                m_parser.Stop();
        }

        // UDP client connection established handler
        private void m_client_ConnectionEstablished(object sender, EventArgs e)
        {
            OnConnected();
        }

        // UDP client connection terminated handler
        private void m_client_ConnectionTerminated(object sender, EventArgs e)
        {
            OnDisconnected();
        }

        // UDP client connection exception handler
        private void m_client_ConnectionException(object sender, EventArgs<Exception> e)
        {
            OnProcessException(e.Argument);
        }

        // Historian packet parser data parsed handler
        private void m_parser_DataParsed(object sender, EventArgs<Guid, IList<IPacket>> e)
        {
            List<IMeasurement> measurements = new List<IMeasurement>();

            // We have new historian packets, convert all PacketType1's to measurements
            foreach (PacketType1 packet in e.Argument2)
            {
                if (packet != null)
                    measurements.Add(new Measurement((uint)packet.HistorianID, m_historianID, packet.Value, packet.Time));
            }

            // Publish new measurements to consumer...
            if (measurements.Count > 0)
                this.OnNewMeasurements(measurements);
        }

        #endregion
    }	
}