from Selection.QC500UniverseSelectionModel import QC500UniverseSelectionModel

class CalibratedOptimizedCompensator(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2017, 1, 1)  # Set Start Date
        self.SetCash(1000000)  # Set Strategy Cash
        
        spy = [Symbol.Create("SPY", SecurityType.Equity, Market.USA)]
        
        # Set QC500 Universe Selection Model
        self.SetUniverseSelection(QC500UniverseSelectionModel())
        self.UniverseSettings.Resolution = Resolution.Daily
        
        # Quality Companies Alpha 
        self.SetAlpha(QualityCompaniesAlpha())
            
        # Equally weigh securities in portfolio, based on insights
        self.SetPortfolioConstruction(EqualWeightingPortfolioConstructionModel())

        # Set Immediate Execution Model
        self.SetExecution(ImmediateExecutionModel())

        # Set Null Risk Management Model
        self.SetRiskManagement(NullRiskManagementModel())
        
class QualityCompaniesAlpha(AlphaModel): 
    def __init__(self):
        self.SecData = {}
        self.selected = []
        self.month = -1
        
    def Update(self, algorithm, data):
        # only trade once a month a few days before months end
        d1 = (algorithm.Time.day != 24)
        d2 = (algorithm.Time.day != 25) 
        d3 = (algorithm.Time.day != 26)
        if d1 or d2 or d3: 
            return 
        
        if self.month == algorithm.Time.month: 
            return
        
        self.month = algorithm.Time.month
        
        # initialize insights 
        insights = []
        
        # SPY change should be positive 
        spyhist = algorithm.History(spy, 140, Resolution.Daily)
        spychange = spyhist.close.pct_change(periods=139)[-1]
        
        if spychange > 0: 
            self.selected = self.SelectStocks(data)
        else: 
            return insights 
        
        for kvp in algorithm.Portfolio:
            symbol = kvp.Key
            holding = kvp.Value
            if symbol not in self.selected and holding.Invested:
                insights.append(Insight.Price(symbol, timedelta(30), InsightType.Price, InsightDirection.Flat, None, None))
        
        for symbol in self.selected:
            if not algorithm.Portfolio[symbol].Invested:
                insights.append(Insight.Price(symbol, timedelta(30), InsightType.Price, InsightDirection.Up, None, None))
        
        return insights
    
    def OnSecuritiesChanged(self, algorithm, changes):
        for security in changes.AddedSecurities:
            symbol = security.Symbol
            if symbol not in self.SecData:
                # adds filter criteria
                self.SecData[symbol] = SecurityData(algorithm, symbol, security)
                
    def SelectStocks(self, data):
        # Sort by ROIC
        sortedByROIC = sorted(list(self.SecData.keys()), key=lambda k : self.SecData[k].roic, reverse=True)
        
        # Sorted by MOM
        sortedByMOM = sorted(sortedByROIC[:50], key=lambda k : self.SecData[k].mom.Current.Value, reverse=True)
        
        # Select top 20 symbols
        return sortedByMOM[:20]
        
class SecurityData: 
    def __init__(self, algorithm, symbol, security): 
        # general 
        self.algorithm = algorithm
        self.symbol = symbol
        self.security = security
        # adds filter criteria
        self.roic = security.Fundamentals.OperationRatios.ROIC.OneYear
        self.mom = algorithm.MOM(symbol, 126, Resolution.Daily)
        
        # Initialize MOM indicator with historical data
        history = algorithm.History(symbol, 126, Resolution.Daily)
        if not history.empty:
            history = history.close.unstack(0)
            if not history.empty:
                df = history[symbol]
                for time, close in df.iteritems():
                    self.mom.Update(time, close)