namespace QuantConnect.Algorithm.CSharp
{
    public class ConsolidatorTest : QCAlgorithm
    {
        private Symbol _symbol = QuantConnect.Symbol.Create("EURUSD", SecurityType.Forex, Market.Oanda);
        // private Symbol _symbol = QuantConnect.Symbol.Create("EURUSD", SecurityType.Forex, Market.FXCM);

        public override void Initialize()
        {
            SetStartDate(2019, 01, 01);  //Set Start Date
            SetEndDate(2019, 02, 03);    //Set End Date
            SetCash(100000);             //Set Strategy Cash
            
            AddForex(_symbol, Resolution.Minute);

            var dailyCloseTime = new TimeSpan(17,0,0);
            var nyCloseConsolidator = new TimeOfDayQuoteBarConsolidator(dailyCloseTime);
            Log("dailyCloseTime = " + dailyCloseTime.ToString());
            nyCloseConsolidator.DataConsolidated += OnNYClose;
            SubscriptionManager.AddConsolidator(_symbol, nyCloseConsolidator);
        }

        public override void OnData(Slice data)
        {
        }

        public void OnNYClose(object sender, QuoteBar bar)
        {
        	Log("OnNYClose(): bar.Time = " + bar.Time.DayOfWeek.ToString() + " " + bar.Time.ToString()
        							+ ", OHLC = " + bar.Open.ToString("0.00000")
        									+ ", " + bar.High.ToString("0.00000")
        									+ ", " + bar.Low.ToString("0.00000")
        									+ ", " + bar.Close.ToString("0.00000"));
        }
    }
}

namespace QuantConnect
{
    /// <summary>
    /// Provides a base class for consolidators that emit data based on the passing
    /// of a specified time of day (in the data time zone.
    /// </summary>
    /// <typeparam name="T">The input type of the consolidator</typeparam>
    /// <typeparam name="TConsolidated">The output type of the consolidator</typeparam>
    public abstract class TimeOfDayConsolidatorBase<T, TConsolidated> : DataConsolidator<T>
        where T : IBaseData
        where TConsolidated : BaseData
    {
    	// The time of day to emit the consolidated bar.
    	private readonly TimeSpan _dailyOpenTime;
        // The working bar used for aggregating the data.
        private TConsolidated _workingBar;
        // The last time we emitted a consolidated bar.
        private DateTime _lastEmit;

        /// <summary>
        /// Creates a consolidator to produce a new <typeparamref name="TConsolidated"/> instance
        /// representing a day starting at the specified time.
        /// </summary>
        /// <param name="dailyOpenTime">The time of day to emit a consolidated bar.</param>
        protected TimeOfDayConsolidatorBase(TimeSpan dailyOpenTime)
        {
            _dailyOpenTime = dailyOpenTime;
            _lastEmit = DateTime.MinValue;
        }

        /// <summary>
        /// Gets the type produced by this consolidator.
        /// </summary>
        public override Type OutputType
        {
            get { return typeof(TConsolidated); }
        }

        /// <summary>
        /// Gets a clone of the data being currently consolidated.
        /// </summary>
        public override IBaseData WorkingData
        {
            get { return _workingBar != null ? _workingBar.Clone() : null; }
        }

        /// <summary>
        /// Event handler that fires when a new piece of data is produced. We define this as a 'new'
        /// event so we can expose it as a <typeparamref name="TConsolidated"/> instead of a <see cref="BaseData"/> instance.
        /// </summary>
        public new event EventHandler<TConsolidated> DataConsolidated;

        /// <summary>
        /// Updates this consolidator with the specified data. This method is
        /// responsible for raising the DataConsolidated event.
        /// The bar range is closed on the left and open on the right: [dailyOpenTime, dailyOpenTime+1day).
        /// For example, if time of day is 17:00, we have [17:00, next day 17:00): so
        /// data at 17:00 next day is not included in the bar.
        /// </summary>
        /// <param name="data">The new data for the consolidator.</param>
        public override void Update(T data)
        {
            if (!ShouldProcess(data))
            {
                // First allow the base class a chance to filter out data it doesn't want
                // before we start incrementing counts and what not.
                return;
            }

            //Fire the event
            if (_workingBar != null && GetRoundedBarTime(data.Time) > _workingBar.Time)
            {
            	// *** I don't understand why this is needed. Refer class PeriodCountConsolidatorBase<>.
                var workingTradeBar = _workingBar as TradeBar;
                if (workingTradeBar != null)
                {
                    // we kind of are cheating here...
                    // if (_period.HasValue)
                    // {
                    //     workingTradeBar.Period = _period.Value;
                        workingTradeBar.Period = new TimeSpan(1, 0, 0, 0);
                    // }
                    // since trade bar has period it aggregates this properly
                    // else if (!(data is TradeBar))
                    // {
                    //     workingTradeBar.Period = data.Time - _lastEmit.Value;
                    // }
                }

                OnDataConsolidated(_workingBar);
                _lastEmit = _workingBar != null ? _workingBar.Time.AddDays(1) : data.Time;
                _workingBar = null;
            }

            if (data.Time >= _lastEmit)
            {
                AggregateBar(ref _workingBar, data);
            }
        }

        /// <summary>
        /// Scans this consolidator to see if it should emit a bar due to time passing.
        /// </summary>
        /// <param name="currentLocalTime">The current time in the local time zone (same as <see cref="BaseData.Time"/>).</param>
        public override void Scan(DateTime currentLocalTime)
        {
            if (_workingBar != null)
            {
                currentLocalTime = GetRoundedBarTime(currentLocalTime);

        	    if (currentLocalTime > _workingBar.Time)
                {
                    OnDataConsolidated(_workingBar);
                    _lastEmit = currentLocalTime;
                    _workingBar = null;
                }
            }
        }

        /// <summary>
        /// Determines whether or not the specified data should be processed.
        /// </summary>
        /// <param name="data">The data to check.</param>
        /// <returns>True if the consolidator should process this data, false otherwise.</returns>
        protected virtual bool ShouldProcess(T data)
        {
            return true;
        }

        /// <summary>
        /// Aggregates the new 'data' into the 'workingBar'. The 'workingBar' will be
        /// null following the event firing.
        /// </summary>
        /// <param name="workingBar">The bar we're building, null if the event was just fired and we're starting a new consolidated bar.</param>
        /// <param name="data">The new data.</param>
        protected abstract void AggregateBar(ref TConsolidated workingBar, T data);

        /// <summary>
        /// Gets a bar time rounded-down to the prior daily close time. Called by AggregateBar in derived classes.
        /// </summary>
        /// <param name="time">The bar time to be rounded down.</param>
        /// <returns>The rounded bar time.</returns>
        protected DateTime GetRoundedBarTime(DateTime time)
        {
            DateTime roundedBarTime = time.Date.Add(_dailyOpenTime);
            return time.TimeOfDay >= _dailyOpenTime ? roundedBarTime : roundedBarTime.AddDays(-1);
        }

        /// <summary>
        /// Event invocator for the <see cref="DataConsolidated"/> event.
        /// </summary>
        /// <param name="e">The consolidated data.</param>
        protected virtual void OnDataConsolidated(TConsolidated e)
        {
            base.OnDataConsolidated(e);
            var handler = DataConsolidated;
            if (handler != null) handler(this, e);
        }
    }
}

