using System.Text.RegularExpressions;
using YLErp.BLL;
using YLErp.Modules;

namespace YLErp.CustomizedBizLogic
{
    public class BizLogicGT : BizLogicDefault
    {
        /*
         《交易确认书》编码规则为：“协议类型”-“机构类型”-“交易对手方编号” -“业务部门编号”-“业务类型”-“交易达成日期”（8 位数字，日期格式为 YYYYMMDD）
         */
        private readonly string _SAC = "SAC";//协议类型

        public override string GenerateTradeNumberBeforeConfirm(TradeNumberReqModel reqModel, YLContext db)
        {
            if (reqModel is null)
            {
                throw new ArgumentNullException(nameof(reqModel));
            }

            if (reqModel.trade.TradeDate == null)
            {
                throw new Exception("生成合同编号失败，请先确认该交易成交日期!");
            }

            if (!string.IsNullOrWhiteSpace(reqModel.trade.TradeNumber)) { return reqModel.trade.TradeNumber; }

            string code = "";
            using (var clientDB = DbContextFactory.GetClientDbContext(null))
            {
                var client = clientDB.client.Where(a => a.id == reqModel.clientId).FirstOrDefault();
                if (client == null)
                {
                    throw new Exception("未找到客户!");
                }

                var trade = reqModel.trade;
                var um = DataCacheProvider.GetUnderlyingDataSource().GetData(trade.UnderlyingCode);
                client.MetaDic = clientDB.ClientMeta.AsNoTracking().Where(t => t.ClientId == reqModel.clientId)
                .Select(n => new { n.MetaKey, n.MetaValue }).ToDictionary(n => n.MetaKey, n => n.MetaValue);

                if (!client.MetaDic.Any(a => a.Key.Contains("OrganizationType")))
                {
                    throw new Exception($"请设置【{client.Name}】客户【机构类型】属性");
                }
                if (!client.MetaDic.Any(a => a.Key.Contains("BusinessDeptCode")))
                {
                    throw new Exception($"请设置【{client.Name}】客户【业务部门编号】属性");
                }
                if (!client.MetaDic.Any(a => a.Key.Contains("ClientCode")))
                {
                    throw new Exception($"请设置【{client.Name}】客户【客户代码】属性");
                }

                //当等于远期时，判断是否累计转的，如果是远期编号规则 -> 当前累计转的远期数量+ 用累计的交易编号 
                if (reqModel.trade.TradeType == "远期" && reqModel.trade.MetaDic.TryGetValue("累计期权交易编号",out var accumulatorTradeNumber) && !string.IsNullOrEmpty(accumulatorTradeNumber))
                {
                    var accumulatorTrade = db.trade.FirstOrDefault(n => n.TradeNumber == accumulatorTradeNumber);
                    var forwardTradeCount = db.autocall_observation.Where(n => n.TradeId == accumulatorTrade.id && n.SettlementMode.Contains("转远期")).Count();
                    var newForwardTradeNumber = $"L{(forwardTradeCount + 1)}-{accumulatorTradeNumber}";
                    return newForwardTradeNumber;
                }


                string OrganizationType = client.MetaDic["OrganizationType"];//机构类型
                string BusinessDeptCode = client.MetaDic["BusinessDeptCode"];//业务部门编号
                string ClientCode = client.MetaDic["ClientCode"];//客户代码

                string BuinessType = trade.TradeType == "远期" ? "SW" : "OP";
                code = $"{_SAC}-{OrganizationType}-{ClientCode}-{BusinessDeptCode}-{BuinessType}-{trade.TradeDate?.ToString("yyyyMMdd")}";
                var tradeNumbers = new List<string>();
                tradeNumbers = db.trade.Where(x => x.TradeDate == trade.TradeDate && x.ParentTradeId == 0).Select(x => x.TradeNumber).ToList();
                //获取导入
                if (reqModel.importTrades != null)
                {
                    tradeNumbers.AddRange(reqModel.importTrades.Select(O => O.TradeNumber));
                }

                var number = tradeNumbers.Count;
                do
                {
                    number++;
                    code = $"{code}-{number:0000}";
                    if (!tradeNumbers.Contains(code))
                    { break; }
                } while (true);
            }
            return code;
        }
        public override void GenerateClientCode(Client clientObj, IQueryable<Client> clientDbQuery)
        {
            lock (_clientCodeLock)
            {
                using (var db = DbContextFactory.GetClientDbContext(null))
                {
                    if ((!clientObj.MetaDic.Any(a => a.Key.Contains("ClientCode"))) ||
                       string.IsNullOrEmpty(clientObj.MetaDic["ClientCode"])
                        )
                    {

                        var code = "";
                        int number = 0000;
                        var numberList = db.ClientMeta.Where(a => a.MetaKey.Contains("ClientCode")).Select(x => x.MetaValue).ToList();
                        if (numberList.Any())
                        {
                            var existingClientCodes = numberList.Where(x => Regex.IsMatch(x, @"^\d{4}$"));
                            int maxNumber = Convert.ToInt32(existingClientCodes.Max(x => x));
                            number = maxNumber > number ? maxNumber : number;
                        }
                        do
                        {
                            number++;
                            code = number.ToString("0000");
                            if (!numberList.Contains(code))
                            { break; }
                        } while (true);
                        clientObj.MetaDic["ClientCode"] = code;
                    }

                    if (string.IsNullOrEmpty(clientObj.Number))
                    {
                        var code = "";
                        int number = 0;
                        string year = DateTime.Now.ToString("yyyy");
                        var numberList = clientDbQuery.Where(x => !string.IsNullOrEmpty(x.Number)).Select(x => x.Number).ToList();
                        if (numberList.Any())
                        {
                            var existingClientCodes = numberList.Where(x => Regex.IsMatch(x, @"^\d{7}$") && x.Contains(year)).Select(x => x.Substring(4));
                            int maxNumber = Convert.ToInt32(existingClientCodes.Max(x => x));
                            number = maxNumber > number ? maxNumber : number;
                        }
                        do
                        {
                            number++;
                            code = year + number.ToString("000");
                            if (!numberList.Contains(code))
                            { break; }
                        } while (true);
                        clientObj.Number = code;
                    }

                    if (!clientObj.MetaDic.Any(a => a.Key.Contains("OrganizationType")))
                    {
                        throw new Exception($"请设置【{clientObj.Name}】客户【机构类型】属性");
                    }
                    if (!clientObj.MetaDic.Any(a => a.Key.Contains("BusinessDeptCode")))
                    {
                        throw new Exception($"请设置【{clientObj.Name}】客户【业务部门编号】属性");
                    }
                    if (!clientObj.MetaDic.Any(a => a.Key.Contains("AdditionalProtocolDate")))
                    {
                        throw new Exception($"请设置【{clientObj.Name}】客户【附加协议生效日期】属性");
                    }
                    if (!clientObj.MetaDic.Any(a => a.Key.Contains("WorkType")))
                    {
                        throw new Exception($"请设置【{clientObj.Name}】客户【业务类型】属性");
                    }

                    string OrganizationType = clientObj.MetaDic["OrganizationType"];//机构类型
                    string BusinessDeptCode = clientObj.MetaDic["BusinessDeptCode"];//业务部门编号
                    string AdditionalProtocolDate = clientObj.MetaDic["AdditionalProtocolDate"];//附加协议生效日期
                    string WorkType = clientObj.MetaDic["WorkType"];//业务类型

                    if (string.IsNullOrEmpty(clientObj.MainProtocolCode))
                    {
                        clientObj.MainProtocolCode = $"{_SAC}-{OrganizationType}-{clientObj.MetaDic["ClientCode"]}";
                    }

                    var dateAp = new DateTime();
                    DateTime.TryParse(AdditionalProtocolDate, out dateAp);
                    if (string.IsNullOrEmpty(clientObj.SupProtocolCode))
                    {
                        clientObj.SupProtocolCode = $"{_SAC}-{OrganizationType}-{clientObj.MetaDic["ClientCode"]}-A-{dateAp.ToString("yyyyMMdd")}";
                    }
                    if (string.IsNullOrEmpty(clientObj.AgreementBookNo))
                    {
                        clientObj.AgreementBookNo = $"{_SAC}-{OrganizationType}-{clientObj.MetaDic["ClientCode"]}-M-{dateAp.ToString("yyyyMMdd")}-{BusinessDeptCode}-{WorkType}";
                    }
                }

            }

        }
    }
}