class FocusedSkyBlueGalago(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2019, 1, 1)

        self.InitCash = 5000
        self.SetCash(self.InitCash)
        self.AddEquity("SPY", Resolution.Minute)
        
        
        
        # Options Parameters ===================================
        spy = self.AddEquity("SPY", Resolution.Minute)
        qqq = self.AddEquity("QQQ", Resolution.Minute)
        tqqq = self.AddEquity("TQQQ", Resolution.Minute)
        spy.SetDataNormalizationMode(DataNormalizationMode.Raw)
        qqq.SetDataNormalizationMode(DataNormalizationMode.Raw)
        tqqq.SetDataNormalizationMode(DataNormalizationMode.Raw)
        self.spy = spy.Symbol
        self.qqq = qqq.Symbol
        self.tqqq = tqqq.Symbol
        self.spycontract = None
        self.tqqqcontract = None

        
        # Rebalance beginning of every month =======================
        self.Schedule.On(self.DateRules.MonthStart("SPY"), self.TimeRules.AfterMarketOpen("SPY", 1), self.monthlyRebalance)
        self.Schedule.On(self.DateRules.EveryDay("SPY"), self.TimeRules.AfterMarketOpen("SPY", 1), self.captureSpy)
        
        #Variables used in stoploss=================================
        self.stoplosshold = 0
        self.dailythresh = 0
        
        #Graphing Benchmark 
        # Graphing SPY Benchmark =================
        
    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
        '''
        if self.IsWarmingUp:
            return
        
        
        # SPY HEDGE
        if self.spycontract is None:
            self.spycontract = self.GetSpy()
            self.tqqqcontract = self.GetTqqq()
            x= 0 
            return
        
        #Since SPY is the most liquid asset, we're basing our exercise actions on it
        if (self.spycontract.ID.Date - self.Time).days < 180:
            
            self.Liquidate(self.spycontract)
            self.RemoveSecurity(self.spycontract)
            self.spycontract = None
            
            self.Liquidate(self.tqqqcontract)
            self.RemoveSecurity(self.tqqqcontract)
            self.tqqqcontract = None
            return
        
        if not self.Portfolio[self.spycontract].Invested:
            self.SetHoldings(self.spycontract, 0.04)
        if not self.Portfolio[self.tqqqcontract].Invested:
            self.SetHoldings(self.tqqqcontract,  0.01)
        
        #Exercixe our option when they increase in value 
        if  self.Securities[self.spy].Price < self.spycontract.ID.StrikePrice * 1.20:
            self.Liquidate(self.spycontract)
            self.RemoveSecurity(self.spycontract)
            self.Liquidate(self.tqqqcontract)
            self.RemoveSecurity(self.tqqqcontract)
    
        
        
        
        if self.stoplosshold == 1:
            return
        else:
            if not self.Portfolio.Invested:
                self.SetHoldings(self.spy, .60)
                self.SetHoldings(self.qqq, .34)
                self.SetHoldings(self.tqqq, .01)
        
        
        if self.stoplosshold == 1: 
            return
        else:
            self.stoploss(data) # change 2


    def GetSpy(self):
        # Target strike as 40% OTM long put 
        targetStrike = (self.Securities[self.spy].Price * 0.60) - (self.Securities[self.spy].Price * 0.60)%5
        contracts = self.OptionChainProvider.GetOptionContractList(self.spy, self.Time)
        puts = [x for x in contracts if x.ID.OptionRight == OptionRight.Put]
        puts = sorted( sorted(puts, key = lambda x: x.ID.Date, reverse = True),
                       key = lambda x: x.ID.StrikePrice)
        puts = [x for x in puts if x.ID.StrikePrice == targetStrike]
        puts = [x for x in puts if 270 < (x.ID.Date - self.Time).days <= 420]
        if len(puts) == 0:
            self.Log("No Puts")
            return None
        self.AddOptionContract(puts[0], Resolution.Minute)
        return puts[0]

    def GetTqqq(self):
        # Target strike as 40% OTM long put 
        targetStrike = (self.Securities[self.tqqq].Price * 0.60) - (self.Securities[self.tqqq].Price * 0.60)%5
        contracts = self.OptionChainProvider.GetOptionContractList(self.tqqq, self.Time)
        puts = [x for x in contracts if x.ID.OptionRight == OptionRight.Put]
        puts = sorted( sorted(puts, key = lambda x: x.ID.Date, reverse = True),
                       key = lambda x: x.ID.StrikePrice)
        puts = [x for x in puts if x.ID.StrikePrice == targetStrike]
        puts = [x for x in puts if 270 < (x.ID.Date - self.Time).days <= 420]
        if len(puts) == 0:
            self.Log("No Puts")
            return None
        self.AddOptionContract(puts[0], Resolution.Minute)
        return puts[0]

    def captureSpy(self):
        if self.CurrentSlice.Bars.ContainsKey(self.spy):
            self.dailythresh = self.CurrentSlice[self.spy].Open
            self.stoplosshold = 0
            return
          
            
    def monthlyRebalance(self):
        '''
        Now I need to rebalance portfolio on a monthly basis
        '''
        if self.IsWarmingUp:
            return
        
        self.SetHoldings(self.spy, 0.60)
        self.SetHoldings(self.qqq, 0.35)
        return   
    
    
    def stoploss(self, data):
        '''
        Stoploss logic:
            1. If spy drops more than 5% liquidate entire equity portfolio
            2. Change stoplosshold value to 1, this indicates that the portfolios SL has been hit 
            and were going to hold until the next trading day
        '''
        if self.IsWarmingUp:
            return
        if self.CurrentSlice.Bars.ContainsKey(self.spy):
            #self.Debug((self.dailythresh - self.CurrentSlice[self.spy].Close)/self.CurrentSlice[self.spy].Close)
            if ((self.dailythresh - self.CurrentSlice[self.spy].Open)/self.dailythresh) < -.05:
                self.SetHoldings(self.spy, 0)
                self.SetHoldings(self.qqq, 0)
                self.stoplosshold = 1