class MultidimensionalOptimizedRadiator(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2019, 1, 1)  # Set Start Date
        self.SetEndDate(2020,1,1)       # Set End Date
        self.SetCash(100000)  # Set Strategy Cash default in USD
        self.symbol = "BTCUSD"
        self.lever = 5         # leverage

        # Adding the symbol
        self.AddCrypto(self.symbol, Resolution.Minute).SetDataNormalizationMode(DataNormalizationMode.Raw) #.SetLeverage(self.lever)
        
        
        # SetBrokerageModel
        self.SetBrokerageModel(BrokerageName.GDAX, AccountType.Cash)
        
        # set benchmark
        self.SetBenchmark(self.symbol)
        
        # tradingview inputs
        self.oRes    = 120                      #"Orange MA Timeframe"
        self.oLen    = 200                      #"Orange MA Length") 
        self.oPos    = 962/1000                 #"Orange MA Position"
        self.bLen    = 180                      #"Blue MA Length"
        self.spread  = 20/10000                 #"Blue MA Spread"
        self.tp      = .9/100                   #"Take Profit %"
        self.tf      = 5                        # "Time frame"
        
        
        #ap      = strategy.position_avg_price
        
        self.consolidator1 = TradeBarConsolidator(timedelta(minutes=self.tf))   # small timeframe consolidator
        self.consolidator2 = TradeBarConsolidator(timedelta(minutes=self.oRes)) # large timeframe consolidator
        
        # Generate Large timeframe HMA
        self.oMa = HullMovingAverage(self.symbol,self.oLen)                     #oMa     = hma(close[1], oLen)*oPos
        self.RegisterIndicator(self.symbol,self.oMa,self.consolidator2)
        self.oAll = IndicatorExtensions.Times(self.oMa,self.oPos )              #*self.oPos # HMA*orange ma position #oAll    = security(syminfo.tickerid, oRes, oMa[1], barmerge.gaps_off, barmerge.lookahead_off)
        self.SetWarmUp(50, Resolution.Daily)
        
        # creating Small timeframe HMA
        self.b_general = HullMovingAverage(self.symbol,self.bLen)
        self.RegisterIndicator(self.symbol,self.b_general,self.consolidator1)
        
        #  Blue MA Positions
        self.r1Pos   = 980/1000                 #"Open Position 1"
        self.r2Pos   = self.r1Pos-self.spread
        self.r3Pos   = self.r2Pos-self.spread
        self.r4Pos   = self.r3Pos-self.spread
        self.r5Pos   = self.r4Pos-self.spread
        self.r6Pos   = self.r5Pos-self.spread
        self.r7Pos   = self.r6Pos-self.spread
        self.r8Pos   = self.r7Pos-self.spread
        self.r9Pos   = self.r8Pos-self.spread
        self.r10Pos  = self.r9Pos-self.spread
        
        # EMA Calcs for Blue MA's
        self.b1      = IndicatorExtensions.Times(self.b_general,self.r1Pos )
        self.b2      = IndicatorExtensions.Times(self.b_general,self.r2Pos )
        self.b3      = IndicatorExtensions.Times(self.b_general,self.r3Pos )
        self.b4      = IndicatorExtensions.Times(self.b_general,self.r4Pos )
        self.b5      = IndicatorExtensions.Times(self.b_general,self.r5Pos )
        self.b6      = IndicatorExtensions.Times(self.b_general,self.r6Pos )
        self.b7      = IndicatorExtensions.Times(self.b_general,self.r7Pos )
        self.b8      = IndicatorExtensions.Times(self.b_general,self.r8Pos )
        self.b9      = IndicatorExtensions.Times(self.b_general,self.r9Pos )
        self.b10      = IndicatorExtensions.Times(self.b_general,self.r10Pos )
        self.SetWarmUp(50, Resolution.Daily)

    def OnData(self, data):
        '''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
            Arguments:
                data: Slice object keyed by symbol containing the stock data
        '''
        
        # Checking if the indicator is ready:
        if not self.oAll.IsReady:
            return
        if not self.b1.IsReady:
            return
        if not self.b2.IsReady:
            return
        if not self.b3.IsReady:
            return
        if not self.b4.IsReady:
            return
        if not self.b5.IsReady:
            return
        if not self.b6.IsReady:
            return
        if not self.b7.IsReady:
            return
        if not self.b8.IsReady:
            return
        if not self.b9.IsReady:
            return
        if not self.b10.IsReady:
            return
        
        # setting current values to the variables
        oAll_value = self.oAll.Current.Value
        b1_value = self.b1.Current.Value
        b2_value = self.b2.Current.Value
        b3_value = self.b3.Current.Value
        b4_value = self.b4.Current.Value
        b5_value = self.b5.Current.Value
        b6_value = self.b6.Current.Value
        b7_value = self.b7.Current.Value
        b8_value = self.b8.Current.Value
        b9_value = self.b9.Current.Value
        b10_value = self.b10.Current.Value
        
        # Take Profit / Close Position / No Position Allowed
        # tPro    = ap+ap*tp
        # cPos    = close<oAll
        # noPos   = low<oAll or b10<=oAll
        
        # calculate order quantity per order
        quantity = self.CalculateOrderQuantity(self.symbol, 0.1)
        
        # check if price(low) is greater than orange HMA and b10 is greater than orange HMA
        if data[self.symbol].Ask.Low > oAll_value and b10_value > oAll_value :
            
        # placing 10 limit orders with stoploss and saving order tickets
            if  (self.Portfolio.MarginRemaining/10) > b1_value:
                ticket_b1 = self.LimitOrder(self.symbol, self.Portfolio.MarginRemaining/(10*b3_value)*.9, b1_value)
            elif (self.Portfolio.MarginRemaining/9) > b2_value:
                ticket_b2 = self.LimitOrder(self.symbol, self.Portfolio.MarginRemaining/(9*b2_value)*.9, b2_value)
            elif  (self.Portfolio.MarginRemaining/8) > b3_value:
                ticket_b3 = self.LimitOrder(self.symbol, self.Portfolio.MarginRemaining/(8*b3_value)*.9, b3_value)
            elif (self.Portfolio.MarginRemaining/7) > b4_value:
                ticket_b4 = self.LimitOrder(self.symbol, self.Portfolio.MarginRemaining/(7*b4_value)*.9, b4_value)
            elif (self.Portfolio.MarginRemaining/6) > b5_value:
                ticket_b5 = self.LimitOrder(self.symbol, self.Portfolio.MarginRemaining/(6*b5_value)*.9, b5_value)
            elif (self.Portfolio.MarginRemaining/5) > b6_value:
                ticket_b6 = self.LimitOrder(self.symbol, self.Portfolio.MarginRemaining/(5*b6_value)*.9, b6_value)
            elif (self.Portfolio.MarginRemaining/4) > b7_value:
                ticket_b7 = self.LimitOrder(self.symbol, self.Portfolio.MarginRemaining/(4*b7_value)*.9, b7_value)
            elif (self.Portfolio.MarginRemaining/3) > b8_value:
                ticket_b8 = self.LimitOrder(self.symbol, self.Portfolio.MarginRemaining/(3*b8_value)*.9, b8_value)
            elif (self.Portfolio.MarginRemaining/2) > b9_value:
                ticket_b9 = self.LimitOrder(self.symbol, self.Portfolio.MarginRemaining/(2*b9_value)*.9, b9_value)
            elif self.Portfolio.MarginRemaining > b10_value:
                ticket_b10 = self.LimitOrder(self.symbol, self.Portfolio.MarginRemaining/b10_value*.9, b10_value)
            else:
                pass
        
        # stop loss at orange HMA
        if data[self.symbol].Bid.Open <= oAll_value:
            self.Liquidate()
        
        
        #take profit
        if data[self.symbol].Bid.Open >= b1_value*(1+self.tp) and self.Portfolio.Invested:
            self.Liquidate()