namespace YLErp.Modules.TradeModule.DealModule
{
    /// <summary>
    /// 交易审批撤回操作
    /// </summary>
    public class TradeRevokeService : TradeServiceBase
    {
        public TradeRevokeService(YLBaseService baseService) : base(baseService)
        {
        }

        public TradeRevokeService(OptUserInfo userInfo) : base(userInfo)
        {
        }

        public void TradeRevoke(string tradeNumber)
        {
            if (string.IsNullOrWhiteSpace(tradeNumber))
            {
                throw new ArgumentException("交易编号不能为空", nameof(tradeNumber));
            }

            var td = DbContext.trade.FirstOrDefault(t => t.TradeNumber == tradeNumber);

            if (td == null)
            {
                throw new ServiceException("找不到交易信息，交易编号:" + tradeNumber);
            }

            if (td.TradeStatus != ConsTrade.行权待复核 && td.TradeStatus != ConsTrade.平仓待复核 && td.TradeStatus != ConsTrade.互换待复核)
            {
                throw new ServiceException($"交易'{tradeNumber}'的交易状态'{td.TradeStatus}'不符合撤回复核操作的条件");
            }

            TradeRevoke(new[] { td }, td.TradeStatus == ConsTrade.平仓待复核 ? 0 : 1);
        }

        public void TradeRevoke(IEnumerable<int> tradeids, int actionType)
        {
            var tradeIds = GetTradeIdsWithChildren(tradeids);
            var revokeTrades = DbContext.trade.Where(t => tradeIds.Contains(t.id)).ToList();

            TradeRevoke(revokeTrades, actionType);
        }

        private void TradeRevoke(IEnumerable<trade> revokeTrades, int actionType)
        {
            if (revokeTrades is null || !revokeTrades.Any())
            {
                return;
            }

            foreach (var td in revokeTrades)
            {
                ArchiveActiveOaOrThrow(td);
            }

            var tradeids = revokeTrades.Select(n => n.id);
            var revokeTrade_cashs = DbContext.trade_cash.Where(c => c.ValidState == "InValid" && !c.IsDeleted && tradeids.Contains(c.TradeId)).ToList();
            revokeTrade_cashs.ForEach(x =>
            {
                x.Status = "已执行";
                x.IsDeleted = true;
            });
            //DbContext.trade_cash.RemoveRange(revokeTrade_cashs);

            var tradeCashIds = revokeTrade_cashs.Select(x => x.id).ToList();
            var tradeCashDetials = DbContext.trade_cash_detail.Where(x => tradeCashIds.Contains(x.TradeCashId));
            if (tradeCashDetials.Any())
            {
                DbContext.trade_cash_detail.RemoveRange(tradeCashDetials);
            }

            var trade_cash_swaps = DbContext.trade_cash_swap.Where(x => tradeCashIds.Contains(x.TradeCashId));
            if (trade_cash_swaps.Any())
            {
                DbContext.trade_cash_swap.RemoveRange(trade_cash_swaps);
            }

            foreach (var td in revokeTrades)
            {
                //判断如果为待确认的则修改状态为确认状态
                if (td == null || (td.TradeStatus != ConsTrade.行权待复核 && td.TradeStatus != ConsTrade.平仓待复核 && td.TradeStatus != ConsTrade.互换待复核))
                {
                    throw new ServiceException("撤回失败，找不到要平仓的主交易，该交易不处于待复核状态，不能被撤回！");
                }
                td.TradeStatus = ConsTrade.确认成交;
                td.CheckStatus = null;
                td.ProcessOrderId = ProcessTradeLog.审批通过;
                td.ProcessStatus = ProcessTradeStatus.通过审批.ToString();
                AddTradeOperationHistoryAndSetParentTradeInfo(false, td, actionType == 0 ? "平仓待复核撤回" : (actionType == 1 ? "行权待复核撤回" : "互换待复核撤回"));
            }
            DbContext.SaveChanges();
        }

        public void TradeWithdraw(IEnumerable<int> tradeids)
        {
            var tradeIds = GetTradeIdsWithChildren(tradeids);
            var Withdraws = DbContext.trade.Where(t => tradeIds.Contains(t.id)).ToList();
            foreach (var td in Withdraws)
            {
                ArchiveActiveOaOrThrow(td);
                var changesTradeStatus = DbContext.TradeAuditLog.Where(x => (x.OptType == "确认交易" || x.OptType == "交易特批-确认交易") && x.TradeId == td.id).OrderByDescending(x => x.id)?.FirstOrDefault()?.Changes;
                td.TradeStatus = changesTradeStatus == ConsTrade.新增待确认 ? ConsTrade.新增待确认 : ConsTrade.修改待确认;
                td.CheckStatus = null;
                td.ProcessOrderId = 0;
                td.IsApproval = false;
                AddTradeOperationHistoryAndSetParentTradeInfo(false, td, "交易撤回");
            }
            DbContext.SaveChanges();
        }

        private void ArchiveActiveOaOrThrow(trade td)
        {
            if (!new TradeApprovalOAService(this).ArchiveActiveForTrade(td, out var errorMessage))
                throw new ServiceException(errorMessage);
        }
        /// <summary>
        /// 获取包含黑箱结构的子交易集合
        /// </summary>
        /// <param name="tradeids"></param>
        /// <returns></returns>
        private List<int> GetTradeIdsWithChildren(IEnumerable<int> tradeids)
        {
            List<int> tradeIds = tradeids.ToList();
            var childrenTrades = DbContext.trade_cash_group_action.Where(x => tradeids.Contains(x.ParentTradeId) && x.Status == "待完成");
            DbContext.trade_cash_group_action.RemoveRange(childrenTrades);
            var childrenTradeIds = childrenTrades.Select(s=>s.TradeId);
            tradeIds.AddRange(childrenTradeIds);
            return tradeIds;
        }
    }
}