namespace QuantConnect.Algorithm.CSharp
{
    /// <summary>
    /// Example structure for structuring an algorithm with indicator and consolidator data for many tickers.
    /// </summary>
    public class MultipleSymbolConsolidationAlgorithm : QCAlgorithm
    {
        /// <summary>
        /// This is the period of bars we'll be creating
        /// </summary>
        public readonly TimeSpan BarPeriod = TimeSpan.FromMinutes(10);
        /// <summary>
        /// This is the period of our sma indicators
        /// </summary>
        public readonly int FirstSimpleMovingAveragePeriod = 50;
        public readonly int SecondSimpleMovingAveragePeriod = 200;
//        private SimpleMovingAverage _fast;
//        private SimpleMovingAverage _slow;
        
        
        
        
        
        
        
        /// <summary>
        /// This is the number of consolidated bars we'll hold in symbol data for reference
        /// </summary>
        public readonly int RollingWindowSize = 10;
        /// <summary>
        /// Holds all of our data keyed by each symbol
        /// </summary>
        public readonly Dictionary<string, SymbolData> Data = new Dictionary<string, SymbolData>();
        /// <summary>
        /// Contains all of our equity symbols
        /// </summary>
        public readonly IReadOnlyList<string> EquitySymbols = new List<string>
        {
//            "AAPL",
            "SPY",
//            "IBM"
        };
        /// <summary>
        /// Contains all of our forex symbols
        /// </summary>
//        public readonly IReadOnlyList<string> ForexSymbols = new List<string>
//        {
//            "EURUSD",
//            "USDJPY",
//            "EURGBP",
//            "EURCHF",
//            "USDCAD",
//            "USDCHF",
//            "AUDUSD",
//            "NZDUSD",
//        };

        /// <summary>
        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
        /// </summary>
        /// <seealso cref="QCAlgorithm.SetStartDate(System.DateTime)"/>
        /// <seealso cref="QCAlgorithm.SetEndDate(System.DateTime)"/>
        /// <seealso cref="QCAlgorithm.SetCash(decimal)"/>
        public override void Initialize()
        {
            SetStartDate(2000, 1, 1);
            //SetEndDate(2015, 02, 01);
            SetCash(100000);
            
            // initialize our equity data
            foreach (var symbol in EquitySymbols)
            {
                Data.Add(symbol, new SymbolData(symbol, SecurityType.Equity, BarPeriod, RollingWindowSize));
            }

            // initialize our forex data
//            foreach (var symbol in ForexSymbols)
//            {
//                Data.Add(symbol, new SymbolData(symbol, SecurityType.Forex, 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;

                // request data subscription
                AddSecurity(symbolData.SecurityType, symbolData.Symbol, Resolution.Minute);

                // define a consolidator to consolidate data for this symbol on the requested period
                var consolidator = new TradeBarConsolidator(BarPeriod);
                // define our indicator
                symbolData.SMA = new SimpleMovingAverage(CreateIndicatorName(symbolData.Symbol, "SMA" + FirstSimpleMovingAveragePeriod, Resolution.Minute), FirstSimpleMovingAveragePeriod);
                symbolData.SMA = new SimpleMovingAverage(CreateIndicatorName(symbolData.Symbol, "SMA" + SecondSimpleMovingAveragePeriod, Resolution.Minute), SecondSimpleMovingAveragePeriod);
                // wire up our consolidator to update the indicator
                consolidator.DataConsolidated += (sender, bar) =>
                {
                    // 'bar' here is our newly consolidated data
                    symbolData.SMA.Update(bar.Time, bar.Close);
                    // we're also going to add this bar to our rolling window so we have access to it later
                    symbolData.Bars.Add(bar);
                };

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

        /// <summary>
        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
        /// </summary>
        /// <param name="data">TradeBars IDictionary object with your stock data</param>
        public void OnData(TradeBars data)
        {
        	
        	const decimal tolerance = 0.00015m;
//        	var holdings = Portfolio[symbolData.Symbol].Quantity;
            
        	foreach (var symbolData in Data.Values)
        	{
            var holdings = Portfolio[symbolData.Symbol].Quantity;
        	// we only want to go long if we're currently short or flat
            if (holdings <= 0)
            {
//            	if (symbolData.IsReady && symbolData.WasJustUpdated(Time))
//                {

                // if the fast is greater than the slow, we'll go long
                if (FirstSimpleMovingAveragePeriod > SecondSimpleMovingAveragePeriod * (1 + tolerance))
                {
                    Log("BUY  >> " + Securities[symbolData.Symbol].Price);
                    SetHoldings(symbolData.Symbol, 1.0);
                }
            }
            
            // we only want to liquidate if we're currently long
            // if the fast is less than the slow we'll liquidate our long
            //if (_fast < _slow)
            if (holdings > 0 && FirstSimpleMovingAveragePeriod < SecondSimpleMovingAveragePeriod)
            {
                Log("SELL >> " + Securities[symbolData.Symbol].Price);
                //SetHoldings(_symbol, -1.0);
                Liquidate(symbolData.Symbol);
            }

//            Plot(symbolData.Symbol, "Price", data[symbolData.Symbol].Price);

            // easily plot indicators, the series name will be the name of the indicator
//            Plot(symbolData.Symbol, FirstSimpleMovingAveragePeriod, SecondSimpleMovingAveragePeriod);
            //Plot("Ribbon", _ribbon);
            
            
            

//            _previous = Time;
        }
    }
}
        		    
        	
        	
//            // 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 (!Portfolio[symbolData.Symbol].Invested)
//                   {
//                        MarketOrder(symbolData.Symbol, 1);
//                   }
//               }
//            }
//        }
 














        /// <summary>
        /// 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).
        /// </summary>
        /// <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, kvp.Value.SMA);
//               }
//            }
//        }

        /// <summary>
        /// Contains data pertaining to a symbol in our algorithm
        /// </summary>
        public class SymbolData
        {
            /// <summary>
            /// This symbol the other data in this class is associated with
            /// </summary>
            public readonly string Symbol;
            /// <summary>
            /// The security type of the symbol
            /// </summary>
            public readonly SecurityType SecurityType;
            /// <summary>
            /// 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)
            /// </summary>
            public readonly RollingWindow<TradeBar> Bars;
            /// <summary>
            /// The period used when population the Bars rolling window.
            /// </summary>
            public readonly TimeSpan BarPeriod;
            /// <summary>
            /// The simple moving average indicator for our symbol
            /// </summary>
            public SimpleMovingAverage SMA;

            /// <summary>
            /// Initializes a new instance of SymbolData
            /// </summary>
            public SymbolData(string symbol, SecurityType securityType, TimeSpan barPeriod, int windowSize)
            {
                Symbol = symbol;
                SecurityType = securityType;
                BarPeriod = barPeriod;
                Bars = new RollingWindow<TradeBar>(windowSize);
            }

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

            /// <summary>
            /// 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
            /// </summary>
            /// <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;
            }
        }
    }