from collections import OrderedDict
from datetime import datetime, timedelta
import pandas as pd
import collections
import numpy as np
from collections import OrderedDict
# 初始化函数,全局只运行一次
def init(context):
     # 设置基准收益：沪深300指数
     set_benchmark('000300.SH')
     # 打印日志
     log.info('策略开始运行,初始化函数全局只运行一次')
     # 设置股票每笔交易的手续费为万分之零八八(手续费在买卖成交后扣除,不包括税费,税费在卖出成交后扣除)
     set_commission(PerTrade(type='stock',cost=0.1))
     # 设置股票交易滑点0.005%,表示买入价为实际价格乘1,卖出价为实际价格乘1
     set_slippage(PriceSlippage(0))
     # 设置基准时间
     run_daily(func=test_day, time_rule='every_bar', reference_security='000001.SZ')
     # 设置网格记忆容器
     g.zqc = pd.DataFrame(columns=['基准价', '网格'])
     # 记录止盈天数
     g.zyts = ''
     # 设置盈亏记忆容器
     g.zqjy = pd.DataFrame(columns=['持仓', '总平盈', '今平盈', '浮盈','总计']) 
     # 记录初始资金
     g.zzc = context.portfolio.stock_account.total_value
# 盘前运行
def before_trading(context):
     # 初始持仓判断
     g.yxcs = 0
     # 计算盈利
     if '总计' in g.zqjy.index:           
         g.zqjy = g.zqjy.drop('总计', axis=0)
     # 更新日内浮盈
     for gps in g.zqjy.index:
         g.zqjy.loc[gps, ['今平盈']] = g.zqjy.loc[gps, '总平盈']
     # 日内求和
     g.zqjy.loc['总计'] = g.zqjy.sum() 
     
