using BBWYB.Common.Log;
using BBWYB.Common.Models;
using BBWYB.Server.Model.Db;
using BBWYB.Server.Model.Dto;
using Yitter.IdGenerator;

namespace BBWYB.Server.Business
{
    public class TimeLimitTaskBusiness : BaseBusiness, IDenpendency
    {
        private VenderBusiness venderBusiness;
        public TimeLimitTaskBusiness(IFreeSql fsql, NLogManager nLogManager, IIdGenerator idGenerator, VenderBusiness venderBusiness) : base(fsql, nLogManager, idGenerator)
        {
            this.venderBusiness = venderBusiness;
        }
        public void CheckTask()
        {
            fsql.Update<TimeLimitTask>().Set(t => t.IsTimely, false)
                                        .Where(t => t.CompletionTime == null)
                                        .Where(t => t.ExpirationTime < DateTime.Now)
                                        .ExecuteAffrows();
        }


        public TimeLimitTaskListResponse QueryTimeLimitTask(QueryTimeLimitTaskRequest request)
        {
            if (request.StartDate > request.EndDate)
                throw new BusinessException("开始时间不能大于结束时间");
            if (request.PageSize > 100)
                request.PageSize = 100;

            var shopList = venderBusiness.GetShopList(request.ShopId, Model.Enums.Platform.拳探);

            request.EndDate = request.EndDate.Date.AddDays(1).AddSeconds(-1);
            var list = fsql.Select<TimeLimitTask>().WhereIf(request.ShopId != null, t => t.ShopId == request.ShopId)
                                                   .Where(t => t.CreateTme >= request.StartDate && t.CreateTme <= request.EndDate)
                                                   .WhereIf(request.IsCompleted != null && request.IsCompleted == 1, t => t.CompletionTime != null)
                                                   .WhereIf(request.IsCompleted != null && request.IsCompleted == 0, t => t.CompletionTime == null)
                                                   .WhereIf(request.IsTimeOut != null && request.IsTimeOut == 1, t => t.IsTimely == false)
                                                   .WhereIf(request.IsTimeOut != null && request.IsTimeOut == 0, t => t.IsTimely == true || t.IsTimely == null)
                                                   .WhereIf(request.TimeLimitTaskType != null, t => t.TaskType == request.TimeLimitTaskType)
                                                   .OrderByDescending(t => t.CreateTme)
                                                   .Count(out var count)
                                                   .Page(request.PageIndex, request.PageSize)
                                                   .ToList<TimeLimitTaskResponse>();
            foreach (var task in list)
            {
                var shopId = task.ShopId.ToString();
                task.ShopName = shopList.FirstOrDefault(s => s.ShopId == shopId)?.ShopName;
            }
            return new TimeLimitTaskListResponse()
            {
                Count = count,
                ItemList = list
            };
        }

        public IList<TimeLimitTaskStatisticsResponse> TimeOutStatistics(QueryTimeOutRequest request)
        {
            if (request.StartDate > request.EndDate)
                throw new BusinessException("开始时间不能大于结束时间");
            request.EndDate = request.EndDate.Date.AddDays(1).AddSeconds(-1);

            var shopList = venderBusiness.GetShopList(request.ShopId, Model.Enums.Platform.拳探);
            var list = new List<TimeLimitTaskStatisticsResponse>();

            var shopIdList = new List<long>();

            #region 采购超时率
            var purchaseTaskCountGroups = fsql.Select<TimeLimitTask>().WhereIf(request.ShopId != null, t => t.ShopId == request.ShopId)
                                                                      .Where(t => t.CreateTme >= request.StartDate && t.CreateTme <= request.EndDate)
                                                                      .GroupBy(t => t.ShopId)
                                                                      .ToList(g => new
                                                                      {
                                                                          ShopId = g.Key,
                                                                          TaskCount = g.Count()
                                                                      });

            var purchaseTaskTimOutCountGroups = fsql.Select<TimeLimitTask>().WhereIf(request.ShopId != null, t => t.ShopId == request.ShopId)
                                                                            .Where(t => t.CreateTme >= request.StartDate && t.CreateTme <= request.EndDate)
                                                                            .Where(t => t.IsTimely == false)
                                                                            .GroupBy(t => t.ShopId)
                                                                            .ToList(g => new
                                                                            {
                                                                                ShopId = g.Key,
                                                                                TaskCount = g.Count()
                                                                            });
            #endregion

            shopIdList.AddRange(purchaseTaskCountGroups.Select(g => g.ShopId.Value).ToList());

            foreach (var shopId in shopIdList)
            {
                var sid = shopId.ToString();
                var response = new TimeLimitTaskStatisticsResponse();
                response.ShopId = shopId;
                response.ShopName = shopList.FirstOrDefault(s => s.ShopId == sid)?.ShopName;
                var purchaseTaskCount = purchaseTaskCountGroups.FirstOrDefault(x => x.ShopId == response.ShopId)?.TaskCount ?? 0;
                var purchaseTaskTimeOutCount = purchaseTaskTimOutCountGroups.FirstOrDefault(x => x.ShopId == response.ShopId)?.TaskCount ?? 0;

                response.PurchaseTimeOutPercent = purchaseTaskCount == 0 ? 0 : Math.Round(1.0 * purchaseTaskTimeOutCount / purchaseTaskCount * 100, 2);

                list.Add(response);
            }

            return list;
        }

        public void EditTimeLimitTaskRemark(EditTimeLimitTaskRemarkRequest request)
        {
            fsql.Update<TimeLimitTask>(request.TaskId).Set(t => t.Remark, request.Remark).ExecuteAffrows();
        }
    }
}