# encoding: UTF-8

from math import floor

from vnpy.trader.vtConstant import (EMPTY_INT, EMPTY_FLOAT, 
                                    EMPTY_STRING, EMPTY_UNICODE,
                                    DIRECTION_LONG, DIRECTION_SHORT,
                                    STATUS_ALLTRADED, STATUS_CANCELLED, STATUS_REJECTED)



########################################################################
class StAlgoTemplate(object):
    """价差算法交易模板"""
    MODE_LONGSHORT = u'双向'
    MODE_LONGONLY = u'做多'
    MODE_SHORTONLY = u'做空'

    SPREAD_LONG = 1
    SPREAD_SHORT = 2

    #----------------------------------------------------------------------
    def __init__(self, algoEngine, spread):
        """Constructor"""
        self.algoEngine = algoEngine        # 算法引擎        
        self.spreadName = spread.name       # 价差名称
        self.spread = spread                # 价差对象      

        self.algoName = EMPTY_STRING        # 算法名称
        
        self.active = False                 # 工作状态
        self.mode = self.MODE_LONGSHORT     # 工作模式
        
        self.buyPrice = EMPTY_FLOAT         # 开平仓价格
        self.sellPrice = EMPTY_FLOAT
        self.shortPrice = EMPTY_FLOAT
        self.coverPrice = EMPTY_FLOAT
        
        self.maxPosSize = EMPTY_INT         # 最大单边持仓量
        self.maxOrderSize = EMPTY_INT       # 最大单笔委托量
    
    #----------------------------------------------------------------------
    def updateSpreadTick(self, spread):
        """"""
        raise NotImplementedError
    
    #----------------------------------------------------------------------
    def updateSpreadPos(self, spread):
        """"""
        raise NotImplementedError
    
    #----------------------------------------------------------------------
    def updateTrade(self, trade):
        """"""
        raise NotImplementedError
    
    #----------------------------------------------------------------------
    def updateOrder(self, order):
        """"""
        raise NotImplementedError
    
    #----------------------------------------------------------------------
    def updateTimer(self):
        """"""
        raise NotImplementedError
        
    #----------------------------------------------------------------------
    def start(self):
        """"""
        raise NotImplementedError
    
    #----------------------------------------------------------------------
    def stop(self):
        """"""
        raise NotImplementedError

    #----------------------------------------------------------------------
    def setBuyPrice(self, buyPrice):
        """设置买开的价格"""
        self.buyPrice = buyPrice
        
    #----------------------------------------------------------------------
    def setSellPrice(self, sellPrice):
        """设置卖平的价格"""
        self.sellPrice = sellPrice
        
    #----------------------------------------------------------------------
    def setShortPrice(self, shortPrice):
        """设置卖开的价格"""
        self.shortPrice = shortPrice
        
    #----------------------------------------------------------------------
    def setCoverPrice(self, coverPrice):
        """设置买平的价格"""
        self.coverPrice = coverPrice
    
    #----------------------------------------------------------------------
    def setMode(self, mode):
        """设置算法交易方向"""
        self.mode = mode
    
    #----------------------------------------------------------------------
    def setMaxOrderSize(self, maxOrderSize):
        """设置最大单笔委托数量"""
        self.maxOrderSize = maxOrderSize
        
    #----------------------------------------------------------------------
    def setMaxPosSize(self, maxPosSize):
        """设置最大持仓数量"""
        self.maxPosSize = maxPosSize
    
    #----------------------------------------------------------------------
    def putEvent(self):
        """发出算法更新事件"""
        self.algoEngine.putAlgoEvent(self)
        
    #----------------------------------------------------------------------
    def writeLog(self, content):
        """输出算法日志"""
        prefix = '  '.join([self.spreadName, self.algoName])
        content = ':'.join([prefix, content])
        self.algoEngine.writeLog(content)

    #----------------------------------------------------------------------
    def getAlgoParams(self):
        """获取算法参数"""
        d = {
            "spreadName": self.spreadName,
            "algoName": self.algoName,
            "buyPrice": self.buyPrice,
            "sellPrice": self.sellPrice,
            "shortPrice": self.shortPrice,
            "coverPrice": self.coverPrice,
            "maxOrderSize": self.maxOrderSize,
            "maxPosSize": self.maxPosSize,
            "mode": self.mode
        }
        return d
    
    #----------------------------------------------------------------------
    def setAlgoParams(self, d):
        """设置算法参数"""
        self.buyPrice = d.get('buyPrice', EMPTY_FLOAT)
        self.sellPrice = d.get('sellPrice', EMPTY_FLOAT)
        self.shortPrice = d.get('shortPrice', EMPTY_FLOAT)
        self.coverPrice = d.get('coverPrice', EMPTY_FLOAT)
        self.maxOrderSize = d.get('maxOrderSize', EMPTY_INT)
        self.maxPosSize = d.get('maxPosSize', EMPTY_INT)
        self.mode = d.get('mode', self.MODE_LONGSHORT)
        

