import numpy as np


class RegionalETFrotationAlgorithm(QCAlgorithm):
    
    def Initialize(self):
        self.changes = None
        self.growth = {}
        
        self.SetStartDate(2011, 1, 5)  #Set Start Date
        self.SetEndDate(2011, 6 ,5)    #Set End Date
        self.SetCash(100000)           #Set Strategy Cash
        
        self.UniverseSettings.Resolution = Resolution.Daily
        
        self.AddUniverse(self.CoarseSelectionFunction)
        
        self.AddEquity("EDV", Resolution.Daily)
        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol
        
            
        #self.etf = self.growth[0]
        self.current = []
        self.top = []
        self.Schedule.On(self.DateRules.MonthStart(self.spy), self.TimeRules.AfterMarketOpen(self.spy,5), self.rebalance)
        
    def OnSecuritiesChanged(self, changes):
        self.Debug("enter changes")
        self.changes = changes
        for ticker in self.changes.AddedSecurities:
            self.growth[ticker.Symbol] = self.MACD(ticker.Symbol,12, 26, 9, MovingAverageType.Exponential, Resolution.Daily)

    def OnData(self, data):
        if self.changes is None:
            return
        else:
            for universe in self.UniverseManager.Values:
                if universe is UserDefinedUniverse:
                    self.tickers = universe.Members.Keys
                    for symbol in self.tickers:
                        self.Debug(symbol.Symbol.Value)

    #    if self.etf[1].Current.Value < 0:
    #        self.rebalance()
    #    if not self.Portfolio.Invested:
    #       self.rebalance()
    #    self.Log(len(self.current))
    #    for etf in self.current:
    #        if etf[1].Current.Value < 0:
    #            self.replace(etf)
    #    pass
    
    
    def replace(etf):
        self.SetHoldings(etf[0], 0)
        self.current.remove(etf)
        for security in self.top:
            if security in self.current:
                continue
            else:
                if security[1].Current.Value > 0:
                    self.current.append(security)
                    self.SetHoldings(security, 0.2)
        
            
    def CoarseSelectionFunction(self, coarse):
        etfs = list(coarse)
        return [ x.Symbol for x in etfs if x.HasFundamentalData==False ]    
    

      
    def rebalance(self):
        #self.current = self.growth
        #self.current.sort(key=self.getMomentum, reverse = True)
        #self.etf = self.current[0]
        
       # if self.etf[1].Current.Value > 0:
       #    if self.Portfolio.Invested and not self.Portfolio[self.etf[0]].Invested:
        #       self.Liquidate()
         #  self.SetHoldings(self.etf[0], 1)
           
    #   else:
     #     if self.Portfolio.Invested:
      #         self.Liquidate()
       #    self.SetHoldings("EDV", 1)
       self.Liquidate()
       self.top = []
       for etf in self.growth:
           if self.growth[etf].Current.Value > 0:
               self.top.append(etf)
       self.current.sort(key=self.getMomentum, reverse = True)          
       if len(self.top) ==0:
           self.SetHoldings("EDV", 1)
       else:
           self.SetHoldings(self.top[0], 0.2)
           self.SetHoldings(self.top[1], 0.2)
           self.SetHoldings(self.top[2], 0.2)
           self.SetHoldings(self.top[3], 0.2)
           self.SetHoldings(self.top[4], 0.2)
            
    def getMomentum(self,elem):
        return elem[1]