using System.Data;
using System.Text.RegularExpressions;
using YLErp.BLL;
using YLErp.BLL.MarginCalculation;
using YLErp.DBModels.Consts;
using YLErp.DBModels.Converts;
using YLErp.Model;
using YLErp.Models;
using YLErp.Modules.DataProviderModule;
using YLErp.Modules.TradeDalModule;
using YLErp.Office;
using YLErp.Plugins.TradeDocGenerator.Abstracts;

namespace YLErp.Modules.TradeModule.DocGenerateModule
{
    /// <summary>
    /// 生成远期结算确认书
    /// </summary>
    public class ForwardSettlementBillGenerateService : YLBaseService
    {
        public ForwardSettlementBillGenerateService(OptUserInfo userInfo) : base(userInfo)
        {
        }

        public ForwardSettlementBillGenerateService(YLBaseService baseService) : base(baseService)
        {
        }

        /// <summary>
        /// 获取交易关联的标的
        /// </summary>
        public underlying_manager GetTradeUnderlying(string underlyingcode)
        {
            var _underlying = DbContext.underlying_manager.AsNoTracking().FirstOrDefault(x => x.UnderlyingCode == underlyingcode);
            return _underlying;
        }

        /// <summary>
        /// 生成结算确认书
        /// </summary>
        public List<TradeDocGenerateResult> Generate(IEnumerable<int> tradeCashIds, IEnumerable<int> tradeIds, string docType)
        {
            if (tradeCashIds != null && tradeCashIds.Any())
            {
                tradeIds = DbContext.trade_cash.Where(x => tradeCashIds.Contains(x.id) && !x.IsDeleted).Select(x => x.TradeId).Distinct();
            }
            if (tradeIds == null)
            {
                throw new ArgumentNullException(nameof(tradeIds));
            }

            if (docType == null)
            {
                throw new ArgumentNullException(nameof(docType));
            }

            //当前交易日
            var valueDate = valuedateBLL.ValueDate;

            //----------------------------------
            // 获取当日行权 平仓 到期的有效交易
            //----------------------------------
            var service = new TradeDalService(this);
            var tradeQuery = service
                .GetTradeOrEodTrade(tradeIds, valueDate)
                .Where(O => O.TradeStatus== ConsTrade.已平仓
                    && O.UnWindDate <= valueDate
                    && O.ClientId != 0);
            var tradeDic = tradeQuery.ToDictionary(n => n.id, n => new trade_contract_group { trade = n });
            if (tradeDic.Count < 1)
            {
                throw new ServiceException("当日没有要结算的记录信息!");
            }

            tradeIds = tradeDic.Keys.ToArray();
            //----------------------------------
            // 交易确认书数据
            //----------------------------------
            var tcrQuery = from aa in DbContext.trade_contract_r
                           where tradeIds.Contains(aa.TradeId)
                           && aa.Type == ContractTypeEnum.Trade && aa.IsValid
                           select aa;
            var tcrDatas = tcrQuery.ToDictionary(K => K.TradeId, V => V);
            foreach (var data in tradeDic)
            {
                var id = data.Key;
                if (tcrDatas.TryGetValue(id, out var tcr))
                { data.Value.ConfirmContractR = tcr; }
            }

            //----------------------------------
            // 交易现金交割记录
            //----------------------------------
            var tradeCashDict = new Dictionary<int, int>();

            var cashQuery = from tradeCash in DbContext.trade_cash.AsNoTracking()
                            where tradeIds.Contains(tradeCash.TradeId) &&
                            tradeCash.ValidState != ConsGlobal.InValid && !tradeCash.IsDeleted
                            && tradeCash.IsLastAction
                            && tradeCash.ExerciseWay == TradeCashExerciseWayEnum.提前终止行权
                            select tradeCash;
            //当一笔交易存在多条到期行权记录时，取的最后一条资金记录。 --时嬴政 2022年8月2日
            var cashDatas = cashQuery.AsEnumerable().GroupBy(O => O.TradeId).ToDictionary(K => K.Key, V => V.LastOrDefault());
            if (tradeCashIds != null && tradeCashIds.Count() > 0)
            {
                tradeCashDict = cashDatas.Where(O => tradeCashIds.Contains(O.Value.id)).Select(O => O).ToDictionary(K => K.Key, V => V.Value.id);
            }
            else
            {
                tradeCashDict = cashDatas.Select(O => O).ToDictionary(K => K.Key, V => V.Value.id);
            }

            foreach (var data in cashDatas)
            {
                if (tradeDic.TryGetValue(data.Value.TradeId, out var group))
                {
                    group.trade.trade_cash = data.Value;
                    group.trade_cash = data.Value;
                }
            }

            //----------------------------------
            // 生成交易结算书
            //----------------------------------
            var resultList = new List<TradeDocGenerateResult>();
            AppManager.TryResolve(out ITradeSettleBillGenerator generatorV2);
            var cacheList = new List<string>();
            //客户编号列表
            foreach (var tradeContractGroup in tradeDic.Values)
            {
                if (tradeContractGroup.trade.TradeStatus != ConsTrade.已平仓 && tradeContractGroup.trade_cash == null)
                {
                    resultList.Add(new TradeDocGenerateResult(tradeContractGroup.trade)
                    {
                        ErrorMessage = "缺少现金交割记录"
                    });
                }
                else if (generatorV2 != null)
                {
                    var key = $"{tradeContractGroup.trade.id}_{tradeContractGroup.trade_cash.Action}_{tradeContractGroup.trade_cash.Notional}_{tradeContractGroup.trade_cash.UnwindNotional}";
                    //判断重复
                    if (cacheList.Contains(key))
                    {
                        continue;
                    }
                    cacheList.Add(key);
                    var result = GenerateSingleV2(generatorV2, tradeContractGroup, tradeContractGroup.trade_cash.id, docType);
                    resultList.Add(result);
                }
            }

            return resultList;
        }

        /// <summary>
        /// 
        /// </summary>
        private TradeDocGenerateResult GenerateSingleV2(ITradeSettleBillGenerator generator, trade_contract_group tradeContractGroup, int tradeCashId, string docType = "DOCX")
        {
            try
            {
                var context = new SettlementBillGenerateContext(tradeCashId, tradeContractGroup.trade, ContractTypeEnum.Clearing, OptUser);

                generator.Initialize(docType, context);
                return generator.GenerateDocument();
            }
            catch (Exception ex)
            {
                LogFactory.GetLogger("GenerateSingleV2").Error(ex);

                return new TradeDocGenerateResult(tradeContractGroup.trade)
                {
                    Exception = ex,
                    ErrorMessage = "出错:" + ex.Message
                };
            }
        }
    }
}