using System.ComponentModel.DataAnnotations;
using MAX.Framework.Commons;
using MAX.Framework.Validation;
using Store.Shops.Dtos;
using Store.Shops.Entities;
using Store.Shops.Mappers;

namespace Store.Shops.Services;

public sealed partial class ShopService
{
    /// <summary>保存授权店铺的物流优化结果；订单已关联其他店铺时拒绝覆盖。</summary>
    public async Task SaveOptimizeResult(OptimizeResultRequest request, CancellationToken ct)
    {
        RequestValidator.Validate(request);
        var actor = await Actor();
        using var work = db.CreateUnitOfWork();
        work.IsolationLevel = System.Data.IsolationLevel.Serializable;
        work.GetOrBeginTransaction();
        var orm = work.Orm;
        await RequireShop(orm, actor, request.ShopId, ct);
        var row = await orm.Select<OptimizeResultEntity>().Where(r => r.OrderId == request.OrderId).ForUpdate().FirstAsync(ct);
        if (row != null && row.ShopId != request.ShopId)
            throw new AppException("订单属于其他店铺，不能覆盖记录");
        if (row == null)
            await orm.Insert(new OptimizeResultEntity
            {
                ShopId = request.ShopId, OrderId = request.OrderId, OptimizeRst = request.OptimizeRst!,
                WaybillId = request.WaybillId ?? "", DeliveryName = request.DeliveryName ?? "",
                AddTime = DateTime.Now, MdyTime = DateTime.Now
            }).ExecuteAffrowsAsync(ct);
        else
        {
            var update = orm.Update<OptimizeResultEntity>().Where(r => r.Id == row.Id)
                .Set(r => r.OptimizeRst, request.OptimizeRst!).Set(r => r.MdyTime, DateTime.Now);
            if (request.WaybillId != null) update.Set(r => r.WaybillId, request.WaybillId);
            if (request.DeliveryName != null) update.Set(r => r.DeliveryName, request.DeliveryName);
            await update.ExecuteAffrowsAsync(ct);
        }
        ct.ThrowIfCancellationRequested();
        work.Commit();
    }

    /// <summary>分页查询可见店铺的物流优化结果，统计与数据使用相同范围。</summary>
    public async Task<ShopPage<OptimizeResultInfo>> OptimizeResults(OrderSearchRequest request, CancellationToken ct)
    {
        RequestValidator.Validate(request);
        Page(request.Page, request.PageSize);
        var actor = await Actor();
        var ids = await VisibleIds(actor, ct);
        var query = db.Select<OptimizeResultEntity>().Where(r => ids.Contains(r.ShopId))
            .WhereIf(request.OrderIds != null, r => request.OrderIds!.Contains(r.OrderId));
        var count = request.NotCount ? -1 : await query.CountAsync(ct);
        var rows = await query.OrderByDescending(r => r.Id).Page(request.Page, request.PageSize).ToListAsync(ct);
        return new(rows.Select(new ShopDetailsMapper().Map).ToList(), count);
    }

    /// <summary>保存授权店铺的物流优化备注；订单已关联其他店铺时拒绝覆盖。</summary>
    public async Task SaveOptimizeRemark(OptimizeRemarkRequest request, CancellationToken ct)
    {
        RequestValidator.Validate(request);
        var actor = await Actor();
        using var work = db.CreateUnitOfWork();
        work.IsolationLevel = System.Data.IsolationLevel.Serializable;
        work.GetOrBeginTransaction();
        var orm = work.Orm;
        await RequireShop(orm, actor, request.ShopId, ct);
        var row = await orm.Select<OptimizeRemarkEntity>().Where(r => r.OrderId == request.OrderId).ForUpdate().FirstAsync(ct);
        if (row != null && row.ShopId != request.ShopId)
            throw new AppException("订单属于其他店铺，不能覆盖记录");
        if (row == null)
            await orm.Insert(new OptimizeRemarkEntity
            {
                ShopId = request.ShopId, OrderId = request.OrderId, Remark = request.Remark!,
                AddTime = DateTime.Now, MdyTime = DateTime.Now
            }).ExecuteAffrowsAsync(ct);
        else
        {
            var update = orm.Update<OptimizeRemarkEntity>().Where(r => r.Id == row.Id)
                .Set(r => r.Remark, request.Remark!).Set(r => r.MdyTime, DateTime.Now);
            await update.ExecuteAffrowsAsync(ct);
        }
        ct.ThrowIfCancellationRequested();
        work.Commit();
    }

    /// <summary>分页查询可见店铺的物流优化备注，统计与数据使用相同范围。</summary>
    public async Task<ShopPage<OptimizeRemarkInfo>> OptimizeRemarks(OrderSearchRequest request, CancellationToken ct)
    {
        RequestValidator.Validate(request);
        Page(request.Page, request.PageSize);
        var actor = await Actor();
        var ids = await VisibleIds(actor, ct);
        var query = db.Select<OptimizeRemarkEntity>().Where(r => ids.Contains(r.ShopId))
            .WhereIf(request.OrderIds != null, r => request.OrderIds!.Contains(r.OrderId));
        var count = request.NotCount ? -1 : await query.CountAsync(ct);
        var rows = await query.OrderByDescending(r => r.Id).Page(request.Page, request.PageSize).ToListAsync(ct);
        return new(rows.Select(new ShopDetailsMapper().Map).ToList(), count);
    }

}