from clr import AddReference
AddReference("System")
AddReference("QuantConnect.Algorithm")
AddReference("QuantConnect.Algorithm.Framework")
AddReference("QuantConnect.Common")

from System import *
from QuantConnect import *
from QuantConnect.Orders import *
from QuantConnect.Algorithm import *
from QuantConnect.Algorithm.Framework import *
from QuantConnect.Algorithm.Framework.Alphas import *
from QuantConnect.Algorithm.Framework.Portfolio import *
from QuantConnect.Algorithm.Framework.Selection import *
from QuantConnect.Data.UniverseSelection import * 
from QuantConnect.Indicators import ExponentialMovingAverage 
from Portfolio.EqualWeightingPortfolioConstructionModel import EqualWeightingPortfolioConstructionModel
from Alphas.ConstantAlphaModel import ConstantAlphaModel
from Execution.ImmediateExecutionModel import ImmediateExecutionModel
from Risk.MaximumSectorExposureRiskManagementModel import MaximumSectorExposureRiskManagementModel
from itertools import chain 
from math import ceil 
from datetime import timedelta
import numpy as np
import pandas as pd
from scipy import stats
import math

class BasicTemplateFrameworkAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.UniverseSettings.Resolution = Resolution.Daily
        self.AddEquity("SPY")
        

        self.SetStartDate(2017,2,1)   #Set Start Date
        self.SetEndDate(2017,3,1)    #Set End Date
        self.SetCash(100000)      #Set Strategy Cash
        self.lastMonth = -1
        
        self.AddUniverse(self.SelectCoarse, self.SelectFine)
        
        self.NumberOfSymbolsCoarse = 10 
        self.dollarVolumeBySymbol = {}
        self.symbols = []
        
        
        self.Schedule.On(self.DateRules.WeekStart("SPY"), self.TimeRules.AfterMarketOpen("SPY", 1), self.ViewUniverse)
        
      
        
    def ViewUniverse(self):
        editted_symbol_list = []
        universe = self.UniverseManager.Values[0]
            
        self.symbol_list = []
        symbols = universe.Members.Keys
            
        for symbol in symbols:
            self.symbol_list.append(symbol.Value)
            self.AddEquity(symbol.Value)
        
            
        if len(self.symbol_list) == 0:
            self.Log("empty")
        else:
            historical_data = self.History(self.symbol_list,30, Resolution.Daily)
            for j in range (0,len(self.symbol_list)):
                self.score = 0
                try:
                    stock_data = historical_data.loc[self.symbol_list[j]]["close"]
                    self.Log(self.symbol_list[j])
                    self.Log(stock_data)
                except:
                    self.Log("No data for stock")
            
        
        
    def SelectCoarse(self, coarse):
        coarse = list(coarse)

        if len(coarse) == 0:
            return self.symbols

        month = coarse[0].EndTime.month
        if month == self.lastMonth:
            return self.symbols

        self.lastMonth = month

        # The stocks must have fundamental data
        # The stock must have positive previous-day close price
        # The stock must have positive volume on the previous trading day
        filtered = [x for x in coarse if x.HasFundamentalData
                                      and x.Volume > 0
                                      and x.Price > 0]
        # sort the stocks by dollar volume and take the top 1500
        top = sorted(filtered, key=lambda x: x.DollarVolume, reverse=True)[:self.NumberOfSymbolsCoarse]

        self.dollarVolumeBySymbol = { i.Symbol: i.DollarVolume for i in top }

        self.symbols = list(self.dollarVolumeBySymbol.keys())

        return self.symbols


    def SelectFine(self, fine):

        filteredFine = [x for x in fine if x.CompanyReference.CountryId == "USA"
                                        and (x.CompanyReference.PrimaryExchangeID == "NYS" or x.CompanyReference.PrimaryExchangeID == "NAS")
                                        and x.EarningReports.BasicAverageShares.ThreeMonths * x.EarningReports.BasicEPS.TwelveMonths * x.ValuationRatios.PERatio > 5e8]
        count = len(filteredFine)
        if count == 0: return []

        
        self.symbols = [f.Symbol for f in filteredFine]

        return self.symbols