using Dlhis.Basic.Api;
using Dlhis.Canteen.Dishes.Request;
using Dlhis.Canteen.Setting.Services;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Canteen.Entities;
using Dlhis.Entity.Canteen.Enums;
using Dlhis.Entity.Device.Entities;
using Kurisu.AspNetCore.UnifyResultAndValidation;
using Kurisu.AspNetCore.Utils;
using Kurisu.AspNetCore.Utils.Extensions;
using Kurisu.Core.CustomClass;
using Kurisu.Core.DataAccess.Dto;
using Kurisu.Core.User.Abstractions;
using Kurisu.SqlSugar.Extensions;
using Kurisu.SqlSugar.Services;
using Mapster;
using SqlSugar;
using Dlhis.Canteen.Order.Response;
using Dlhis.Canteen.Dishes;
using Dlhis.Canteen.Order.Request;

namespace Dlhis.Canteen.Order.Services.Implements;

public class OrderService : BaseOrderService, IOrderService
{
    public OrderService(ICanteenSettingService canteenSettingService, IDbContext dbContext,
        ICurrentUser currentUser, IDevicePermissionApi devicePermissionApi,
        ILogger<OrderService> logger)
        : base(canteenSettingService, dbContext, currentUser, devicePermissionApi, logger)
    {
    }

    public async Task<OrderResultResponse> DeviceConsume(OrderAddRequest request)
    {
        return await AddAsync(request);
    }

    public async Task<OrderResultResponse> AddAsync(OrderAddRequest request)
    {
        //尝试匹配userId
        _ = long.TryParse(request.UserUniqueNo, out var userId);

        //根据档案号
        var gainfo = await DbContext.Queryable<GainfoEntity>()
            .Where(x => x.No == request.UserUniqueNo || x.Code == request.UserUniqueNo || x.Id == userId || x.CardNo == request.UserUniqueNo)
            .FirstAsync();

        gainfo.ThrowIfNull($"无消费权限");
        //消费权限控制
        await CheckPermissionAsync(gainfo.No, request.DeviceUniqueNo);

        var canteenUserExists = await DbContext.Queryable<GainfoMealEntity>()
           .Where(x => x.UserNo == gainfo.No)
           .AnyAsync();

        if (!canteenUserExists)
        {
            await DbContext.InsertAsync(new GainfoMealEntity
            {
                UserNo = gainfo.No,
                Balance = 0,
                BalanceOfRecharge = 0,
                BalanceOfSubsidies = 0,
                TenantId = gainfo.Factory,
                Version = 0,

                CreatedBy = 1,
                CreateTime = DateTime.Now,
                ModifiedBy = 1,
                ModifiedTime = DateTime.Now,
            });
        }

        //消费
        if (request.Type == BalanceRecordTypeEnumType.Out)
        {
            await ConsumeAsync(request.Adapt<ConsumeRequest>(), gainfo);
        }
        //充值
        else
        {
            await RechargeAsync(request.Adapt<RechargeRequest>(), gainfo);
        }

        //获取人员余额
        return await DbContext.Queryable<GainfoEntity>()
                  .LeftJoin<DepartmentEntity>((ga, department) => ga.DepartmentNo == department.No)
                  .LeftJoin<GainfoMealEntity>((ga, department, mealUser) => ga.No == mealUser.UserNo)
                  .Where(ga => ga.Id == gainfo.Id)
                  .Select((ga, department, mealUser) => new OrderResultResponse
                  {
                      UserCode = ga.Code,
                      UserName = ga.Name,
                      DepartmentNo = ga.DepartmentNo,
                      DepartmentName = department.Name,
                      CurrentBalance = mealUser.Balance
                  })
                  .SingleAsync();
    }

