using Org.BouncyCastle.Ocsp;
using System.Linq;
using YLErp.Abstract;
using YLErp.Commons;
using YLErp.DBModels.Abstract;
using YLErp.DBModels.Consts;
using YLErp.Model;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;

namespace YLErp.Modules.TradeModule
{
    /// <summary>
    /// 交易确认书接口
    /// </summary>
    public class TradeContractBLL : YLBaseService, IContractBLL
    {
        private static readonly object lockObj = new object();

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

        public TradeContractBLL(int optId, string optName) : base(new OptUserInfo(optId, optName, OptUserFrom.System, null))
        {
        }

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

        public int GetRuleIndex(string ruleId, int beginIndex = 1)
        {
            lock (lockObj)
            {
                var contractNoGenRule = DbContext.rpt_contract_no_gen_rule.FirstOrDefault(s => s.RuleId == ruleId);
                if (contractNoGenRule == null)
                {
                    contractNoGenRule = new rpt_contract_no_gen_rule
                    {
                        RuleId = ruleId,
                        SeqNum = beginIndex
                    };
                    DbContext.rpt_contract_no_gen_rule.Add(contractNoGenRule);
                    DbContext.SaveChanges();
                    return beginIndex;
                }
                contractNoGenRule.SeqNum = contractNoGenRule.SeqNum + 1;

                DbContext.SaveChanges();
                return contractNoGenRule.SeqNum.Value;
            }
        }

        public string GetContractNo(string ruleId)
        {
            var index = GetRuleIndex(ruleId);
            return $"{index.ToString().PadLeft(4, '0')}";
        }

        /// <summary>
        /// 获取确认书
        /// </summary>
        public ITradeContractDocument GetContractDoc(int tradeId, string contractType, int tradeCashId = 0, DateTime? valueDate = null)
        {
            //var docQuery = (from contractDoc in DbContext.trade_contract_document
            //                from contractRelation in DbContext.trade_contract_r
            //                where contractDoc.Code == contractRelation.ContractCode
            //                   && contractDoc.Type == contractRelation.Type && contractRelation.IsValid
            //                   && contractDoc.Type == contractType && contractRelation.TradeId == tradeId
            //                select contractDoc);
            var docQuery = DbContext.trade_contract_document
                            .Join(DbContext.trade_contract_r,
                            contractDoc => new { Code = contractDoc.Code, Type = contractDoc.Type },
                            contractRelation => new { Code = contractRelation.ContractCode, Type = contractRelation.Type },
                            (contractDoc, contractRelation) => new
                            {
                                contractDoc,
                                contractRelation
                            })
                            .Where(t => t.contractRelation.IsValid && t.contractDoc.Type == contractType && t.contractRelation.TradeId == tradeId);

            if ((tradeCashId == 0 && contractType == ContractTypeEnum.UnWind) || contractType == ContractTypeEnum.Trade || contractType == ContractTypeEnum.Clearing)
            {
                var doc = docQuery.Select(d => d.contractDoc).FirstOrDefault();
                return doc;
            }

            if (tradeCashId > 0 && contractType == ContractTypeEnum.UnWind)
            {
                var doc = docQuery.Where(d => d.contractRelation.TradeCashId == tradeCashId).Select(d => d.contractDoc).FirstOrDefault();
                //var doc = (from contractDoc in DbContext.trade_contract_document
                //           from contractRelation in DbContext.trade_contract_r
                //           where contractDoc.Code == contractRelation.ContractCode
                //              && contractDoc.Type == contractRelation.Type
                //              && contractDoc.Type == contractType
                //              && contractRelation.TradeId == tradeId
                //              && contractRelation.TradeCashId == tradeCashId
                //              && contractRelation.IsValid
                //           select contractDoc).FirstOrDefault();
                return doc;
            }

            if (contractType == ContractTypeEnum.Margin && valueDate != null)
            {
                var doc = docQuery.Where(d => d.contractDoc.ValueDate == valueDate).Select(d => d.contractDoc).FirstOrDefault();
                //var doc = (from contractDoc in DbContext.trade_contract_document
                //           from contractRelation in DbContext.trade_contract_r
                //           where contractDoc.Code == contractRelation.ContractCode
                //              && contractDoc.Type == contractRelation.Type
                //              && contractDoc.Type == contractType
                //              && contractRelation.TradeId == tradeId
                //              && contractRelation.IsValid
                //              && contractDoc.ValueDate == valueDate
                //           select contractDoc).FirstOrDefault();
                return doc;
            }
            return null;
        }