namespace QuantConnect
{
    /// <summary>
    /// Consolidates quotebars into larger quotebars at the specified time of day (in the QuoteBar time zone).
    /// </summary>
    public class TimeOfDayQuoteBarConsolidator : TimeOfDayConsolidatorBase<QuoteBar, QuoteBar>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="TickQuoteBarConsolidator"/> class.
        /// </summary>
        /// <param name="dailyOpenTime">The time of day to emit a consolidated bar.</param>
        public TimeOfDayQuoteBarConsolidator(TimeSpan dailyOpenTime)
            : base(dailyOpenTime)
        {
        }

        /// <summary>
        /// Aggregates the new 'data' into the 'workingBar'. The 'workingBar' will be
        /// null following the event firing.
        /// </summary>
        /// <param name="workingBar">The bar we're building, null if the event was just fired and we're starting a new consolidated bar.</param>
        /// <param name="data">The new data.</param>
        protected override void AggregateBar(ref QuoteBar workingBar, QuoteBar data)
        {
            var bid = data.Bid;
            var ask = data.Ask;

            if (workingBar == null)
            {
                workingBar = new QuoteBar
                {
                    Symbol = data.Symbol,
                    Time = GetRoundedBarTime(data.Time),
                    Bid = bid == null ? null : bid.Clone(),
                    Ask = ask == null ? null : ask.Clone(),
                    Period = data.Period
                };
            }

            // update the bid and ask
            if (bid != null)
            {
                workingBar.LastBidSize = data.LastBidSize;
                if (workingBar.Bid == null)
                {
                    workingBar.Bid = new Bar(bid.Open, bid.High, bid.Low, bid.Close);
                }
                else
                {
                    workingBar.Bid.Close = bid.Close;
                    if (workingBar.Bid.High < bid.High) workingBar.Bid.High = bid.High;
                    if (workingBar.Bid.Low > bid.Low) workingBar.Bid.Low = bid.Low;
                }
            }
            if (ask != null)
            {
                workingBar.LastAskSize = data.LastAskSize;
                if (workingBar.Ask == null)
                {
                    workingBar.Ask = new Bar(ask.Open, ask.High, ask.Low, ask.Close);
                }
                else
                {
                    workingBar.Ask.Close = ask.Close;
                    if (workingBar.Ask.High < ask.High) workingBar.Ask.High = ask.High;
                    if (workingBar.Ask.Low > ask.Low) workingBar.Ask.Low = ask.Low;
                }
            }

            workingBar.Value = data.Value;
            workingBar.Period += data.Period;
        }
    }
}