namespace QuantConnect.Algorithm.CSharp
{
    public class UPROSim : QCAlgorithm
    {
    	private decimal _lastBenchmarkValue;
    	private decimal _benchmarkPerformance;
    	
    	private const string EquityToLeverage = "SPY";
    	private const string BenchmarkEquity = "UPRO";
    	private const decimal LeverageFactor = 3.0m;
    	
        public override void Initialize()
        {
            SetStartDate(2009, 7, 1);
            SetCash(100000);

			var spy = AddEquity(EquityToLeverage, Resolution.Minute);
			spy.SetFeeModel(new ExpenseRatioFeeModel(this));
            spy.SetLeverage(LeverageFactor);
            
            AddEquity(BenchmarkEquity, Resolution.Minute);
        	SetBenchmark(BenchmarkEquity);
        	
	        // Inital benchmark value scaled to match our portfolio
    	    _benchmarkPerformance = Portfolio.TotalPortfolioValue;
        }

        public override void OnData(Slice data)
        {
            if (!Portfolio.Invested)
            {
                SetHoldings(EquityToLeverage, LeverageFactor);
            }
        }
        
        public override void OnEndOfDay(string symbol)
        {
        	// store the current benchmark close price
        	var benchmark = Securities["UPRO"].Price;
        	
        	Liquidate(symbol);
        	
        	// Calculate the performance of our benchmark and update our benchmark value for plotting
        	if (_lastBenchmarkValue != default)
        	{
        		_benchmarkPerformance = _benchmarkPerformance * ( benchmark / _lastBenchmarkValue);
        	}

        	// store today's benchmark close price for use tomorrow
        	_lastBenchmarkValue = benchmark;
        
        	// Render plots
        	Plot("UPRO-SIM vs UPRO", "UPRO-SIM", Portfolio.TotalPortfolioValue);
        	Plot("UPRO-SIM vs UPRO", "UPRO", _benchmarkPerformance);
        }

		private class ExpenseRatioFeeModel : FeeModel
		{
			private const decimal ExpenseRatio = 0.0093m;
			private const int TradingDaysPerYear = 252;
			
			private QCAlgorithm _algorithm;
			
			public ExpenseRatioFeeModel(QCAlgorithm algorithm)
			{
				_algorithm = algorithm;
			}
			
			public override OrderFee GetOrderFee(OrderFeeParameters parameters)
			{
				if (parameters.Order.Direction == OrderDirection.Buy)
				{
					var dailyExpenseRatio = ExpenseRatio / TradingDaysPerYear;
					var dailyFee = _algorithm.Portfolio.Cash * dailyExpenseRatio;
					return new OrderFee(new CashAmount(Math.Abs(dailyFee), "USD"));
				}
				else
				{
					return OrderFee.Zero;
				}
			}
		}
    }
}