using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Net;
using QuantConnect.Brokerages;
using QuantConnect.Data.Consolidators;
using QuantConnect.Data.Market;
using QuantConnect.Indicators;
using QuantConnect.Data;
using QuantConnect.Orders;
using QuantConnect.Securities;

namespace QuantConnect.Algorithm.CSharp
{
    /// <summary>
    /// This example demonstrates how to add futures for a given underlying asset.
    /// It also shows how you can prefilter contracts easily based on expirations, and how you
    /// can inspect the futures chain to pick a specific contract to trade.
    /// </summary>
    /// <meta name="tag" content="using data" />
    /// <meta name="tag" content="benchmarks" />
    /// <meta name="tag" content="futures" />
    public class BasicTemplateFuturesAlgorithm : QCAlgorithm
    {
        // S&P 500 EMini futures
        private const string RootSP500 = Futures.Indices.SP500EMini;
        public Symbol SP500 = QuantConnect.Symbol.Create(RootSP500, SecurityType.Future, Market.USA);

        // Gold futures
        private const string RootGold = Futures.Metals.Gold;
        public Symbol Gold = QuantConnect.Symbol.Create(RootGold, SecurityType.Future, Market.USA);

        private const string RootCrudeOil = Futures.Energies.CrudeOilWTI;
		public Symbol CrudeOil = QuantConnect.Symbol.Create(RootCrudeOil, SecurityType.Future, Market.USA);

	    public Chart Price_Chart = new Chart("Price");
        /// <summary>
        /// Initialize your algorithm and add desired assets.
        /// </summary>
        public override void Initialize()
        {
            SetStartDate(2016, 10, 07);
            SetEndDate(DateTime.Now);
            SetCash(1000000);

            // var futureSP500 = AddFuture(RootSP500);
            // var futureGold = AddFuture(RootGold);
            var futureCrude = AddFuture(RootCrudeOil);
            
			Price_Chart.AddSeries(new Series("Close", SeriesType.Line, string.Empty, Color.Black));
			Price_Chart.AddSeries(new Series("High", SeriesType.Line, string.Empty, Color.Lime));
			Price_Chart.AddSeries(new Series("Low", SeriesType.Line, string.Empty, Color.Red));
			AddChart(Price_Chart);

            // set our expiry filter for this futures chain
            // futureSP500.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
            // futureGold.SetFilter(TimeSpan.Zero, TimeSpan.FromDays(182));
            futureCrude.SetFilter(TimeSpan.Zero,TimeSpan.FromDays(40));

            var benchmark = AddEquity("SPY");
            SetBenchmark(benchmark.Symbol);
        }

        /// <summary>
        /// Event - v3.0 DATA EVENT HANDLER: (Pattern) Basic template for user to override for receiving all subscription data in a single event
        /// </summary>
        /// <param name="slice">The current slice of data keyed by symbol string</param>
        public override void OnData(Slice slice)
        {
        	Console.Write("Futures Chains: " + slice.FutureChains.Count);
        	bool Has_Data = false;
        	// var nearestContract;
        	if (slice.FutureChains.ContainsKey(CrudeOil)) {
	        	var Crude_Oil_Chain = slice.FutureChains[CrudeOil];
				var contracts = Crude_Oil_Chain.OrderBy(x => x.Expiry);
		        var nearestContract = contracts.FirstOrDefault();
        		Has_Data = true;
				if (Has_Data
				&& nearestContract != null
				&& nearestContract.LastPrice != null) {
					if (nearestContract.Time.Minute == 0 
					&& nearestContract.Time.Hour == 9) {
			        	Console.Write("Nearest Contract Price: " + nearestContract.LastPrice + " " + 
			        	nearestContract.Symbol + " Time: " + nearestContract.Time + " Expiry: " 
			        	+ nearestContract.Expiry);
					}
					if (nearestContract.Time.Minute == 0) {
			        	Plot("Price", "High", nearestContract.AskPrice);
			        	Plot("Price", "Close", nearestContract.LastPrice);
			        	Plot("Price", "Low", nearestContract.BidPrice);
					}
				}
        	}
            foreach(var chain in slice.FutureChains) {
            	// Console.Write("Chain: " + chain);
            	// Console.Write("Chain Symbol: " + chain.Value.Symbol);
            }
            if (!Portfolio.Invested)
            {
                foreach(var chain in slice.FutureChains)
                {
                    // find the front contract expiring no earlier than in 90 days
                    var contract = (
                        from futuresContract in chain.Value.OrderBy(x => x.Expiry)
                        where futuresContract.Expiry > Time.Date.AddDays(90)
                        select futuresContract
                        ).FirstOrDefault();

                    // if found, trade it
                    if (contract != null)
                    {
                        MarketOrder(contract.Symbol, 1);
                    }
                }
            }
            else
            {
                Liquidate();
            }
        }

        /// <summary>
        /// Order fill event handler. On an order fill update the resulting information is passed to this method.
        /// </summary>
        /// <param name="orderEvent">Order event details containing details of the evemts</param>
        /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
        public override void OnOrderEvent(OrderEvent orderEvent)
        {
            Log(orderEvent.ToString());
        }
    }
}