from QuantConnect.Algorithm import *
from QuantConnect.Securities.Option import OptionPriceModels

class BasicTemplateOptionsFilterUniverseAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2019, 1, 1)
        self.SetEndDate(2019, 1, 30)
        self.SetCash(100000)

        self.option = self.AddOption("AAPL")
        
        self.option.SetFilter(-1, +1, 1, 30) 
        self.option.PriceModel = OptionPriceModels.CrankNicolsonFD()
        self.SetWarmup(30, Resolution.Daily)
        
        self.Schedule.On(self.DateRules.EveryDay(), self.TimeRules.Every(timedelta(minutes=10)), self.PlotGreek)
        
    def OnData(self, slice):
        
        if self.IsWarmingUp or self.Portfolio.Invested:
            return 
        
        for symbol, chain in slice.OptionChains.items():
            contracts = [c for c in chain if c.Right == OptionRight.Call]
            if len(contracts) == 0:
                return

            sorted_contracts = sorted(contracts, key = lambda x: (x.Strike, x.Expiry), reverse=True)
            contract = sorted_contracts[0]
            self.MarketOrder(contract.Symbol, 1)
            
            
    def get_option_for_option_holding(self, symbol):
        for chain in self.CurrentSlice.OptionChains.Values:
            for opt in chain:
                if opt.Symbol == symbol:
                    return opt
                
    def get_option_holdings(self):
        options = []
        for holding in self.Portfolio.Values:
            if holding.Invested and holding.Type == SecurityType.Option:
                option = self.get_option_for_option_holding(holding.Symbol)
                if option is not None:
                    options.append((holding.Quantity, option))
        return options

    def PlotGreek(self):
        options = self.get_option_holdings()
        
        for quantity, option in options:
            self.Plot("Greeks", "Values", option.Greeks.Delta)