    /// <summary>
    /// 消费 
    /// </summary>
    /// <param name="request"></param>
    /// <param name="gainfo"></param>
    /// <returns></returns>
    private async Task ConsumeAsync(ConsumeRequest request, GainfoEntity gainfo)
    {
        var device = await DbContext.Queryable<DeviceEntity>().Where(x => x.UniqueNo == request.DeviceUniqueNo).Where(x => x.Enable).FirstAsync();
        device.ThrowIfNull("设备不存在或者尚未启用");
        var registry = await DbContext.Queryable<DeviceRegistryEntity>().Where(x => x.DeviceUniqueNo == request.DeviceUniqueNo).FirstAsync();
        registry.ThrowIfNull("设备尚未注册");
        var businessPlaceInfo = await DbContext.Queryable<BusinessPlaceEntity>()
            .LeftJoin<BusinessPlaceShiftRelationshipEntity>((x, sr) => x.Code == sr.PlaceCode)
            .Where(x => x.Code == registry.BusinessPlaceCode)
            .Select((x, sr) => new
            {
                x.Code,
                sr.ShiftCode,
                x.TenantId
            })
            .FirstAsync();
        businessPlaceInfo.ThrowIfNull("营业点尚未设置");

        //获取当前消费餐次
        var shifts = await DbContext.Queryable<BusinessShiftMealRelationshipEntity>().Where(x => x.ShiftCode == businessPlaceInfo.ShiftCode).ToListAsync();

        var shift = shifts.FirstOrDefault(x => new TimePeriod()
        {
            Start = x.Start,
            End = x.End

        }.IsPresent1(request.CostDateTime));

        var switchTime = await GetSettingAsync<TimeOnly?>(CanteenSettingItemEnumType.BusinessSwitchTime);

        var shiftTimePeriod = new TimePeriod()
        {
            Start = shift?.Start,
            End = shift?.End
        };

        //计算成本日期 todo 优化
        var costDate = DateTime.Now;
        if (shift == null)
        {
            costDate = DateTime.Now;
        }
        else
        {
            if (switchTime.HasValue)
            {
                var beginOfDay = DateTime.Today;

                var setTime = beginOfDay.Add(switchTime.Value.ToTimeSpan());
                if (DateTime.Now < setTime)
                    costDate = DateTime.Now.AddDays(-1);
            }
        }

        var order = new CanteenOrderEntity
        {
            RequestJson = request.ToJson(),
            ThirdNo = request.ThirdNo,
            Type = BalanceRecordTypeEnumType.Out,
            ApplicationType = CanteenApplicaitonTypeEnumType.Device,
            Name = gainfo.Name,
            Source = request.Source,
            UserNo = gainfo.No,
            UserCode = gainfo.Code,
            Amount = request.Amount,
            BusinessPlaceCode = businessPlaceInfo.Code,
            BusinessShiftCode = shift?.ShiftCode,
            ShiftType = shift?.ShiftType,
            CostDate = costDate.Date,
            CostId = gainfo.CostId,
            DepartmentNo = gainfo.DepartmentNo,
            DeviceUniqueNo = request.DeviceUniqueNo,

            No = SnowFlakeHelper.Instance.NextId().ToString(),
            SubsidiesFromMonth = request.CostDateTime.ToString("yyyyMM"),
            IsOffline = request.IsOffline,
            IsCostCrossTenant = await GetSettingAsync<bool>(CanteenSettingItemEnumType.AllowCrossTenant),

            OriginTenantId = gainfo.Factory,//人员可能跨基地消费

            //餐别异常处理
            Status = shift == null ? BalanceRecordStatusEnumType.Doubtful : BalanceRecordStatusEnumType.Valid,

            OrderStatus = CanteenOrderStatusEnumType.Wait,

            CostDateTime = request.CostDateTime,

            //标识当前消费的基地
            TenantId = businessPlaceInfo.TenantId,
        };

        var orderId = await DbContext.InsertReturnIdentityAsync(order);
        try
        {
            await GenerateConsumeRecordAsync(orderId, shifts, request.CostDateTime);
        }
        catch (Exception ex)
        {
            await DbContext.Updateable<CanteenOrderEntity>()
                .SetColumns(x => x.OrderStatus == CanteenOrderStatusEnumType.Failure)
                .SetColumns(x => x.Result == ex.Message)
                .SetColumns(x => x.ModifiedTime == DateTime.Now)
                .Where(x => x.Id == orderId)
                .ExecuteCommandAsync();

            throw;
        }

        await DbContext.Updateable<CanteenOrderEntity>()
              .SetColumns(x => x.OrderStatus == CanteenOrderStatusEnumType.Success)
              .SetColumns(x => x.ModifiedTime == DateTime.Now)
              .Where(x => x.Id == orderId)
              .ExecuteCommandAsync();
    }

