# region imports
from io import StringIO
from AlgorithmImports import *
from AlgorithmImports import Chart,ScatterMarkerSymbol,Resolution,DayOfWeek
import pickle
import datetime


# endregion

class CapitalMarketDays(QCAlgorithm):
    def Initialize(self):
        self.start_date_ = datetime.datetime(2023, 1, 1)
        self.end_date_ = datetime.datetime(2024, 1, 1)

        self.set_start_date(self.start_date_)
        self.set_end_date(self.end_date_)
        self.set_cash(5_000)
        
        # self.marketscreener_path = self.ObjectStore.get_file_path('market_screener_googlesheet')
        # self.df = pd.read_pickle(self.marketscreener_path)

        self.symbols_ = dict()

        # buying_dict_path = self.ObjectStore.get_file_path('buying_dict')
        buying_dict_path = self.ObjectStore.get_file_path('captial_market_days_buying_dict')
        # buying_dict_path = captial_market_days_buying_dict_path
        with open(buying_dict_path, 'rb') as f:
            self.buying_dict = pickle.load(f)

        for i,j in self.buying_dict.items():
            j['symbol'] = Symbol.Create(i, SecurityType.Equity,Market.USA)
         



        # self.add_universe(
        #     ScheduledUniverse(
        #         self.date_rules.every_day("SPY"), 
        #         self.TimeRules.At(8, 0), 
        #         self.select_symbols
        #     )

        #         )

        # self.schedule.on(
        #     self.date_rules.every_day(),
        #     self.time_rules.at(21,0),
        #     self.manual_buy_and_sell
        # )
        self.schedule.on(
            self.date_rules.every_day(),
            self.time_rules.at(12,0),
            self.manual_buy_and_sell
        )
        # self.schedule.on(
        #     self.date_rules.every_day(),
        #     self.time_rules.at(10,0),
        #     self.add_data_to_algo
        # )

        self.schedule.on(
            self.date_rules.every(DayOfWeek.MONDAY,DayOfWeek.THURSDAY),
            self.time_rules.at(13,0),
            self.logging
        )

        self.chart = Chart('custom_chart')
        self.add_chart(self.chart)
        self.add_series = []

        # for i in self.buying_dict.keys():
        s1 = Series('price',SeriesType.SCATTER)
        s2 = Series('buy',SeriesType.SCATTER, "$", Color.Green, ScatterMarkerSymbol.TRIANGLE)
        s3 = Series('sell',SeriesType.SCATTER, "$", Color.Red, ScatterMarkerSymbol.TRIANGLE)
        self.chart.add_series(s1)
        self.chart.add_series(s2)
        self.chart.add_series(s3)

    @staticmethod
    def parse_datetime(dt):
        return dt.strftime('%Y-%m-%d')

    # def select_symbols(self,dt):
    #     self.Log(f"The universe selection ran on {dt.strftime('%Y-%m-%d %H:%M:%S')}")
    #     dt_parsed = self.parse_datetime(dt)
    #     self.Log(f"{dt_parsed}")
    #     if dt_parsed in self.buying_dict.keys():
    #         self.Log(f"{self.buying_dict[dt_parsed]}")
        
    #         return [Symbol.Create(t, SecurityType.Equity, Market.USA) for  t in self.buying_dict[dt_parsed]]

    def manual_buy_and_sell(self):
        for i,j in self.buying_dict.items():
            symbol =j['symbol']
            symbol_str = str(symbol)

            if j['buy_on'] == self.parse_datetime(self.time):
                if symbol not in self.securities.keys():
                    self.debug(f"add_equity {str(symbol)}")
                    self.add_equity(symbol,Resolution.HOUR)
                    
            if j['sell_on'] == self.parse_datetime(self.time):
                self.log(f"Sell {i}") 
                if self.portfolio[symbol].invested:
                    self.liquidate(i)
                    self.log(f"liquidate {i}") 
                    self.remove_security(symbol)
                    self.plot("custom_chart",'sell', self.current_slice[symbol].price)
                else:
                    self.log(f"We never bought {i} in the first place")


    def add_data_to_algo(self):
        "This adds the data to our algo (add_equity) when they are in the dict in two weeks"
        return 
        dt = self.time
        dt_plus_14  = dt+timedelta(days = 14)
        dt_plus_14_parsed = self.parse_datetime(dt_plus_14)
                    

    
    def logging(self):
        pass

        # self.log(f"{self.symbols_.keys()=}")
        # self.log([str(i) for i in self.portfolio.keys()] )

    def on_data(self, data: Slice):
        if data.time.day%7==0:
            self.log(f"data.keys(): {[str(i) for i in data.keys()]}")

        for symbol in data.keys():
            symbol_str = str(symbol)
            if not self.portfolio[symbol].invested:
                self.log(f"{symbol_str} is {self.securities[symbol].is_tradable} tradable")
                if self.securities[symbol].is_tradable:
                    self.debug(f"set_holding {symbol_str} on {data.time}")
                    self.set_holdings(symbol,0.1)
                    self.plot("custom_chart",'buy', data[symbol].price)

            if data[symbol] is not None:
                # if symbol_str not in self.add_series:
                    # pass
                    # s = Series(symbol_str)
                    # self.chart.add_series(s)
                    # self.add_series.append(symbol_str)
                self.plot("custom_chart",'price', data[symbol].price)
        
        return


        for symbol in data.keys():
            if not self.portfolio[symbol].invested:
                self.set_holdings(symbol,0.1)
                self.log(f"Bought {str(symbol)} on { self.parse_datetime(data.time)}")
                self.securities[symbol].bought_on = self.parse_datetime(data.time)
                self.debug(f"{self.securities[symbol].bought_on =}")

        
            # self.portfolio[i].invested

        # if the sma is bigger, 
        # self.emit_insights(Insight(symbol, timedelta(weeks=4), InsightType.PRICE, InsightDirection.UP))

        # if not self.Portfolio.Invested:
            # pass
            # self.SetHoldings("SPY", 0.33)

    def extract_from_sheets_load_to_objectstore(self):
        """
        This is the ELT that keeps the object store up to date with google sheets
        It loads from google sheets saves to ObjectStore
        """
        googlesheets_path = "https://docs.google.com/spreadsheets/d/e/2PACX-1vRyrVQwoM9Svg8mHWb2mC2K84QBUwAonoilR2jj5fg38IuGJFRxbSAUtk6nhFAG1T0cToIxcKeWC668/pubhtml"
        content = self.Download(googlesheets_path)
        df = pd.read_html(StringIO(content))[0]
        df.to_csv(self.marketscreener_path)
        return None

    def on_end_of_algorithm(self):
        self.liquidate()