using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TradeIdeas.TIQData
{
    public class ConnectionMaster : IDisposable
    {
        /// <summary>
        /// This is what automatically reconnects, when required.
        /// </summary>
        private ConnectionLifeCycle _connectionLifeCycle;

        /// <summary>
        /// This lets you set the username and related items for the connection.
        /// </summary>
        public LoginManager LoginManager { get; private set; }

        /// <summary>
        /// This provides ping statistics, if required.
        /// This is sometimes required to keep the connection alive.
        /// </summary>
        public PingManager PingManager { get; private set; }

        /// <summary>
        /// This is a convenent way to send messages.  It helps manage retries, among
        /// other things.
        /// </summary>
        public SendManager SendManager { get; private set; }

        /// <summary>
        /// This provides limited access to the connection life cycle.  The main program
        /// can use this to offer connection instructions or to monitor the status of the
        /// connection.
        /// </summary>
        public ConnectionBase ConnectionBase { get { return _connectionLifeCycle; } }

        public TraditionalAlertsManager TraditionalAlertsManager { get; private set; }

        /// <summary>
        /// Constructor for the connection master.
        /// </summary>
        public ConnectionMaster()
        {
            _connectionLifeCycle = new ConnectionLifeCycle();
            // Initialize the login manager before anything else so it will be the first
            // one to get callbacks from the connection life cycle.  We want to send the
            // login command first, before any other commands.
            LoginManager = new LoginManager(_connectionLifeCycle);
            PingManager = new PingManager(_connectionLifeCycle);
            SendManager = new SendManager(_connectionLifeCycle);
            TraditionalAlertsManager = new TraditionalAlertsManager(_connectionLifeCycle);
        }

        /// <summary>
        /// Throw away the resources.  Can't use this object again after this.
        /// It is safe to call this more than once.
        /// </summary>
        public void Dispose()
        {
            if (null != _connectionLifeCycle)
                _connectionLifeCycle.Dispose();
            //SoftReset();  
            // Calling SoftReset from the GUI lead to a deadlock.  The thread will
            // disconnect the socket soon enough, and that's all we really need.
        }

        /// <summary>
        /// The destructor calls Dispose().
        /// </summary>
        ~ConnectionMaster()
        {
            Dispose();
        }
    }
}