from System.Drawing import Color


class MyFirstAlgo(QCAlgorithm):

    def Initialize(self):

        self.SetStartDate(2021, 4, 1)
        self.SetEndDate(2021, 4, 10)
        self.SetCash(100000)

        self.stopLossPercent = .02
        self.profitTargetPercent = .03
        self.orderTicket = None
        self.profitTicket = None
        self.stopLossTicket = None

        self.symbol = "EURUSD"
        self.AddForex(self.symbol, Resolution.Minute, Market.FXCM)
        self.lotSize = self.Securities[self.symbol].SymbolProperties.LotSize
        self._trend = 0
        self.Consolidate(self.symbol, timedelta(minutes=30), self.ThirtyMinuteBarHandler)

        self.benchmarkTicker = self.symbol
        self.SetBenchmark(self.benchmarkTicker)
        self.initBenchmarkPrice = None

        self.SetBrokerageModel(BrokerageName.FxcmBrokerage)

        self.macd = MovingAverageConvergenceDivergence(12, 26, 9, MovingAverageType.Exponential)
        self.RegisterIndicator(self.symbol, self.macd, timedelta(minutes=30))

        self.ema_slow = self.LWMA(self.symbol, 100, Resolution.Hour)
        self.ema_fast = self.EMA(self.symbol, 50, Resolution.Hour)

        self.SetWarmUp(210, Resolution.Hour)

        self.initPlots()

    def ThirtyMinuteBarHandler(self, bar):
        if self.IsWarmingUp:
            return

        if self.Time.hour % 13 == 0:
            self.plot()

        if self.Portfolio[self.symbol].Invested:
            return

        self.trend(bar)
        self.Debug(self._trend)
        currentPrice = round(bar.Close, 5)
        sellPrice = round(bar.Ask.Close, 5)
        buyPrice = round(bar.Bid.Close, 5)
        self.Debug(currentPrice)
        self.Debug(buyPrice)
        self.Debug(sellPrice)
        quantity = self.CalculateOrderQuantity(self.symbol, 1)
        self.Debug(quantity)
        if self._trend == 1:
            if self.orderTicket is not None and self.orderTicket.Status in [OrderStatus.Submitted, OrderStatus.UpdateSubmitted]:
                self.Debug("Updating Long")
                updateSettings = UpdateOrderFields()
                updateSettings.LimitPrice = buyPrice
                self.orderTicket.Update(updateSettings)
            elif self.macd.Current.Value > self.macd.Signal.Current.Value and self.macd.Signal.Current.Value > 0:
                self.Debug("New Long")
                self.orderTicket = self.LimitOrder(self.symbol, quantity, buyPrice, "Long")
        elif self._trend == -1:
            if self.orderTicket is not None and self.orderTicket.Status in [OrderStatus.Submitted, OrderStatus.UpdateSubmitted]:
                self.Debug("Updating Short")
                updateSettings = UpdateOrderFields()
                updateSettings.LimitPrice = sellPrice
                self.orderTicket.Update(updateSettings)
            elif self.macd.Current.Value < self.macd.Signal.Current.Value and self.macd.Signal.Current.Value < 0:
                self.Debug("New Short")
                self.orderTicket = self.LimitOrder(self.symbol, -quantity, sellPrice, "Short")
            else:
                self.Debug("No Trend")

    def OnOrderEvent(self, orderEvent):
        order = self.Transactions.GetOrderById(orderEvent.OrderId)
        status = {0: "New", 1:"Submitted", 2:"PartiallyFilled", 3:"Filled", 4:"Canceled", 5:"None", 6:"Invalid", 7:"CancelPending", 8:"UpdateSubmitted"}
        self.Debug(f">{order.Tag}: {status.get(orderEvent.Status)}")
        self.Debug(f"Open Orders: {len(self.Transactions.GetOpenOrders())}")
        # self.Debug(f"Open Orders: {len(self.Transactions.GetOpenOrders())}")

        if self.orderTicket is not None and self.orderTicket.OrderId == orderEvent.OrderId and self.orderTicket.Status == OrderStatus.Filled:
            qty = -self.orderTicket.QuantityFilled
            price = self.orderTicket.AverageFillPrice
            tag_tp = f"{self.orderTicket.Tag} TP"
            tag_sl = f"{self.orderTicket.Tag} SL"
            self.Debug(qty)
            self.Debug(price)
            self.Debug(tag_tp)
            self.Debug(tag_sl)
        if self.orderTicket.Tag == "Long":
            stopPrice = round(price * (1 - self.stopLossPercent), 5)
            targetPrice = round(price * (1 + self.profitTargetPercent), 5)
        if self.orderTicket.Tag == "Short":
            stopPrice = round(price * (1 + self.stopLossPercent), 5)
            targetPrice = round(price * (1 - self.profitTargetPercent), 5)
            self.Debug(stopPrice)
            self.Debug(targetPrice)
            self.profitTicket = self.LimitOrder(self.symbol, qty, targetPrice, tag_tp)
            self.stopLossTicket = self.StopMarketOrder(self.symbol, qty, stopPrice, tag_sl)
            self.UpdateBenchmarkValue()
            self.Plot('Strategy Equity', f"Open {self.orderTicket.Tag}", self.benchmarkValue+15)

        if self.profitTicket is not None and self.profitTicket.OrderId == orderEvent.OrderId and self.profitTicket.Status == OrderStatus.Filled:
            self.Transactions.CancelOpenOrders()
            # response = self.stopLossTicket.Cancel("TP Hit")
            # if response.IsSuccess:
                # self.Debug("TP Order Canceled")
                # self.Debug(f"Open Orders: {len(self.Transactions.GetOpenOrders())}")
            self.UpdateBenchmarkValue()
            self.Plot('Strategy Equity', f"Close {self.orderTicket.Tag}", self.benchmarkValue-15)

        if self.stopLossTicket is not None and self.stopLossTicket.OrderId == orderEvent.OrderId and self.stopLossTicket.Status == OrderStatus.Filled:
            self.Transactions.CancelOpenOrders()
            # response = self.profitTicket.Cancel("SL Hit")
            # if response.IsSuccess:
            # self.Debug("SL Order Canceled")
            # self.Debug(f"Open Orders: {len(self.Transactions.GetOpenOrders())}")
            self.UpdateBenchmarkValue()
            self.Plot('Strategy Equity', f"Close {self.orderTicket.Tag}", self.benchmarkValue-15)

    def OnData(self, data):
        pass

    def trend(self, bar):
        if all(
                [
                bar.Close < self.ema_slow.Current.Value,
                # self.Securities["EURUSD"].Price < self.ema_fast.Current.Value,
                # self.ema_slow.Current.Value > self.ema_fast.Current.Value,
                ]
                ):
            _trend = -1
        elif all(
                [
                bar.Close > self.ema_slow.Current.Value,
                # self.Securities["EURUSD"].Price > self.ema_fast.Current.Value,
                # self.ema_slow.Current.Value < self.ema_fast.Current.Value,
                ]
                ):
            _trend = 1
        else:
            _trend = 0
            self._trend = _trend

    def initPlots(self):

        trendPlot = Chart('Trend Indicator')
        trendPlot.AddSeries(Series('Price', SeriesType.Line))
        trendPlot.AddSeries(Series('EMA 200', SeriesType.Line))
        # trendPlot.AddSeries(Series('EMA 50', SeriesType.Line))
        self.AddChart(trendPlot)

        ocPlot = Chart('Open Close Indicator')
        ocPlot.AddSeries(Series('MACD', SeriesType.Line))
        ocPlot.AddSeries(Series('Signal', SeriesType.Line))
        self.AddChart(ocPlot)

        tradesPlot = Chart('Strategy Equity')
        # tradesPlot.AddSeries(Series('Price', SeriesType.Line, "$"))
        tradesPlot.AddSeries(Series('Open Long', SeriesType.Scatter, "", Color.Green, ScatterMarkerSymbol.Triangle))
        tradesPlot.AddSeries(Series('Close Long', SeriesType.Scatter, "", Color.Red, ScatterMarkerSymbol.Triangle))
        tradesPlot.AddSeries(Series('Open Short', SeriesType.Scatter, "", Color.Green, ScatterMarkerSymbol.TriangleDown))
        tradesPlot.AddSeries(Series('Close Short', SeriesType.Scatter, "", Color.Red, ScatterMarkerSymbol.TriangleDown))
        self.AddChart(tradesPlot)

    def plot(self):
        self.Plot('Trend Indicator', 'Price', self.Securities[self.symbol].Close)
        self.Plot('Trend Indicator', 'EMA 200', self.ema_slow.Current.Value)
        # self.Plot('Trend Indicator', 'EMA 50', self.ema_fast.Current.Value)
        self.Plot('Open Close Indicator', 'MACD', self.macd.Current.Value)
        self.Plot('Open Close Indicator', 'Signal', self.macd.Signal.Current.Value)

        self.UpdateBenchmarkValue()
        self.Plot('Strategy Equity', self.benchmarkTicker, self.benchmarkValue)

        # self.Plot('Trades', 'Price', self.Securities[self.symbol].Close)


    def UpdateBenchmarkValue(self):
            if self.initBenchmarkPrice is None:
                self.initBenchmarkCash = self.Portfolio.Cash
                self.initBenchmarkPrice = self.Benchmark.Evaluate(self.Time)
                self.benchmarkValue = self.initBenchmarkCash
            else:
                self.benchmarkValue = (
                    self.Benchmark.Evaluate(self.Time) / self.initBenchmarkPrice
                    ) * self.initBenchmarkCash