    /// <summary>
    /// 充值
    /// </summary>
    /// <param name="request"></param>
    /// <param name="gainfo"></param>
    /// <returns></returns>
    private async Task RechargeAsync(RechargeRequest request, GainfoEntity gainfo)
    {
        var order = new CanteenOrderEntity
        {
            RequestJson = request.ToJson(),
            IsOffline = false,
            ThirdNo = request.ThirdNo,
            Type = BalanceRecordTypeEnumType.In,
            Name = gainfo.Name,
            Source = request.Source,
            UserNo = gainfo.No,
            UserCode = gainfo.Code,
            Amount = request.Amount,
            BusinessPlaceCode = null,
            BusinessShiftCode = null,
            CostDate = DateTime.Now.Date,
            CostId = gainfo.CostId,
            DepartmentNo = gainfo.DepartmentNo,
            DeviceUniqueNo = string.Empty,

            No = SnowFlakeHelper.Instance.NextId().ToString(),
            SubsidiesFromMonth = request.CostDateTime.ToString("yyyyMM"),
            IsCostCrossTenant = await GetSettingAsync<bool>(CanteenSettingItemEnumType.AllowCrossTenant),

            OriginTenantId = gainfo.Factory,//人员可能跨基地消费

            Status = BalanceRecordStatusEnumType.Valid,

            OrderStatus = CanteenOrderStatusEnumType.Wait,

            CostDateTime = request.CostDateTime,

            //标识当前消费的基地
            TenantId = gainfo.Factory,
        };

        var orderId = await DbContext.InsertReturnIdentityAsync(order);
        try
        {
            await GenerateRechargeRecordAsync(orderId);
        }
        catch (Exception ex)
        {
            await DbContext.Updateable<CanteenOrderEntity>()
                .SetColumns(x => x.OrderStatus == CanteenOrderStatusEnumType.Failure)
                .SetColumns(x => x.Result == ex.Message)
                .Where(x => x.Id == orderId)
                .ExecuteCommandAsync();

            throw;
        }

        await DbContext.Updateable<CanteenOrderEntity>()
              .SetColumns(x => x.OrderStatus == CanteenOrderStatusEnumType.Success)
              .Where(x => x.Id == orderId)
              .ExecuteCommandAsync();
    }


    public async Task<Pagination<OrderAggregationResponse>> GetOrdersAggregationAsync(PageDto page)
    {
        var subjectId = CurrentUser.GetIntSubjectId();
        var gainfo = await DbContext.Queryable<GainfoEntity>().Where(x => x.IdentityUserId == subjectId).FirstAsync();
        var jinkoCode = CurrentUser.GetUserClaim("jinko-code") ?? string.Empty;
        if (jinkoCode.IsPresent())
        {
            gainfo = await DbContext.Queryable<GainfoEntity>().Where(x => x.Code == jinkoCode).FirstAsync();
        }

        var pageResult = await DbContext.Queryable<CanteenOrderEntity>().Where(x => x.UserNo == gainfo.No)
                .LeftJoin<BusinessPlaceEntity>((x, bplace) => x.BusinessPlaceCode == bplace.Code)
                .Where(x => x.ApplicationType == CanteenApplicaitonTypeEnumType.Booking)
                .Select((x, bplace) => new OrderAggregationResponse
                {
                    No = x.No,
                    BusinessPlaceName = bplace.Name,
                    CreateTime = x.CreateTime
                })
                .ToPageListAsync(page);

        //.LeftJoin<CanteenOrderDetailEntity>((x, bplace, detail) => x.No == detail.OrderNo)

        var nos = pageResult.Data.Select(x => x.No).ToList();
        var dtos = await DbContext.Queryable<CanteenOrderDetailEntity>()
                .LeftJoin<DishesEntity>((x, d) => x.DishesCode == d.CustomCode)
                .Where(x => nos.Contains(x.OrderNo))
                .Select((x, d) => new DishesDto
                {
                    No = x.OrderNo,
                    DishesCode = x.DishesCode,
                    Name = d.Name,
                    ImageUrl = d.ImageUrl,
                    Number = x.Number,
                    Price = x.Price,
                })
                .ToListAsync();


        pageResult.Data.ForEach(item =>
        {
            item.Dishes = dtos.Where(x => x.No == item.No).ToList();
        });

        return pageResult;
    }


    //******************************************************* help methods ************************************************************/




