using BaseOUDAL;
using YLErp.BLL;

namespace YLErp.Modules.ClientModule
{
    /// <summary>
    /// 客户资信评级服务
    /// </summary>
    public class ClientRatingService : ClientBaseService
    {
        public ClientRatingService(OptUserInfo userInfo) : base(userInfo)
        {
        }

        public ClientRatingService(ClientBaseService baseService) : base(baseService)
        {
        }

        /// <summary>
        /// 检查授信总额度是否是否超过了资信等级对应的额度
        /// </summary>
        public bool IsCreditOverTheCreditLine(CreditTable newCredit)
        {
            var curDate = valuedateBLL.ValueDate;
            //var clientrating = db.Client_Rating.Where(x => !x.IsDeleted && x.ProcessStatus == "已审批" && x.ClientId == newCredit.ClientId && newCredit.CreditStartDate >= x.RatingStartDate)
            //    .OrderByDescending(x => x.RatingDeadLine).ThenByDescending(x => x.ProcessOptDate).FirstOrDefault();
            Tuple<int, string> clientrating = GetCurrentCreditRating(curDate, newCredit.ClientId ?? 0);
            if (clientrating == null)
            {
                return false;
            }

            var creditRating = DbContext.credit_rating.FirstOrDefault(r => r.id == clientrating.Item1 && r.ValidState != ConsGlobal.InValid);
            //如果为空或者额度不限，表示没有限额
            if (creditRating == null || creditRating.IsUnLimited == 1)
            {
                return false;
            }
            return (newCredit?.Credit ?? 0) > creditRating.CreditLine;
        }

        /// <summary>
        /// 获取当前日期有效的客户评级
        /// </summary>
        public Tuple<int, string> GetCurrentCreditRating(DateTime valuedate, int clientId)
        {
            var perfectCreditRating = DbContext.Client_Rating.Where(x => !x.IsDeleted && x.ProcessStatus == "已审批" && x.ClientId == clientId
                  && x.RatingStartDate <= valuedate && x.RatingDeadLine >= valuedate).OrderByDescending(x => x.RatingDeadLine).ThenByDescending(x => x.ProcessOptDate).FirstOrDefault();//优先取deadline最大的
            if (perfectCreditRating != null)
            {
                return new Tuple<int, string>(perfectCreditRating.CreditRatingId, perfectCreditRating.CreditRatingStr);
            }
            return null;
        }

        /// <summary>
        /// 获取列表数据
        /// </summary>
        public SearchListResult<ClientRatingDto> SearchList(ClientRatingReq req)
        {
            var creditProcessList = yldb.approvalprocess.Where(x => x.processType == "CreditProcess").ToArray();

            var valuedate = valuedateBLL.ValueDate;
            var Client_RatingOpenProcessOrder = yldb.approvalprocess.Where(x => x.processType == "CreditProcess").Count();



            var query = from source in DbContext.Client_Rating.AsQueryable().Where(s => !s.IsDeleted)
                            //join process in yldb.approvalprocess.Where(a => a.processType == "CreditProcess") on source.ProcessOrderId equals process.order into pro
                            //from proce in pro.DefaultIfEmpty()
                        join client in DbContext.client.Where(a => req.DbClientIds.Contains(a.id)) on source.ClientId equals client.id
                        select new ClientRatingDto
                        {
                            id = source.id,
                            ClientId = source.ClientId,
                            ClientName = source.ClientName,
                            RatingStartDate = source.RatingStartDate,
                            RatingDeadLine = source.RatingDeadLine,
                            ClientNumber = source.ClientNumber,
                            ProcessStatusOriginal = source.ProcessStatus,
                            ProcessStatus = source.ProcessStatus == "审批中" ? source.ProcessStatus + " 流程" + (source.ProcessOrderId - 1) + "/" + Client_RatingOpenProcessOrder : source.ProcessStatus,
                            //ProcessRoleId = proce.roleId,
                            ProcessRoleName = "",
                            ProcessOptDate = source.ProcessOptDate,
                            OptId = source.OptId,
                            OptName = source.OptName,
                            ProcessOrderId = source.ProcessOrderId,
                            OptDate = source.OptDate,
                            RoleId = source.RoleId,
                            RoleName = source.RoleName,
                            CreditRatingId = source.CreditRatingId,
                            CreditRatingStr = source.CreditRatingStr,
                            RatingAccording = source.RatingAccording,
                            RatingPersonnel = source.RatingPersonnel,
                            CheckPersonnel = source.CheckPersonnel,
                            Comments = source.Comments,
                            BusinessType = client.BusinessType
                        };

            if (req.ShowExpiredRecords)
            {
                var notExpiredCids = DbContext.Client_Rating.Where(x => !x.IsDeleted && x.ProcessStatus == "已审批"
              && x.RatingStartDate <= valuedate && x.RatingDeadLine >= valuedate && x.ClientId > 0).Select(x => x.ClientId).Distinct().ToArray();//具有有效评级的客户 
                query = query.Where(d => !notExpiredCids.Contains(d.ClientId));
            }

            if (req.ClientId > 0)
            {
                query = query.Where(d => d.ClientId == req.ClientId);
            }

            if (!string.IsNullOrEmpty(req.ClientName))
            {
                query = query.Where(d => d.ClientName.Contains(req.ClientName));
            }

            if (!string.IsNullOrWhiteSpace(req.ProcessStatuses))
            {
                query = query.Where(d => req.ProcessStatusList.Contains(d.ProcessStatusOriginal));
            }
            if (req.RatingDeadLineStart != DateTime.MinValue)
            {
                query = query.Where(d => d.RatingDeadLine >= req.RatingDeadLineStart);
            }

            if (req.RatingDeadLineEnd != DateTime.MinValue)
            {
                query = query.Where(d => d.RatingDeadLine <= req.RatingDeadLineEnd);
            }

            if (!string.IsNullOrEmpty(req.ClientNumber))
            {
                query = query.Where(d => d.ClientNumber.Contains(req.ClientNumber));
            }

            if (req.OptId != null)
            {
                query = query.Where(d => d.OptId == req.OptId);
            }

            if (!string.IsNullOrEmpty(req.OptName))
            {
                query = query.Where(d => d.OptName.Contains(req.OptName));
            }

            if (req.OptDateStart != DateTime.MinValue)
            {
                query = query.Where(d => d.OptDate >= req.OptDateStart);
            }

            if (req.OptDateEnd != DateTime.MinValue)
            {
                DateTime OptDateTemp = req.OptDateEnd.AddDays(1);
                query = query.Where(d => d.OptDate < OptDateTemp);
            }

            if (string.IsNullOrEmpty(req.sidx))
            {
                req.sidx = "id";
                req.sord = "desc";
            }
            var DbErpBaseContext = new ErpBaseContext();
            query = query.OrderByDescending(x => x.OptDate);
            var retListResult = query.ToSearchList(req);
            var listRoles = DbErpBaseContext.Roles.Select(n => new { n.Id, n.Name }).ToDictionary(n => n.Id, m => m.Name);
            foreach (var item in retListResult.rows)
            {
                if (item.ProcessOrderId > 0)
                {
                    item.ProcessRoleId = creditProcessList.FirstOrDefault(n => n.order == item.ProcessOrderId)?.roleId;
                }
                if (item.ProcessRoleId != null && listRoles.TryGetValue(item.ProcessRoleId.Value, out var name))
                {
                    item.ProcessRoleName = name;
                }
            }
            return retListResult;
        }
    }