# 每分钟运行     
def test_day(context, bar_dict):
     data1 = read_file('instruct.txt').decode('utf-8').replace('\r\n', '').split('qshmd:')[0].split(',')
     qshmd = read_file('instruct.txt').decode('utf-8').replace('\r\n', '').split('qshmd:')[1].split('sdhmd')[0]
     sdhmd = read_file('instruct.txt').decode('utf-8').replace('\r\n', '').split('sdhmd:')[1]
     # 获取持仓
     chicangs = list(context.portfolio.positions)
     # 组合债券池
     zd_gps=list(collections.OrderedDict.fromkeys(chicangs+data1))
     # 初始持仓为0
     y = 0
     
     # 设置单债持仓上限
     dzsx = 200
     # 设置债券支数上限
     zqsx = 20
     # 设置网格大小（元）
     wgdx = 0.2
     # 设置止盈金额
     zhiying = 500
     # 设置状态
     zt = '模拟'
     # 设置一个网格交易的数量
     wgsl = 20
     # 设置底仓数量
     dcsl = 60
     
     for zd_gp in zd_gps:
         try:
             # 获取时间
             time =get_datetime()
             # 获取指定时间
             gdsj = get_datetime().replace(hour=14, minute=30)
             if zt == '回测':
                 # 获取未来一分钟时间
                 timebl = get_datetime()+timedelta(minutes=1)
                 # 获取债券当前最新价
                 value = get_price(zd_gp, None, timebl, '1m', ['open'], True, None, 1, is_panel=1)['open'].mean()
             elif zt == '模拟':
                 # 获取未来一分钟时间
                 timebl = get_datetime()
                 # 获取债券当前最新价
                 value = get_price(zd_gp, None, timebl, '1m', ['close'], True, None, 1, is_panel=1)['close'].mean()
             # 获取下单金额
             xdje = context.portfolio.stock_account.total_value/zqsx
             # 获取底仓所需金额
             xdje1 = value * dcsl
             # 获取单个网格所需金额
             xdje2 = value * wgsl
             # 获取可用资金
             kyzj = context.portfolio.stock_account.available_cash
             # 计算每组数量
             shuliang = round(xdje/value/10)*10
             # 取得当前账户该股票的持仓
             market_value = context.portfolio.positions[zd_gp].amount
             # 取得当前债券成本价
             cbj = context.portfolio.positions[zd_gp].cost_basis
             # 取得当前债券张数
             zqzs = len(context.portfolio.positions)
             # 获取当前账户资金
             zzc = context.portfolio.stock_account.total_value
             # 判断该债是否曾经止盈
             if zd_gp in g.zyts:
                dqts == g.zyts.split(zd_gp)[1].split(',')[0]
                if dqts == 0:
                     g.zyts.replace(str(zd_gp + str(dqts) + ','), '')
             else:
                 dqts = 0
   
             # 计算当前债券的盈利情况     
             yl = 0
             if cbj != 0:
                 yl = value/cbj
                 zyj = (value*market_value)-(cbj*market_value)
                 # 获取交易前的持仓盈亏
                 ccyks = (value/cbj) * market_value
                 
             # 判断该债券是否存在于债券池，并取出基准价
             if zd_gp in g.zqc.index and market_value > 0 and zqzs <= zqsx:
                 jzj = g.zqc.loc[zd_gp, '基准价']
                 # 计算网格大小
                 wg = wgdx
                 # 查询上次网格
                 qwgs = g.zqc.loc[zd_gp, '网格']
                 # 计算网格
                 wgs = int((float(value)-float(jzj))/wg)
                 # 计算网格变化
                 wgbh = wgs-qwgs
             # 第一次交易
             elif zd_gp not in g.zqc.index and market_value == 0 and zqzs <= zqsx:
                 # 记录新基准价
                 g.zqc.loc[zd_gp] = [value, 0]
                 # 网格初始化为0
                 wgs = 0
                 qwgs = 0
                 wgbh = 0
                 
             # 判断是否为初始化交易  
             if market_value == 0 and zqzs < zqsx and kyzj > xdje1:
                 # 按照每组数量下单
                 id=order(zd_gp, dcsl)
                 # 取得当前账户该债券的持仓
                 hqdd = get_order(id).amount
                 # 下单成功则记录
                 if hqdd > 0:
                     # 买入初始化持仓
                     log.info("建立底仓, %.2f 买入 %d 张 %s" % (value, dcsl , zd_gp))
                     # 记录网格
                     g.zqc.loc[zd_gp, ['基准价', '网格']] = [value, 0]
                     # 获取持仓盈亏
                     ccyk = context.portfolio.positions[zd_gp].pnl
                     # 已经有过交易
                     if zd_gp in g.zqjy.index:
                         # 获取平仓盈亏
                         pcyk = g.zqjy.loc[zd_gp, '总平盈']
                         # 记录该股票
                         g.zqjy.loc[zd_gp, ['持仓', '浮盈', '总计']] = [hqdd, ccyk, pcyk+ccyk]
                     # 今日第一次交易
                     elif zd_gp not in g.zqjy.index:
                         # 记录该股票
                         g.zqjy.loc[zd_gp] = [hqdd, 0, 0, ccyk, ccyk]
                            
             # 符合网格条件，则买入该债券10股
             elif wgs < qwgs and market_value < dzsx and zqzs < zqsx and dqts == 0 and kyzj > xdje2 * abs(wgbh):
                 # 按照每组数量下单
                 id=order(zd_gp, abs(wgsl * wgbh))
                 # 取得本次成交数量
                 hqdd = get_order(id).amount
                 # 下单成功则记录
                 if hqdd > 0:
                     # 记录这次买入
                     log.info("网格交易, %.2f 买入 %d 张 %s" % (value, abs(wgsl * wgbh), zd_gp))   
                     # 记录网格
                     g.zqc.loc[zd_gp, ['网格']] = [wgs]
                     # 获取持仓盈亏
                     ccyk = context.portfolio.positions[zd_gp].pnl
                     # 已经有过交易
                     if zd_gp in g.zqjy.index:
                         # 获取平仓盈亏
                         pcyk = g.zqjy.loc[zd_gp, '总平盈']
                         # 更新记录
                         g.zqjy.loc[zd_gp, ['持仓', '浮盈', '总计']] = [hqdd, ccyk, pcyk+ccyk]
                     # 今日第一次交易
                     elif zd_gp not in g.zqjy.index:
                         # 记录该股票
                         g.zqjy.loc[zd_gp] = [hqdd, 0, 0, ccyk, ccyk]
                     
             # 判断债券是否强赎
             elif market_value > 0 and zd_gp in qshmd:
                 # 卖出10
                 id=order_target(zd_gp, 0)
                 # 取得本次成交数量
                 hqdd = get_order(id).amount
                 # 下单成功则记录
                 if hqdd > 0:
                     # 记录这次卖出
                     log.info("触发强赎清仓, %.2f 卖出 %d 张 %s" % (value, market_value, zd_gp))                       
                     # 删除网格记录网格
                     g.zqc = g.zqc.drop(zd_gp, axis=0)
                     # 获取持仓盈亏
                     ccyk = context.portfolio.positions[zd_gp].pnl
                     # 获取平仓盈亏
                     pcyk = g.zqjy.loc[zd_gp, '总平盈'] + (ccyks - (value/cbj) * hqdd)
                     # 更新记录
                     g.zqjy.loc[zd_gp, ['持仓', '总平盈', '浮盈', '总计']] = [hqdd, pcyk, ccyk, pcyk+ccyk]
                     
             # 符合网格条件则卖入该债券10股
             elif market_value > 0 and wgs > qwgs:
                 # 卖出10
                 id=order(zd_gp, -abs(wgsl * wgbh))
                 # 取得本次成交数量
                 hqdd = get_order(id).amount
                 # 下单成功则记录
                 if hqdd > 0:
                     # 记录这次卖出
                     log.info("网格交易, %.2f 卖出 %d 张 %s" % (value,-abs(wgsl * wgbh), zd_gp))
                     # 记录网格
                     g.zqc.loc[zd_gp, ['网格']] = [wgs]
                     # 获取持仓盈亏
                     ccyk = context.portfolio.positions[zd_gp].pnl
                     # 获取平仓盈亏
                     pcyk = g.zqjy.loc[zd_gp, '总平盈'] + (ccyks - (value/cbj) * hqdd)
                     # 更新记录
                     g.zqjy.loc[zd_gp, ['持仓', '总平盈', '浮盈', '总计']] = [hqdd, pcyk, ccyk, pcyk+ccyk]
                     
             # 止盈
             elif zyj > zhiying and market_value > 0:
                 # 卖出所有股票,使这只股票的最终持有量为0
                 id=order_target(zd_gp, 0)
                 # 取得本次成交数量
                 hqdd = get_order(id).amount
                 # 下单成功则记录
                 if hqdd > 0:
                     # 开始计时
                     g.zyts = g.zyts + str(zd_gp) + '3' + ','
                     # 记录这次卖出
                     log.info("止盈,  %.2f 卖出 %d 张 %s" % (value, market_value, zd_gp))  
                     # 删除网格记录网格
                     g.zqc = g.zqc.drop(zd_gp, axis=0)
                     # 获取持仓盈亏
                     ccyk = context.portfolio.positions[zd_gp].pnl
                     # 获取平仓盈亏
                     pcyk = g.zqjy.loc[zd_gp, '总平盈'] + (ccyks - (value/cbj) * hqdd)
                     # 更新记录
                     g.zqjy.loc[zd_gp, ['持仓', '总平盈', '浮盈', '总计']] = [hqdd, pcyk, ccyk, pcyk+ccyk]
                     
             # 判断是否跌出黑名单       
             if market_value > 0 and time == gdsj and zd_gp in sdhmd:
                 # 卖出所有股票,使这只股票的最终持有量为0
                 id=order_target(zd_gp, 0)
                 # 取得本次成交数量
                 hqdd = get_order(id).amount
                 # 下单成功则记录
                 if hqdd > 0:
                     # 记录这次卖出
                     log.info("两点半清除黑名单,  %.2f 卖出 %d 张 %s" % (value, market_value, zd_gp))  
                     # 删除网格记录网格
                     g.zqc = g.zqc.drop(zd_gp, axis=0)
                     # 获取持仓盈亏
                     ccyk = context.portfolio.positions[zd_gp].pnl
                     # 获取平仓盈亏
                     pcyk = g.zqjy.loc[zd_gp, '总平盈'] + (ccyks - (value/cbj) * hqdd)
                     # 更新记录
                     g.zqjy.loc[zd_gp, ['持仓', '总平盈', '浮盈', '总计']] = [hqdd, pcyk, ccyk, pcyk+ccyk]
                          # 判断是否跌出黑名单
                          
         except:
             #print(zd_gp & '：出现问题')
             pass
     # 破坏初始信号
     g.yxcs += 1
