Overall Statistics
using System;
using System.Collections.Generic;
using System.Linq;
using QuantConnect.Data;
using QuantConnect.Data.Consolidators;
using QuantConnect.Data.Market;
using QuantConnect.Indicators;

namespace QuantConnect.Algorithm.CSharp
    /// Example structure for structuring an algorithm with indicator and consolidator data for many tickers.

    public class MultipleSymbolConsolidationAlgorithm : QCAlgorithm
        /// This is the period of bars we'll be creating
        public readonly TimeSpan BarPeriod = TimeSpan.FromDays(1);
        /// This is the period of our sma indicators
        public readonly int SimpleMovingAveragePeriod = 55;
        /// This is the number of consolidated bars we'll hold in symbol data for reference
        public readonly int RollingWindowSize = 10;
        /// Holds all of our data keyed by each symbol
        public readonly Dictionary<string, SymbolData> Data = new Dictionary<string, SymbolData>();
        /// Contains all of our equity symbols
        public readonly IReadOnlyList<string> EquitySymbols = new List<string>
        /// Contains all of our forex symbols
        public readonly IReadOnlyList<string> ForexSymbols = new List<string>

        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
        public override void Initialize()
            SetStartDate(2017, 6, 01);
            SetEndDate(2018, 02, 01);
            // Set cash allocation for backtest
            // In live trading this is ignored and your real account is used.
            // Specify the OANDA Brokerage: This gives lets us know the fee models & data.

            // initialize our equity data
            //foreach (var symbol in EquitySymbols)
            //    var equity = AddEquity(symbol);
            //    Data.Add(symbol, new SymbolData(equity.Symbol, BarPeriod, RollingWindowSize));

            // initialize our forex data
            foreach (var symbol in ForexSymbols)
                var forex = AddForex(symbol, market: Market.Oanda);
                Data.Add(symbol, new SymbolData(forex.Symbol, BarPeriod, RollingWindowSize));

            // loop through all our symbols and request data subscriptions and initialize indicatora
            foreach (var kvp in Data)
                // this is required since we're using closures below, for more information
                // see: http://stackoverflow.com/questions/14907987/access-to-foreach-variable-in-closure-warning
                var symbolData = kvp.Value;

                // define a consolidator to consolidate data for this symbol on the requested period
                var consolidator = symbolData.Symbol.SecurityType == SecurityType.Equity
                    ? (IDataConsolidator)new TradeBarConsolidator(BarPeriod)
                    : (IDataConsolidator)new QuoteBarConsolidator(BarPeriod);

                // define our indicator
                //symbolData.SMA = new SimpleMovingAverage(CreateIndicatorName(symbolData.Symbol, "SMA" + SimpleMovingAveragePeriod, Resolution.Minute), SimpleMovingAveragePeriod);
                symbolData.HA = new HeikinAshi(CreateIndicatorName(symbolData.Symbol, "HA", Resolution.Daily));
                // wire up our consolidator to update the indicator
                consolidator.DataConsolidated += (sender, baseData) =>
                    // 'bar' here is our newly consolidated data
                    var bar = (IBaseDataBar)baseData;
                    // update the indicator
                    //symbolData.SMA.Update(bar.Time, bar.Close);
                    // Add the latest result to history
                    // we're also going to add this bar to our rolling window so we have access to it later

                // we need to add this consolidator so it gets auto updates
                SubscriptionManager.AddConsolidator(symbolData.Symbol, consolidator);

        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
        /// <param name="data">TradeBars IDictionary object with your stock data</param>
        public override void OnData(Slice data)
            // loop through each symbol in our structure
            foreach (var symbolData in Data.Values)
                // this check proves that this symbol was JUST updated prior to this OnData function being called
                if (symbolData.IsReady && symbolData.WasJustUpdated(Time))
                	//if (symbolData.HA.Open < symbolData.HA.Close) //&& (symbolData.HA[1].Open > symbolData.HA[1].Close))
                	//if ((symbolData.HA.Open < symbolData.HA.Close) && (symbolData.HA_History.Count > 1) && (symbolData.HA_History[1].Open > symbolData.HA_History[1].Close))
                	if ((symbolData.HA_History[0].Open < symbolData.HA_History[0].Close) && (symbolData.HA_History.Count > 1) && (symbolData.HA_History[1].Open > symbolData.HA_History[1].Close))
                  		MarketOrder(symbolData.Symbol, 1);
                  		Debug("Purchased " + symbolData.Symbol +" " + symbolData.HA_History[1].Open +" " +symbolData.HA_History[1].Close);

        /// End of a trading day event handler. This method is called at the end of the algorithm day (or multiple times if trading multiple assets).
        /// <remarks>Method is called 10 minutes before closing to allow user to close out position.</remarks>
        //public override void OnEndOfDay()
        //    int i = 0;
        //    foreach (var kvp in Data.OrderBy(x => x.Value.Symbol))
        //    {
                // we have too many symbols to plot them all, so plot ever other
        //        if (kvp.Value.IsReady && ++i%2 == 0)
        //        {
        //            Plot(kvp.Value.Symbol.ToString(), kvp.Value.SMA);
        //        }
        //    }

        /// Contains data pertaining to a symbol in our algorithm
        public class SymbolData
            /// This symbol the other data in this class is associated with
            public readonly Symbol Symbol;
            /// A rolling window of data, data needs to be pumped into Bars by using Bars.Update( tradeBar ) and
            /// can be accessed like:
            ///  mySymbolData.Bars[0] - most first recent piece of data
            ///  mySymbolData.Bars[5] - the sixth most recent piece of data (zero based indexing)
            public readonly RollingWindow<IBaseDataBar> Bars;
            /// The period used when population the Bars rolling window.
            public readonly TimeSpan BarPeriod;
            /// The simple moving average indicator for our symbol
            public SimpleMovingAverage SMA;
            /// The HeikinAshi indicator for our symbol
            public HeikinAshi HA;
			/// The HeikinAshi indicator history for our symbol
            public readonly RollingWindow<IBaseDataBar> HA_History;
            /// Initializes a new instance of SymbolData
            public SymbolData(Symbol symbol, TimeSpan barPeriod, int windowSize)
                Symbol = symbol;
                BarPeriod = barPeriod;
                Bars = new RollingWindow<IBaseDataBar>(windowSize);
                HA_History = new RollingWindow<IBaseDataBar>(windowSize);

            /// Returns true if all the data in this instance is ready (indicators, rolling windows, ect...)
            public bool IsReady
                get { return Bars.IsReady && HA.IsReady; }

            /// Returns true if the most recent trade bar time matches the current time minus the bar's period, this
            /// indicates that update was just called on this instance
            /// <param name="current">The current algorithm time</param>
            /// <returns>True if this instance was just updated with new data, false otherwise</returns>
            public bool WasJustUpdated(DateTime current)
                return Bars.Count > 0 && Bars[0].Time == current - BarPeriod;