    /// <summary>
    /// 验证参数
    /// </summary>
    /// <param name="shifts"></param>
    /// <param name="costDateTime"></param>
    /// <param name="order"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    private async Task Verify(List<BusinessShiftMealRelationshipEntity> shifts, DateTime costDateTime, CanteenOrderEntity order)
    {
        //在线
        if (!order.IsOffline)
        {
            shifts.FirstOrDefault(x => new TimePeriod()
            {
                Start = x.Start,
                End = x.End,

            }.IsPresent1(costDateTime)).ThrowIfNull("当前非就餐时间,无法消费");
        }

        var beginOfDay = DateTime.Today;
        var endOfDay = beginOfDay.AddHours(23).AddMinutes(59).AddSeconds(59);

        var balanceRecords = await DbContext.Queryable<BalanceRecordEntity>()
            .Where(x => x.UserNo == order.UserNo)
            .Where(x => x.CreateTime >= beginOfDay && x.CreateTime <= endOfDay) //今天消费记录
            .ToListAsync();

        var dayMarketCostMax = await GetSettingAsync<decimal>(CanteenSettingItemEnumType.DayMarketCostMax);
        if (dayMarketCostMax != default)
        {
            var businessPlaceCodes = await DbContext.Queryable<BusinessPlaceEntity>()
                .Where(x => x.Catalog == CanteenBusinessPlaceCatalogEnumType.Supermarket)
                .Select(x => x.Code).ToListAsync();

            var cost = balanceRecords.Where(x => businessPlaceCodes.Contains(x.BusinessPlaceCode.Value)).Sum(x => x.Amount);
            if (cost + Math.Abs(order.Amount) > dayMarketCostMax)
            {
                throw new UserFriendlyException($"超出当天超市消费限制({dayMarketCostMax}),无法消费");
            }
        }

        var allowRepeatInOneShift = await GetSettingAsync(CanteenSettingItemEnumType.AllowRepeatInOneShift, true);
        if (!allowRepeatInOneShift)
        {
            //todo 餐次问题
            var costCount = balanceRecords.Where(x => x.BusinessShiftCode == order.BusinessShiftCode).Count();
            if (costCount > 1)
            {
                throw new UserFriendlyException($"当前餐次不允许多次消费");
            }
        }

        var onceCostMax = await GetSettingAsync<decimal>(CanteenSettingItemEnumType.OnceCostMax);
        if (onceCostMax != default)
        {
            if (Math.Abs(order.Amount) > onceCostMax)
            {
                throw new UserFriendlyException($"一次消费金额不能超出{onceCostMax}");
            }
        }

        var dayCostMax = await GetSettingAsync<decimal>(CanteenSettingItemEnumType.DayCostMax);
        if (dayCostMax != default)
        {
            var cost = balanceRecords.Where(x => x.Type == BalanceRecordTypeEnumType.Out).Sum(x => Math.Abs(x.Amount));
            if (cost + Math.Abs(order.Amount) > dayCostMax)
            {
                throw new UserFriendlyException($"超出当天消费限制({dayCostMax}),无法消费");
            }
        }
    }


    /// <summary>
    /// 生成消费记录
    /// </summary>
    /// <param name="orderId"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    /// <exception cref="VersionExceptions"></exception>
    private async Task GenerateRechargeRecordAsync(long orderId)
    {
        var order = await DbContext.Queryable<CanteenOrderEntity>().Where(x => x.Id == orderId).FirstAsync();

        await ContinueUpdateAsync(async () =>
        {
            var canteenUser = await DbContext.Queryable<GainfoMealEntity>().Where(x => x.UserNo == order.UserNo).FirstAsync();
            //金额+-
            canteenUser.Balance += order.Amount;

            var effect = await DbContext.Updateable<GainfoMealEntity>()
                        .SetColumns(x => x.Balance == canteenUser.Balance)
                        .SetColumns(x => x.Version == x.Version + 1)
                        .Where(x => x.UserNo == order.UserNo && x.Version == canteenUser.Version)
                        .ExecuteCommandAsync();

            if (effect <= 0) throw new VersionExceptions("更新版本冲突");

            //写入记录
            var balanceRecord = order.Adapt<BalanceRecordEntity>();
            await DbContext.InsertAsync(balanceRecord);

        }, 5);
    }

    /// <summary>
    /// 生成充值记录
    /// </summary>
    /// <param name="orderId"></param>
    /// <param name="shifts"></param>
    /// <param name="costDateTime"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    /// <exception cref="VersionExceptions"></exception>
    private async Task GenerateConsumeRecordAsync(long orderId, List<BusinessShiftMealRelationshipEntity> shifts, DateTime costDateTime)
    {
        var order = await DbContext.Queryable<CanteenOrderEntity>().Where(x => x.Id == orderId).FirstAsync();
        //校验
        await Verify(shifts, costDateTime, order);

        var allowNoBalance = await GetSettingAsync<bool>(CanteenSettingItemEnumType.AllowNoBalance);

        await ContinueUpdateAsync(async () =>
        {
            if (!allowNoBalance)
            {
                var canteenUser = await DbContext.Queryable<GainfoMealEntity>().Where(x => x.UserNo == order.UserNo).FirstAsync();
                //金额+-
                canteenUser.Balance += order.Amount;
                if (canteenUser.Balance < 0)
                {
                    throw new UserFriendlyException("余额不足,无法消费");
                }

                var effect = await DbContext.Updateable<GainfoMealEntity>()
                            .SetColumns(x => x.Balance == canteenUser.Balance)
                            .SetColumns(x => x.Version == x.Version + 1)
                            .Where(x => x.UserNo == order.UserNo && x.Version == canteenUser.Version)//必须与查询时的version一致
                            .ExecuteCommandAsync();

                if (effect <= 0) throw new VersionExceptions("更新版本冲突");
            }

            //写入记录
            var balanceRecord = order.Adapt<BalanceRecordEntity>();
            await DbContext.InsertAsync(balanceRecord);

        }, 5);
    }


}