# 收盘后运行函数,用于储存自定义参数、全局变量,执行盘后选股等
def after_trading(context):
     # 所有止盈天数减少1天
     if len(g.zyts) < 12 and g.zyts != '':
         if int(g.zyts[-2]) != 0:
             sl = int(g.zyts[-2]) - 1
             gp = g.zyts[:9]
             g.zyts = str(gp) + str(sl) + ','
     elif g.zyts != '' and len(g.zyts) > 12:
             zfc = g.zyts[:-1]
             szs = zfc.split(',')
             g.zyts = ''
             for sz in szs:
                 sl = int(sz[-1]) - 1
                 gp = sz[:9]
                 zf = str(gp) + str(sl) + ','
                 g.zyts = g.zyts + str(zf)
                 
     if '总计' in g.zqjy.index:           
         g.zqjy = g.zqjy.drop('总计', axis=0)
     # 更新日内浮盈
     for gps in g.zqjy.index:
         fk = context.portfolio.positions[gps].pnl
         g.zqjy.loc[gps, ['浮盈']] = [fk]
         g.zqjy.loc[gps, ['总计']] = [fk+g.zqjy.loc[gps, '总平盈']]
         g.zqjy.loc[gps, ['今平盈']] = g.zqjy.loc[gps, '总平盈']-g.zqjy.loc[gps, '今平盈']
     g.zqjy = g.zqjy.round(2)
     g.zqjy['持仓'] = g.zqjy['持仓'].astype(int)
     # 日内求和
     g.zqjy.loc['总计'] = g.zqjy.sum()
     #输出盈亏日志            
     print(g.zqjy)
     print(context.portfolio.stock_account.total_value)
     # print(g.zyts)
     log.info('一天结束')