        public ITradeContractDocument GetContractDocBySwapEventId(int tradeId, string contractType, long swapEventId)
        {
            var docQuery = DbContext.trade_contract_document
                            .Join(DbContext.trade_contract_r,
                            contractDoc => new { Code = contractDoc.Code, Type = contractDoc.Type },
                            contractRelation => new { Code = contractRelation.ContractCode, Type = contractRelation.Type },
                            (contractDoc, contractRelation) => new
                            {
                                contractDoc,
                                contractRelation
                            })
                            .Where(t => t.contractRelation.IsValid && t.contractDoc.Type == contractType && t.contractRelation.TradeId == tradeId&&t.contractRelation.SwapFlowEventId== swapEventId);

            var doc = docQuery.Select(d => d.contractDoc).FirstOrDefault();
            return doc;
        }
        /// <summary>
        /// 获取确认书
        /// </summary>
        public IEnumerable<ITradeContractDocument> GetContractDoc(int clientId, string contractType, DateTime valueDate)
        {
            var doc = (from contractDoc in DbContext.trade_contract_document
                       join contractRelation in DbContext.trade_contract_r
                       on contractDoc.Code equals contractRelation.ContractCode
                       join t in DbContext.trade on contractRelation.TradeId equals t.id
                       where
                       contractDoc.ValueDate == valueDate &&
                       contractDoc.Type == contractType &&
                       contractDoc.Type == contractRelation.Type &&
                       t.ClientId == clientId && contractRelation.IsValid
                       select contractDoc).ToArray();
            return doc; ;
        }

        /// <summary>
        /// 获取所有文档
        /// </summary>
        public IEnumerable<ITradeContractDocument> GetAllContractDocs(int tradeId)
        {
            var docList = (from contractDoc in DbContext.trade_contract_document
                           join contractRelation in DbContext.trade_contract_r on contractDoc.Code equals contractRelation.ContractCode
                           where contractDoc.Type == contractRelation.Type
                                 && contractRelation.TradeId == tradeId
                                 && contractRelation.IsValid
                           select contractDoc).ToList();
            return docList;
        }

        /// <summary>
        /// 删除确认书
        /// </summary>
        public void DeleteConfirmBook(int tradeId, string contractType = ContractTypeEnum.Trade)
        {
            new TradeDocumentDataService(this).DeleteConfirmBook(tradeId, contractType);
        }

        /// <summary>
        /// 获取对应的交易确认书协议版本号
        /// </summary>
        public static string GetTradeConfirmContractVersion(ServiceRepresentativeConfig sp, string BuySell, string UnderlyingInstrumentType)
        {
            if (sp != null)
            {
                switch (BuySell)
                {
                    case EnumTradeBuySell.Sell:
                        if ("Stock".Equals(UnderlyingInstrumentType))
                        {
                            return sp.StockBuyContractVersion;
                        }
                        else
                        {
                            return sp.FutureBuyContractVersion;
                        }
                    case EnumTradeBuySell.Buy:
                        if ("Stock".Equals(UnderlyingInstrumentType))
                        {
                            return sp.StockSellContractVersion;
                        }
                        else
                        {
                            return sp.FutureSellContractVersion;
                        }
                    default:
                        return null;
                }
            }
            else
            {
                return null;
            }

        }

        /// <summary>
        /// 检查相同合约书号是否对应的相同客户相同交易方向的确认书编号(买卖方向)
        /// </summary>
        public bool HasRepeatContractCodeForDiffClient(string ContractCode, string clientName, string BuySell, out string TradeNumber)
        {
            TradeNumber = null;
            if (ContractTrades == null)
            {
                ContractTrades = (from contract in DbContext.trade_contract_r
                                  where contract.ContractCode == ContractCode
                                  join trade in DbContext.trade on contract.TradeId equals trade.id
                                  where trade.ValidState != "InValid" && contract.IsValid
                                  select new { contract, trade }).ToLookup(t => t.contract.ContractCode).ToDictionary(t => t.Key, t => t.Select(a => a.trade).ToList());
            }
            if (ContractTrades.ContainsKey(ContractCode))
            {
                var query = ContractTrades[ContractCode].Where(t => t.ClientName != clientName);
                if (BuySell != null)
                {
                    query = ContractTrades[ContractCode].Where(t => t.ClientName != clientName || t.BuySell != BuySell);
                }
                if (query.Any())
                {
                    TradeNumber = query.Select(t => t.TradeNumber).FirstOrDefault().ToString();
                    return true;
                }
            }
            return false;
        }

        public trade_contract_r GetTrade_Contract_R(int tradeId)
        {
            return DbContext.trade_contract_r.AsNoTracking().FirstOrDefault(x => x.TradeId == tradeId && x.Type == ContractTypeEnum.Trade && x.IsValid);
        }

        public Dictionary<long, ITradeContractDocument> GetContractDocDic(List<long> swapFlowEventIds, string contractType, DateTime valueDate)
        {
            Dictionary<long, ITradeContractDocument> dic=new Dictionary<long, ITradeContractDocument>();
            var contracts= DbContext.trade_contract_r.Where(x=> swapFlowEventIds.Contains(x.SwapFlowEventId??0)&&x.IsValid&&x.Type== contractType).ToList();
            var ContractCodes= contracts.Select(x => x.ContractCode).ToList();
            var contractDocs = DbContext.trade_contract_document.Where(x=> ContractCodes.Contains(x.Code)&&x.Type== contractType&& x.ValueDate== valueDate).ToList();
            foreach (var fid in swapFlowEventIds)
            {
                var contract = contracts.FirstOrDefault(x=>x.SwapFlowEventId==fid);
                if (contract!=null)
                {
                    var contractDoc = contractDocs.FirstOrDefault(x=>x.Code== contract.ContractCode);
                    dic.Add(fid, contractDoc);
                }
                else
                {
                    dic.Add(fid,null);
                }
               
            }
            return dic;
        }

        private Dictionary<string, List<trade>> ContractTrades = null;
    }
}