from Execution.VolumeWeightedAveragePriceExecutionModel import VolumeWeightedAveragePriceExecutionModel
from clr import AddReference
AddReference("System")
AddReference("QuantConnect.Algorithm")
AddReference("QuantConnect.Indicators")
AddReference("QuantConnect.Common")

from System import *
from QuantConnect import *
from QuantConnect.Algorithm import *
from QuantConnect.Indicators import *
from datetime import datetime
import decimal as d

class UncoupledOptimizedRadiator(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2010, 8, 8)  # Set Start Date
        self.SetEndDate(datetime.now())
        self.end_date = datetime.now()
        self.SetCash(100000)  # Set Strategy Cash
        # self.AddEquity("SPY", Resolution.Minute)
        # self.SetExecution(VolumeWeightedAveragePriceExecutionModel())

    
        self.SetRiskManagement(MaximumUnrealizedProfitPercentPerSecurity(0.03))
        self.AddForex("EURJPY", Resolution.Minute, Market.Oanda)
        self.__macd = self.MACD("EURJPY", 33, 91, 34, MovingAverageType.Exponential, Resolution.Minute)
        self.__previous = datetime.min
        
        self.pair = "EURJPY"
        
        # self.PlotIndicator("MACD", True, self.__macd, self.__macd.Signal)
        # self.PlotIndicator
        self.position = 0
        self.past_delta = 0.0

    def OnData(self, data):
        '''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
            Arguments:
                data: Slice object keyed by symbol containing the stock data
        '''
        if not self.__macd.IsReady: return
    
        # holdings = self.Portfolio["EURJPY"].Quantity
        
        # self.Log(holdings)
        # self.Debug(str(self.Time) + " Purchasing AAPL: ")
        
        tolerance = 0
        # self.Log(self.__macd)
        current_delta = float(self.__macd.Fast.Current.Value) - float(self.__macd.Slow.Current.Value)
        # orderTicket = self.MarketOrder("EURJPY", 1)
        
        # self.Debug("Past"  +str(self.past_delta ))
        # self.Debug("Fast"+str(self.__macd.Fast.Current.Value ) + "   , Slow" + str(self.__macd.Slow.Current.Value))
        # self.Debug("Delta"+str( float(self.__macd.Fast.Current.Value) - float(self.__macd.Slow.Current.Value)))
        # price = data.Close
        onePercent = d.Decimal(1.01)
        if self.past_delta > 0.00 and  current_delta  < 0.00: 
            if not self.Portfolio.Invested:
                price = data[self.pair].Close
                onePercent = d.Decimal(1.01)
                self.Buy(self.pair, 1000000)
                self.LimitOrder(self.pair, -1000000, price * onePercent)
                self.StopMarketOrder(self.pair, -1000000, price / onePercent)
           
            
        if self.past_delta < 0.00 and current_delta > 0.00:
            if not self.Portfolio.Invested:
                price = data[self.pair].Close
                onePercent = d.Decimal(1.01)
                self.Sell(self.pair, 1000000)
                self.LimitOrder(self.pair, 1000000, price / onePercent)
                self.StopMarketOrder(self.pair, 1000000, price * onePercent)
            
            
            
        self.past_delta = current_delta
       
            
        self.__previous = self.Time
        
    def OnOrderEvent(self, orderEvent):
        order = self.Transactions.GetOrderById(orderEvent.OrderId)
        
        if order.Status == OrderStatus.Filled:
            if order.Type == OrderType.Limit or order.Type == OrderType.StopMarket:
                self.Transactions.CancelOpenOrders(order.Symbol)
        
        if order.Status == OrderStatus.Canceled:
            self.Log(str(orderEvent))