//Copyright HardingSoftware.com. Granted to the public domain.
//Use entirely at your own risk.
using System;
using System.Collections.Generic;
using System.Linq;
using QuantConnect.Data.Market;
using QuantConnect.Data.UniverseSelection;

namespace QuantConnect.Algorithm.CSharp
{
    public class Flock : QCAlgorithm
    {
		List<StockData> HighDollarVolumeStocks = new List<StockData>();
		int TotalHighDollarVolumeStocks = 250;
		int TotalStocksToHold = 10;
		Resolution Resolution = Resolution.Daily;
		int Period = 5;
		decimal Leverage = 0.99m;
		decimal Threshold = 0.0m;
		
        public override void Initialize()
        {
            UniverseSettings.Resolution = Resolution;

            SetStartDate(2019, 9, 27);
            SetCash(100000);

            AddUniverse(coarse =>
            {
            	return (from stock in coarse
            			where stock.Symbol.ToString().Substring(0, 3) != "GME"
            			where stock.Symbol.ToString().Substring(0, 3) != "AMC"
            			where stock.Symbol.ToString().Substring(0, 4) != "UVXY"
            			//where stock.HasFundamentalData == false
            			orderby stock.DollarVolume descending  
            			select stock.Symbol).Take(TotalHighDollarVolumeStocks);
            });
        }

        public void OnData(TradeBars data)
        {
            foreach (StockData stockData in HighDollarVolumeStocks)
            {
            	if (data.ContainsKey(stockData.Symbol))
            	{
	            	TradeBar bar = data[stockData.Symbol];
	            	stockData.Candles.Add(bar);
	            	if (stockData.Candles.Count > Period)
	            	{
	            		stockData.Candles.RemoveAt(0);
	            	}
            	}
            }
            
            foreach (StockData stockData1 in HighDollarVolumeStocks)
            {
        	    List<TradeBar> candles1 = stockData1.Candles;
                decimal[] prices1 = candles1.Select(x => x.Close).ToArray();
                decimal averagePrice1 = prices1.Average();
                decimal[] normalizedPrices1 = prices1.Select(x => x / averagePrice1).ToArray();
                decimal sumRatios = 0;
                foreach (StockData stockData2 in HighDollarVolumeStocks)
                {
                	if (stockData1 != stockData2)
                	{
	                    List<TradeBar> candles2 = stockData2.Candles;
	                    decimal[] prices2 = candles2.Select(x => x.Close).ToArray();
	                    decimal averagePrice2 = prices2.Average();
	                    decimal[] normalizedPrices2 = prices2.Select(x => x / averagePrice2).ToArray();
	                    decimal[] differences = normalizedPrices1.Zip(normalizedPrices2, (x, y) => x - y).ToArray();
	                    decimal maxDifference = differences.Max();
	                    decimal minDifference = differences.Min();
	                    decimal differenceRange = maxDifference - minDifference;
	                    decimal currentDifference = normalizedPrices1.Last() - normalizedPrices2.Last();
	                    if (differenceRange != 0)
	                    {
		                    decimal ratio = currentDifference / differenceRange;
		                    sumRatios += ratio;
	                    }
                	}
                }
                stockData1.AverageRatio = sumRatios / (HighDollarVolumeStocks.Count - 1);
            }
            
            List<StockData> stocksToHold = HighDollarVolumeStocks.OrderByDescending(x => Math.Abs(x.AverageRatio)).Take(TotalStocksToHold).ToList();
            
            foreach (var security in Portfolio.Values)
            {
            	if (Portfolio[security.Symbol].Invested)
            	{
	                if (stocksToHold.Exists(x => x.Symbol == security.Symbol) == false)
	                {
	                    Liquidate(security.Symbol);
	                }
            	}
            }
            
            foreach (StockData stockData in stocksToHold)
            {
                if (stockData.AverageRatio < -Threshold && Portfolio[stockData.Symbol].Quantity <= 0)
                {
                    SetHoldings(stockData.Symbol, Leverage / (decimal)TotalStocksToHold);
                }
                else if (stockData.AverageRatio > Threshold && Portfolio[stockData.Symbol].Quantity >= 0)
                {
					SetHoldings(stockData.Symbol, -Leverage / (decimal)TotalStocksToHold);
                }
            }

        }

		public class StockData
		{
			public Symbol Symbol;
			public List<TradeBar> Candles = new List<TradeBar>();
            public decimal AverageRatio;
		}

        public override void OnSecuritiesChanged(SecurityChanges changes)
        {
            foreach (var security in changes.RemovedSecurities)
            {
            	StockData stockData = HighDollarVolumeStocks.Find(x => x.Symbol == security.Symbol);
            	if (stockData != null)
            	{
                	HighDollarVolumeStocks.Remove(stockData);
            	}
            }
            foreach (var security in changes.AddedSecurities)
            {
            	StockData stockData = new StockData();
            	stockData.Symbol = security.Symbol;
            	stockData.Candles = History(stockData.Symbol, Period, Resolution).ToList();
				HighDollarVolumeStocks.Add(stockData);
            }
        }
        
    }
}