# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from AlgorithmImports import *
from math import copysign

### <summary>
### Provides a regression baseline focused on updating orders
### </summary>
### <meta name="tag" content="regression test" />
class UpdateOrderRegressionAlgorithm(QCAlgorithm):

 def initialize(self):
 '''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''

 self.set_start_date(2013,1,1) #Set Start Date
 self.set_end_date(2015,1,1) #Set End Date
 self.set_cash(100000) #Set Strategy Cash
 # Find more symbols here: http://quantconnect.com/data

 self.security = self.add_equity("SPY", Resolution.DAILY)

 self.last_month = -1
 self.quantity = 100
 self.delta_quantity = 10

 self.stop_percentage = 0.025
 self.stop_percentage_delta = 0.005
 self.limit_percentage = 0.025
 self.limit_percentage_delta = 0.005

 order_type_enum = [OrderType.MARKET, OrderType.LIMIT, OrderType.STOP_MARKET, OrderType.STOP_LIMIT, OrderType.MARKET_ON_OPEN, OrderType.MARKET_ON_CLOSE, OrderType.TRAILING_STOP]
 self.order_types_queue = CircularQueue[OrderType](order_type_enum)
 self.order_types_queue.circle_completed += self.on_circle_completed
 self.tickets = []


 def on_circle_completed(self, sender, event):
 '''Flip our signs when we've gone through all the order types'''
 self.quantity *= -1


 def on_data(self, data):
 '''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.'''
 if not data.bars.contains_key("SPY"):
 return

 if self.time.month != self.last_month:
 # we'll submit the next type of order from the queue
 order_type = self.order_types_queue.dequeue()
 self.log("\r\n--------------MONTH: {0}:: {1}".format(self.time.strftime("%B"), order_type))
 self.last_month = self.time.month
 self.log("ORDER TYPE:: {0}".format(order_type))
 is_long = self.quantity > 0
 stop_price = (1 + self.stop_percentage)*data["SPY"].high if is_long else (1 - self.stop_percentage)*data["SPY"].low
 limit_price = (1 - self.limit_percentage)*stop_price if is_long else (1 + self.limit_percentage)*stop_price

 if order_type == OrderType.LIMIT:
 limit_price = (1 + self.limit_percentage)*data["SPY"].high if not is_long else (1 - self.limit_percentage)*data["SPY"].low

 request = SubmitOrderRequest(order_type, self.security.symbol.security_type, "SPY", self.quantity, stop_price, limit_price, 0, 0.01, True,
 self.utc_time, str(int(order_type)))
 ticket = self.transactions.add_order(request)
 self.tickets.append(ticket)

 elif len(self.tickets) > 0:
 ticket = self.tickets[-1]

 if self.time.day > 8 and self.time.day < 14:
 if len(ticket.update_requests) == 0 and ticket.status is not OrderStatus.FILLED:
 self.log("TICKET:: {0}".format(ticket))
 update_order_fields = UpdateOrderFields()
 update_order_fields.quantity = ticket.quantity + copysign(self.delta_quantity, self.quantity)
 update_order_fields.tag = "Change quantity: {0}".format(self.time.day)
 ticket.update(update_order_fields)

 elif self.time.day > 13 and self.time.day < 20:
 if len(ticket.update_requests) == 1 and ticket.status is not OrderStatus.FILLED:
 self.log("TICKET:: {0}".format(ticket))
 update_order_fields = UpdateOrderFields()
 update_order_fields.limit_price = self.security.price*(1 - copysign(self.limit_percentage_delta, ticket.quantity))
 update_order_fields.stop_price = self.security.price*(1 + copysign(self.stop_percentage_delta, ticket.quantity)) if ticket.order_type != OrderType.TRAILING_STOP else None
 update_order_fields.tag = "Change prices: {0}".format(self.time.day)
 ticket.update(update_order_fields)
 else:
 if len(ticket.update_requests) == 2 and ticket.status is not OrderStatus.FILLED:
 self.log("TICKET:: {0}".format(ticket))
 ticket.cancel("{0} and is still open!".format(self.time.day))
 self.log("CANCELLED:: {0}".format(ticket.cancel_request))


 def on_order_event(self, orderEvent):
 order = self.transactions.get_order_by_id(orderEvent.order_id)
 ticket = self.transactions.get_order_ticket(orderEvent.order_id)

 #order cancelations update CanceledTime
 if order.status == OrderStatus.CANCELED and order.canceled_time != orderEvent.utc_time:
 raise ValueError("Expected canceled order CanceledTime to equal canceled order event time.")

 #fills update LastFillTime
 if (order.status == OrderStatus.FILLED or order.status == OrderStatus.PARTIALLY_FILLED) and order.last_fill_time != orderEvent.utc_time:
 raise ValueError("Expected filled order LastFillTime to equal fill order event time.")

 # check the ticket to see if the update was successfully processed
 if len([ur for ur in ticket.update_requests if ur.response is not None and ur.response.is_success]) > 0 and order.created_time != self.utc_time and order.last_update_time is None:
 raise ValueError("Expected updated order LastUpdateTime to equal submitted update order event time")

 if orderEvent.status == OrderStatus.FILLED:
 self.log("FILLED:: {0} FILL PRICE:: {1}".format(self.transactions.get_order_by_id(orderEvent.order_id), orderEvent.fill_price))
 else:
 self.log(orderEvent.to_string())
 self.log("TICKET:: {0}".format(ticket))