########################################################################
class SniperAlgo(StAlgoTemplate):
    """狙击算法（市价委托）"""
    FINISHED_STATUS = [STATUS_ALLTRADED, STATUS_CANCELLED, STATUS_REJECTED]

    #----------------------------------------------------------------------
    def __init__(self, algoEngine, spread):
        """Constructor"""
        super(SniperAlgo, self).__init__(algoEngine, spread)
        
        self.algoName = u'Sniper'
        self.quoteInterval = 2      # 主动腿报价撤单再发前等待的时间
        self.quoteCount = 0         # 报价计数
        self.hedgeInterval = 2      # 对冲腿对冲撤单再发前的等待时间
        self.hedgeCount = 0         # 对冲计数
        
        self.activeVtSymbol = spread.activeLeg.vtSymbol                         # 主动腿代码
        self.passiveVtSymbols = [leg.vtSymbol for leg in spread.passiveLegs]    # 被动腿代码列表
        
        # 缓存每条腿对象的字典
        self.legDict = {}
        self.legDict[spread.activeLeg.vtSymbol] = spread.activeLeg
        for leg in spread.passiveLegs:
            self.legDict[leg.vtSymbol] = leg
        
        self.hedgingTaskDict = {}           # 被动腿需要对冲的数量字典  vtSymbol:volume
        self.legOrderDict = {}              # vtSymbol: list of vtOrderID       
        self.orderTradedDict = {}           # vtOrderID: tradedVolume
        
    #----------------------------------------------------------------------
    def updateSpreadTick(self, spread):
        """价差行情更新"""
        self.spread = spread
        
        # 若算法没有启动则直接返回
        if not self.active:
            return
        
        # 若当前已有主动腿委托则直接返回
        if (self.activeVtSymbol in self.legOrderDict and
            self.legOrderDict[self.activeVtSymbol]):
            return

        # 允许做多
        if self.mode == self.MODE_LONGSHORT or self.mode == self.MODE_LONGONLY:
            # 买入
            if (spread.netPos >= 0 and 
                spread.netPos < self.maxPosSize and
                spread.askPrice <= self.buyPrice):
                self.quoteActiveLeg(self.SPREAD_LONG)
                self.writeLog(u'买入开仓')
            
            # 卖出
            elif (spread.netPos > 0 and
                  spread.bidPrice >= self.sellPrice):
                self.quoteActiveLeg(self.SPREAD_SHORT)
                self.writeLog(u'卖出平仓')
        
        # 允许做空
        if self.mode == self.MODE_LONGSHORT or self.mode == self.MODE_SHORTONLY:
            # 做空
            if (spread.netPos <= 0 and
                spread.netPos > -self.maxPosSize and
                spread.bidPrice >= self.shortPrice):
                self.quoteActiveLeg(self.SPREAD_SHORT)
                self.writeLog(u'卖出开仓')
            
            # 平空
            elif (spread.netPos < 0 and
                  spread.askPrice <= self.coverPrice):
                self.quoteActiveLeg(self.SPREAD_LONG)
                self.writeLog(u'买入平仓')
    
    #----------------------------------------------------------------------
    def updateSpreadPos(self, spread):
        """价差持仓更新"""
        self.spread = spread
    
    #----------------------------------------------------------------------
    def updateTrade(self, trade):
        """成交更新"""
        pass
    
    #----------------------------------------------------------------------
    def updateOrder(self, order):
        """委托更新"""
        if not self.active:
            return

        vtOrderID = order.vtOrderID
        vtSymbol = order.vtSymbol
        newTradedVolume = order.tradedVolume
        lastTradedVolume = self.orderTradedDict.get(vtOrderID, 0)
        
        # 检查是否有新的成交
        if newTradedVolume > lastTradedVolume:
            self.orderTradedDict[vtOrderID] = newTradedVolume       # 缓存委托已经成交数量
            volume = newTradedVolume - lastTradedVolume             # 计算本次成交数量
            
            if vtSymbol == self.activeVtSymbol:
                self.newActiveLegTrade(vtSymbol, order.direction, volume)
            else:
                self.newPassiveLegTrade(vtSymbol, order.direction, volume)            
            
        # 处理完成委托
        if order.status in self.FINISHED_STATUS:
            vtOrderID = order.vtOrderID
            vtSymbol = order.vtSymbol
            
            # 从委托列表中移除该委托
            orderList = self.legOrderDict.get(vtSymbol, None)
            
            if orderList and vtOrderID in orderList:
                orderList.remove(vtOrderID)
                
            # 检查若是被动腿，且已经没有未完成委托，则执行对冲
            if not orderList and vtSymbol in self.passiveVtSymbols:
                self.hedgePassiveLeg(vtSymbol)
    
    #----------------------------------------------------------------------
    def updateTimer(self):
        """计时更新"""
        if not self.active:
            return
        
        self.quoteCount += 1
        self.hedgeCount += 1
        
        # 计时到达报价间隔后，则对尚未成交的主动腿委托全部撤单
        # 收到撤单回报后清空委托列表，等待下次价差更新再发单
        if self.quoteCount > self.quoteInterval:
            self.cancelLegOrder(self.activeVtSymbol)
            self.quoteCount = 0
        
        # 计时到达对冲间隔后，则对尚未成交的全部被动腿委托全部撤单
        # 收到撤单回报后，会自动发送新的对冲委托
        if self.hedgeCount > self.hedgeInterval:
            self.cancelAllPassiveLegOrders()
            self.hedgeCount = 0
        
    #----------------------------------------------------------------------
    def start(self):
        """启动"""
        # 如果已经运行则直接返回状态
        if self.active:
            return self.active
        
        # 做多检查
        if self.mode != self.MODE_SHORTONLY:
            if self.buyPrice >= self.sellPrice:
                self.writeLog(u'启动失败，允许多头交易时BuyPrice必须小于SellPrice')
                return self.active
            
        # 做空检查
        if self.mode != self.MODE_LONGONLY:
            if self.shortPrice <= self.coverPrice:
                self.writeLog(u'启动失败，允许空头交易时ShortPrice必须大于CoverPrice')
                return self.active
            
        # 多空检查
        if self.mode == self.MODE_LONGSHORT:
            if self.buyPrice >= self.coverPrice:
                self.writeLog(u'启动失败，允许双向交易时BuyPrice必须小于CoverPrice')
                return self.active
            
            if self.shortPrice <= self.sellPrice:
                self.writeLog(u'启动失败，允许双向交易时ShortPrice必须大于SellPrice')
                return self.active
        
        # 启动算法
        self.quoteCount = 0
        self.hedgeCount = 0
            
        self.active = True
        self.writeLog(u'算法启动')
        
        return self.active
    
    #----------------------------------------------------------------------
    def stop(self):
        """停止"""
        if self.active:
            self.hedgingTaskDict.clear()
            self.cancelAllOrders()
           
        self.active = False   
        self.writeLog(u'算法停止')
        
        return self.active
    
    #----------------------------------------------------------------------
    def sendLegOrder(self, leg, legVolume):
        """发送每条腿的委托"""
        vtSymbol = leg.vtSymbol
        volume = abs(legVolume)
        payup = leg.payup
        
        # 发送委托
        if legVolume > 0:
            price = leg.askPrice
            
            if leg.shortPos > 0:
                orderList = self.algoEngine.cover(vtSymbol, price, volume, payup)
            else:
                orderList = self.algoEngine.buy(vtSymbol, price, volume, payup)
                
        elif legVolume < 0:
            price = leg.bidPrice
            
            if leg.longPos > 0:
                orderList = self.algoEngine.sell(vtSymbol, price, volume, payup)
            else:
                orderList = self.algoEngine.short(vtSymbol, price, volume, payup)
                
        # 保存到字典中
        if vtSymbol not in self.legOrderDict:
            self.legOrderDict[vtSymbol] = orderList
        else:
            self.legOrderDict[vtSymbol].extend(orderList)        
    
    #----------------------------------------------------------------------
    def quoteActiveLeg(self, direction):
        """发出主动腿"""        
        spread = self.spread
        
        # 首先计算不带正负号的价差委托量
        if direction == self.SPREAD_LONG:
            spreadVolume = min(spread.askVolume,
                               self.maxPosSize - spread.netPos,
                               self.maxOrderSize)
            
            # 有价差空头持仓的情况下，则本次委托最多平完空头
            if spread.shortPos > 0:
                spreadVolume = min(spreadVolume, spread.shortPos)
        else:
            spreadVolume = min(spread.bidVolume,
                               self.maxPosSize + spread.netPos,
                               self.maxOrderSize)
            
            # 有价差多头持仓的情况下，则本次委托最多平完多头
            if spread.longPos > 0:
                spreadVolume = min(spreadVolume, spread.longPos)
            
        if spreadVolume <= 0:
            return
        
        # 加上价差方向
        if direction == self.SPREAD_SHORT:
            spreadVolume = -spreadVolume
        
        # 计算主动腿委托量
        leg = self.legDict[self.activeVtSymbol]
        legVolume = spreadVolume * leg.ratio        
        self.sendLegOrder(leg, legVolume)
        self.writeLog(u'发出新的主动腿%s狙击单' %self.activeVtSymbol)
        
        self.quoteCount = 0         # 重置主动腿报价撤单等待计数

    #----------------------------------------------------------------------
    def hedgePassiveLeg(self, vtSymbol):
        """被动腿对冲"""
        if vtSymbol not in self.hedgingTaskDict:
            return
        
        orderList = self.legOrderDict.get(vtSymbol, [])
        if orderList:
            return
        
        legVolume = self.hedgingTaskDict[vtSymbol]
        leg = self.legDict[vtSymbol]
        
        self.sendLegOrder(leg, legVolume)
        self.writeLog(u'发出新的被动腿%s对冲单' %vtSymbol)
        
    #----------------------------------------------------------------------
    def hedgeAllPassiveLegs(self):
        """执行所有被动腿对冲"""
        for vtSymbol in self.hedgingTaskDict.keys():
            self.hedgePassiveLeg(vtSymbol)
        
        self.hedgeCount = 0         # 重置被动腿对冲撤单等待计数
        
    #----------------------------------------------------------------------
    def newActiveLegTrade(self, vtSymbol, direction, volume):
        """新的主动腿成交"""
        # 输出日志
        self.writeLog(u'主动腿%s成交，方向%s，数量%s' %(vtSymbol, direction, volume))        
        
        # 将主动腿成交带上方向
        if direction == DIRECTION_SHORT:
            volume = -volume
        
        # 计算主动腿成交后，对应的价差仓位
        spread = self.spread
        activeRatio = spread.activeLeg.ratio
        spreadVolume = round(volume / activeRatio)  # 四舍五入求主动腿成交量对应的价差份数
        
        # 计算价差新仓位，对应的被动腿需要对冲部分
        for leg in self.spread.passiveLegs:
            newHedgingTask = leg.ratio * spreadVolume
            
            if leg.vtSymbol not in self.hedgingTaskDict:
                self.hedgingTaskDict[leg.vtSymbol] = newHedgingTask
            else:
                self.hedgingTaskDict[leg.vtSymbol] += newHedgingTask
        
        # 发出被动腿对冲委托
        self.hedgeAllPassiveLegs()        
    
    #----------------------------------------------------------------------
    def newPassiveLegTrade(self, vtSymbol, direction, volume):
        """新的被动腿成交"""
        if vtSymbol in self.hedgingTaskDict:
            # 计算完成的对冲数量
            if direction == DIRECTION_LONG:
                hedgedVolume = volume
            else:
                hedgedVolume = -volume
                
            # 计算剩余尚未完成的数量
            self.hedgingTaskDict[vtSymbol] -= hedgedVolume
            
            # 如果已全部完成，则从字典中移除
            if not self.hedgingTaskDict[vtSymbol]:
                del self.hedgingTaskDict[vtSymbol]
                
        # 输出日志
        self.writeLog(u'被动腿%s成交，方向%s，数量%s' %(vtSymbol, direction, volume))
                
    #----------------------------------------------------------------------
    def cancelLegOrder(self, vtSymbol):
        """撤销某条腿的委托"""
        if vtSymbol not in self.legOrderDict:
            return
        
        orderList = self.legOrderDict[vtSymbol]
        if not orderList:
            return
        
        for vtOrderID in orderList:
            self.algoEngine.cancelOrder(vtOrderID)
            
        self.writeLog(u'撤单%s的所有委托' %vtSymbol)
            
    #----------------------------------------------------------------------
    def cancelAllOrders(self):
        """撤销全部委托"""
        for orderList in self.legOrderDict.values():
            for vtOrderID in orderList:
                self.algoEngine.cancelOrder(vtOrderID)
        
        self.writeLog(u'全部撤单')
    
    #----------------------------------------------------------------------
    def cancelAllPassiveLegOrders(self):
        """撤销全部被动腿委托"""
        cancelPassive = False
        
        for vtSymbol in self.passiveVtSymbols:
            if vtSymbol in self.legOrderDict and self.legOrderDict[vtSymbol]:
                self.cancelLegOrder(vtSymbol)
                cancelPassive = True

        # 只有确实发出撤单委托时，才输出信息        
        if cancelPassive:
            self.writeLog(u'被动腿全撤')
