using YLErp.BLL;
using YLErp.Modules;
using static YLErp.ConsGlobal;

namespace YLErp.CustomizedBizLogic
{
    public abstract class BizLogicDefault : IBizLogic
    {
        /// <summary>
        /// 在交易确认前生成交易编号
        /// </summary>
        public virtual string GenerateTradeNumberBeforeConfirm(TradeNumberReqModel reqModel, YLContext db)
        {
            if (reqModel is null)
            {
                throw new ArgumentNullException(nameof(reqModel));
            }

            //对于对冲交易、场内交易等没有设置客户的
            if (reqModel.clientId == 0)
            {
                return DateTime.Now.ToString("yyyyMMddHHmmssfff");
            }

            var clientNumber = DataCacheProvider.GetClientDataSource().GetData(reqModel.clientId)?.Number.TrimToNull();

            string preTag = clientNumber ?? "N", midTag = "C";
            var stockInstrumentTypes = new[] { InstrumentType.Stock, InstrumentType.StockIF };
            var um = DataCacheProvider.GetUnderlyingDataSource().GetData(reqModel.trade.UnderlyingId);
            //权益类场外交易编号处理
            if (um != null && stockInstrumentTypes.Contains(um.UnderlyingInstrumentType))
            {
                var E_TradeTypes = new[] { "香草期权", "自定义交易", "结构化交易" };
                midTag = E_TradeTypes.Contains(reqModel.trade.TradeType) ? "E" : "X";
                //if (preTag.StartsWith("CW")) preTag = "OTC" + preTag.Substring(2);
            }

            //合并起来作为获取递增序号的取值条件
            var leftPart = preTag + midTag;
            var fullSize = leftPart.Length + 4;

            //获取数据库该用户最大的交易编号记录
            var tradeNumber = db.trade.Where(x => x.TradeNumber.StartsWith(leftPart) && x.TradeNumber.Length == fullSize)
                .OrderByDescending(x => x.TradeNumber).Select(n => n.TradeNumber).FirstOrDefault() ?? string.Empty;

            if (reqModel.importTrades != null && reqModel.importTrades.Any())
            {
                //获取导入交易中该客户最大的交易编号记录
                var importTradeNumber = reqModel.importTrades.Where(x => x.TradeNumber.StartsWith(leftPart) && x.TradeNumber.Length == fullSize)
                    .OrderByDescending(x => x.TradeNumber).Select(n => n.TradeNumber).FirstOrDefault() ?? string.Empty;
                tradeNumber = tradeNumber.CompareTo(importTradeNumber) > 0 ? tradeNumber : importTradeNumber;
            }

            //获取总的该用户最大的交易编号记录
            int newNumber = string.IsNullOrWhiteSpace(tradeNumber) ? 1 : (int.Parse(tradeNumber.Substring(leftPart.Length)) + 1);

            if (newNumber < 1e4)
            {
                return leftPart + newNumber.ToString("D4");
            }
            else
            {
                throw new Exception("该客户存在最大交易编号" + (newNumber - 1) + "，超出了限制规则9999，生成交易编号失败");
            }
        }

        /// <summary>
        /// 在交易确认前生成子交易编号
        /// </summary>
        /// <param name="curLeg">当前子交易</param>
        /// <param name="masterTrade">主交易</param>
        /// <param name="legIndex">当前子交易序号</param>
        /// <returns></returns>
        public virtual string GenerateSubTradeNumberBeforeConfirm(trade curLeg, trade masterTrade, int legIndex, YLContext db)
        {
            if (PS.Config.Is物产中大)
            {
                if (legIndex == 1)
                {
                    return GenerateTradeNumberBeforeConfirm(curLeg, db);
                }
                else if (legIndex > 1)
                {
                    var firstTrade = masterTrade.SubTrades.Skip((legIndex > 2 ? legIndex : 2) - 2).FirstOrDefault();
                    var num = firstTrade.TradeNumber.Split("-").LastOrDefault();
                    var tradeNumber = firstTrade.TradeNumber.Substring(0, firstTrade.TradeNumber.LastIndexOf("-")) +"-"+ (int.TryParse(num, out int n) ? n + 1 : 0).ToString("D3");
                    curLeg.MetaDic["期货报送成交编号"] = new BizLogicWCZD().GenerateWCZDNumber(db, curLeg, curLeg.TradeDate, 0, false,leg: legIndex-1);
                    return tradeNumber.ToString();
                }
                else
                {
                    throw new ArgumentNullException(nameof(masterTrade));
                }
            }
            else
            {
                return masterTrade.TradeNumber + "-" + legIndex.ToString();
            }
        }

        /// <summary>
        /// 根据交易编号获取交易确认书的前缀
        /// </summary>
        public virtual string GetTradeContractPrefix(string tradeNumber)
        {
            if (tradeNumber.IndexOf("(") != -1)
            {
                return tradeNumber.Substring(0, tradeNumber.IndexOf("("));
            }
            else
            {
                return tradeNumber;
            }
        }

        /// <summary>
        /// 生成客户编号
        /// 生成规则：例如 CW20180001 ， CW为固定字符，加上4位年份， 最后四位是序列编号，从0001开始，每增加一个客户自动加1，序号最大值9999
        /// </summary>
        /// <param name="initialCode">客户创建时的初始编号，如果没有传null</param>
        /// <param name="db"></param>
        public virtual void GenerateClientCode(Client clientObj, IQueryable<Client> clientDbQuery)
        {

            if (string.IsNullOrWhiteSpace(clientObj.Number))
            {
                var result = "CW";
                lock (_clientCodeLock)
                {
                    result += DateTime.Now.Year.ToString();

                    var existingClientCodes = clientDbQuery.Where(x => x.Number.Contains(result)).Select(x => x.Number).ToList();
                    var maxNumber = 0;
                    if (existingClientCodes.Count > 0)
                    { maxNumber = existingClientCodes.Max(x => ParseNumber(x.Substring(6))); }
                    var nextNum = maxNumber + 1;
                    if (nextNum < 10000)
                    {
                        result += nextNum.ToString("D4");
                    }
                    else
                    {
                        //如果大于9999，将生成CW201810000等字符串，需求是说不会大于10000的
                        result += nextNum.ToString();
                    }
                    clientObj.Number = result;
                }
            }
        }

        protected static readonly object _clientCodeLock = new object();

        private int ParseNumber(string clientNumber)
        {
            int.TryParse(clientNumber, out var number);
            return number;
        }

        protected Client GetClient(int clientId)
        {
            return DataCacheProvider.GetClientDataSource().GetData(clientId);
        }
    }
}