    /// <summary>
    /// 客户资信评级查询请求
    /// </summary>
    public class ClientRatingReq : BaseSearchReq
    {
        public int? id { get; set; }

        /// <summary>
        /// 评级Id
        /// </summary>   
        public int CreditRatingId { get; set; }

        /// <summary>
        /// 评级
        /// </summary>   
        public string CreditRatingStr { get; set; }

        /// <summary>
        /// 客户信息
        /// </summary> 
        public int ClientId { get; set; }

        public List<int> ClientIds { get; set; }

        public List<int> DbClientIds { get; set; }

        /// <summary>
        /// 客户名称
        /// </summary> 
        public string ClientName { get; set; }

        /// <summary>
        /// 评级起始日
        /// </summary>
        public DateTime? RatingStartDate { get; set; }

        /// <summary>
        /// 评级到期日
        /// </summary> 
        public DateTime? RatingDeadLine { get; set; }

        public DateTime RatingDeadLineStart { get; set; }

        public DateTime RatingDeadLineEnd { get; set; }

        public string RatingAccording { get; set; }
        public string RatingPersonnel { get; set; }
        public string CheckPersonnel { get; set; }

        /// <summary>
        /// 用户编号
        /// </summary> 
        public string ClientNumber { get; set; }

        /// <summary>
        /// 操作人_optid
        /// </summary> 
        public int? OptId { get; set; }

        /// <summary>
        /// 操作人_optid
        /// </summary> 
        public string OptName { get; set; }

        /// <summary>
        /// 操作时间_createdate
        /// </summary> 
        public DateTime? OptDate { get; set; }

        public DateTime OptDateStart { get; set; }

        public DateTime OptDateEnd { get; set; }

        /// <summary>
        /// 评级状态
        /// </summary>
        public string ProcessStatuses { get; set; }

        public List<string> ProcessStatusList
        {
            get
            {
                if (string.IsNullOrWhiteSpace(ProcessStatuses))
                {
                    return new List<string>();
                }

                return ProcessStatuses.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
            }
        }

        /// <summary>
        /// 客户代码列表
        /// </summary>
        public List<string> ClientNumberList { get; set; }

        /// <summary>
        /// 客户名称列表
        /// </summary>
        public List<string> ClientNameList { get; set; }

        /// <summary>
        /// 评级列表
        /// </summary>
        public List<string> RateList { get; set; }

        /// <summary>
        /// 评级有效期开始时间
        /// </summary>
        public DateTime? Client_RatingStartDateStart { get; set; }

        /// <summary>
        /// 评级有效期截至时间
        /// </summary>
        public DateTime? Client_RatingStartDateEnd { get; set; }

        /// <summary>
        /// 评级状态列表
        /// </summary>
        public List<string> ProcessStatusList_New { get; set; }

        /// <summary>
        /// 说明
        /// </summary>
        public string Comments { get; set; } = "";

        /// <summary>
        /// 只显示全部无效评级客户的记录
        /// </summary>
        public bool ShowExpiredRecords { get; set; }
    }
}