王明 / Food-Labeling-Management-Platform

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using FoodLabeling.Application.Contracts.Dtos.Common;
using FoodLabeling.Application.Contracts.Dtos.Label;
using FoodLabeling.Application.Contracts.Dtos.LabelTemplate;
using FoodLabeling.Application.Contracts.Dtos.Reports;
using FoodLabeling.Application.Contracts.Dtos.UsAppLabeling;
using FoodLabeling.Application.Contracts.IServices;
using FoodLabeling.Application.Helpers;
using FoodLabeling.Application.Services.DbModels;
using FoodLabeling.Domain.Entities;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using Volo.Abp;
using Volo.Abp.Application.Services;
using Volo.Abp.Guids;
using Volo.Abp.Uow;
using Yi.Framework.Rbac.Domain.Entities;
using Yi.Framework.SqlSugarCore.Abstractions;

namespace FoodLabeling.Application.Services;

/// <summary>
/// App Labeling：四级列表（标签分类 → 产品分类 → 产品 → 标签种类）
/// </summary>
public class UsAppLabelingAppService : ApplicationService, IUsAppLabelingAppService
{
    private readonly ISqlSugarDbContext _dbContext;
    private readonly ILabelAppService _labelAppService;
    private readonly IGuidGenerator _guidGenerator;
    private readonly ISqlSugarRepository<UserAggregateRoot, Guid> _userRepository;

    public UsAppLabelingAppService(
        ISqlSugarDbContext dbContext,
        ILabelAppService labelAppService,
        IGuidGenerator guidGenerator,
        ISqlSugarRepository<UserAggregateRoot, Guid> userRepository)
    {
        _dbContext = dbContext;
        _labelAppService = labelAppService;
        _guidGenerator = guidGenerator;
        _userRepository = userRepository;
    }

    /// <summary>
    /// 获取当前门店下四级嵌套数据
    /// </summary>
    /// <remarks>
    /// L1 标签分类 fl_label_category（含 buttonAppearance；COLOR/IMAGE 展示值在 categoryPhotoUrl）；仅对当前门店可用：ALL 或 SPECIFIED 且在 fl_label_category_location；
    /// L2 产品分类 fl_product.CategoryId join fl_product_category（同上，展示值在 categoryPhotoUrl）；
    /// L3 产品卡片：按「产品 + 标签模板」拆分；出参含 fl_product 的 codeValue、buttonAppearance、categoryPhotoUrl；L4 为标签种类（fl_label + fl_label_type）。
    /// L2 产品分类展示名来自 fl_product_category；产品范围已由 fl_location_product 限定当前门店，
    /// 不再因产品分类 SPECIFIED 未配 fl_product_category_location 而整行过滤（避免 App 全店空数据）。
    /// 未归类或分类行未关联到 fl_product_category 时仍归入「无」节点。
    /// </remarks>
    [Authorize]
    public virtual async Task<List<UsAppLabelCategoryTreeNodeDto>> GetLabelingTreeAsync([FromQuery] UsAppLabelingTreeInputVo input)
    {
        if (string.IsNullOrWhiteSpace(input.LocationId))
        {
            throw new UserFriendlyException("门店Id不能为空");
        }

        var locationId = input.LocationId.Trim();
        var keyword = input.Keyword?.Trim();
        var filterCategoryId = input.LabelCategoryId?.Trim();

        await UsAppPrintLogScopeHelper.EnsureUserCanAccessLocationAsync(
            CurrentUser, _dbContext.SqlSugarClient, locationId);

        var productIds = await _dbContext.SqlSugarClient.Queryable<FlLocationProductDbEntity>()
            .Where(x => x.LocationId == locationId)
            .Select(x => x.ProductId)
            .ToListAsync();

        if (productIds.Count == 0)
        {
            return new List<UsAppLabelCategoryTreeNodeDto>();
        }

        var query = await BuildLabelingJoinQueryAsync(locationId, productIds, filterCategoryId, keyword);

        var rawRows = await query
            .Select((lp, l, p, c, t, tpl, pc) => new
            {
                LabelCategoryId = c.Id,
                LabelCategoryName = c.CategoryName,
                LabelCategoryPhotoUrl = c.CategoryPhotoUrl,
                LabelCategoryDisplayText = c.DisplayText,
                LabelCategoryButtonAppearance = c.ButtonAppearance,
                LabelCategoryOrderNum = c.OrderNum,
                ProductCategoryId = p.CategoryId,
                ProductCategoryName = pc.CategoryName,
                ProductCategoryPhotoUrl = pc.CategoryPhotoUrl,
                ProductCategoryDisplayText = pc.DisplayText,
                ProductCategoryButtonAppearance = pc.ButtonAppearance,
                ProductCategoryAvailabilityType = pc.AvailabilityType,
                ProductCategoryOrderNum = pc.OrderNum,
                ProductId = p.Id,
                ProductName = p.ProductName,
                ProductCode = p.ProductCode,
                ProductImageUrl = p.ProductImageUrl,
                ProductDisplayText = p.DisplayText,
                ProductCodeValue = p.CodeValue,
                ProductButtonAppearance = p.ButtonAppearance,
                ProductAppearancePhotoUrl = p.CategoryPhotoUrl,
                LabelTypeId = t.Id,
                TypeName = t.TypeName,
                TypeOrderNum = t.OrderNum,
                LabelCode = l.LabelCode ?? string.Empty,
                TemplateId = tpl.Id,
                TemplateCode = tpl.TemplateCode,
                TemplateWidth = tpl.Width,
                TemplateHeight = tpl.Height,
                TemplateUnit = tpl.Unit
            })
            .ToListAsync();

        var raw = rawRows.Select(r => new LabelingTreeRow
        {
            LabelCategoryId = r.LabelCategoryId,
            LabelCategoryName = r.LabelCategoryName,
            LabelCategoryPhotoUrl = r.LabelCategoryPhotoUrl,
            LabelCategoryButtonAppearance = r.LabelCategoryButtonAppearance,
            LabelCategoryOrderNum = r.LabelCategoryOrderNum,
            ProductCategoryId = r.ProductCategoryId,
            ProductCategoryName = r.ProductCategoryName,
            ProductCategoryPhotoUrl = r.ProductCategoryPhotoUrl,
            ProductCategoryDisplayText = r.ProductCategoryDisplayText,
            ProductCategoryButtonAppearance = r.ProductCategoryButtonAppearance,
            ProductCategoryAvailabilityType = r.ProductCategoryAvailabilityType,
            ProductCategoryOrderNum = r.ProductCategoryOrderNum,
            ProductId = r.ProductId,
            ProductName = r.ProductName,
            ProductCode = r.ProductCode,
            ProductImageUrl = r.ProductImageUrl,
            ProductDisplayText = r.ProductDisplayText,
            ProductCodeValue = r.ProductCodeValue,
            ProductButtonAppearance = r.ProductButtonAppearance,
            ProductAppearancePhotoUrl = r.ProductAppearancePhotoUrl,
            LabelTypeId = r.LabelTypeId,
            TypeName = r.TypeName,
            TypeOrderNum = r.TypeOrderNum,
            LabelCode = r.LabelCode,
            TemplateId = r.TemplateId,
            TemplateCode = r.TemplateCode,
            TemplateWidth = r.TemplateWidth,
            TemplateHeight = r.TemplateHeight,
            TemplateUnit = r.TemplateUnit
        }).ToList();

        if (raw.Count == 0)
        {
            return new List<UsAppLabelCategoryTreeNodeDto>();
        }

        var byL1 = raw.GroupBy(x => new
        {
            x.LabelCategoryId,
            x.LabelCategoryName,
            x.LabelCategoryPhotoUrl,
            x.LabelCategoryDisplayText,
            x.LabelCategoryButtonAppearance,
            x.LabelCategoryOrderNum
        }).OrderBy(g => g.Key.LabelCategoryOrderNum).ThenBy(g => g.Key.LabelCategoryName);

        var result = new List<UsAppLabelCategoryTreeNodeDto>();
        foreach (var g1 in byL1)
        {
            var l1Appearance = string.IsNullOrWhiteSpace(g1.Key.LabelCategoryButtonAppearance)
                ? "TEXT"
                : g1.Key.LabelCategoryButtonAppearance.Trim();
            var l1Flat = CategoryAppearanceApiHelper.BuildFlatAppearanceFields(
                l1Appearance,
                g1.Key.LabelCategoryPhotoUrl,
                g1.Key.LabelCategoryDisplayText);
            var l1 = new UsAppLabelCategoryTreeNodeDto
            {
                Id = g1.Key.LabelCategoryId,
                CategoryName = g1.Key.LabelCategoryName ?? string.Empty,
                CategoryPhotoUrl = g1.Key.LabelCategoryPhotoUrl,
                DisplayText = l1Flat.DisplayText ?? g1.Key.LabelCategoryDisplayText,
                ButtonAppearance = l1Appearance,
                ButtonStyleJson = l1Flat.ButtonStyleJson,
                ButtonBgColor = l1Flat.ButtonBgColor,
                ButtonImageUrl = l1Flat.ButtonImageUrl,
                ButtonTextColor = l1Flat.ButtonTextColor,
                OrderNum = g1.Key.LabelCategoryOrderNum,
                ProductCategories = new List<UsAppProductCategoryNodeDto>()
            };

            var byL2 = g1.GroupBy(x =>
                {
                    var categoryId = NormalizeNullableId(x.ProductCategoryId);
                    if (categoryId is null)
                    {
                        return new
                        {
                            CategoryId = (string?)null,
                            CategoryName = "无",
                            CategoryPhotoUrl = (string?)null,
                            DisplayText = (string?)null,
                            ButtonAppearance = (string?)null,
                            AvailabilityType = (string?)null,
                            CategoryOrderNum = int.MaxValue
                        };
                    }

                    var categoryName = NormalizeCategoryName(x.ProductCategoryName);
                    var categoryPhotoUrl = NormalizeNullableUrl(x.ProductCategoryPhotoUrl);
                    return new
                    {
                        CategoryId = (string?)categoryId,
                        CategoryName = categoryName,
                        CategoryPhotoUrl = categoryPhotoUrl,
                        DisplayText = NormalizeNullableUrl(x.ProductCategoryDisplayText),
                        ButtonAppearance = NormalizeNullableAppearance(x.ProductCategoryButtonAppearance),
                        AvailabilityType = NormalizeAvailabilityType(x.ProductCategoryAvailabilityType),
                        CategoryOrderNum = x.ProductCategoryOrderNum
                    };
                })
                .OrderBy(g => g.Key.CategoryOrderNum)
                .ThenBy(g => g.Key.CategoryName);

            foreach (var g2 in byL2)
            {
                var productsGrouped = g2
                    .GroupBy(x => new { x.ProductId, x.TemplateId })
                    .OrderBy(pg => pg.First().ProductName)
                    .ThenBy(pg => pg.Key.TemplateId);
                var appearance = string.IsNullOrWhiteSpace(g2.Key.ButtonAppearance)
                    ? "TEXT"
                    : g2.Key.ButtonAppearance.Trim();
                var availability = string.IsNullOrWhiteSpace(g2.Key.AvailabilityType)
                    ? "ALL"
                    : g2.Key.AvailabilityType.Trim().ToUpperInvariant();
                var l2Flat = CategoryAppearanceApiHelper.BuildFlatAppearanceFields(
                    appearance,
                    g2.Key.CategoryPhotoUrl,
                    g2.Key.DisplayText);
                var l2 = new UsAppProductCategoryNodeDto
                {
                    CategoryId = g2.Key.CategoryId,
                    CategoryPhotoUrl = g2.Key.CategoryPhotoUrl,
                    Name = g2.Key.CategoryName,
                    DisplayText = l2Flat.DisplayText ?? g2.Key.DisplayText,
                    ButtonAppearance = appearance,
                    ButtonStyleJson = l2Flat.ButtonStyleJson,
                    ButtonBgColor = l2Flat.ButtonBgColor,
                    ButtonImageUrl = l2Flat.ButtonImageUrl,
                    ButtonTextColor = l2Flat.ButtonTextColor,
                    AvailabilityType = availability,
                    OrderNum = g2.Key.CategoryOrderNum == int.MaxValue ? 0 : g2.Key.CategoryOrderNum,
                    ItemCount = productsGrouped.Count(),
                    Products = new List<UsAppLabelingProductNodeDto>()
                };

                foreach (var g3 in productsGrouped)
                {
                    var first = g3.First();
                    var typeNodes = g3
                        .GroupBy(r => r.LabelCode)
                        .Select(gr => BuildLabelTypeNode(gr.First()))
                        .OrderBy(t => t.OrderNum)
                        .ThenBy(t => t.TypeName)
                        .ToList();

                    var subtitle = string.IsNullOrWhiteSpace(first.ProductCode?.Trim())
                        ? "无"
                        : first.ProductCode!.Trim();
                    var templateLabelSizeText = FormatLabelSize(
                        first.TemplateWidth,
                        first.TemplateHeight,
                        first.TemplateUnit);

                    var productAppearance = string.IsNullOrWhiteSpace(first.ProductButtonAppearance)
                        ? CategoryAppearanceStorageHelper.DefaultButtonAppearanceJson
                        : first.ProductButtonAppearance.Trim();
                    l2.Products.Add(new UsAppLabelingProductNodeDto
                    {
                        ProductId = first.ProductId,
                        TemplateId = first.TemplateId,
                        TemplateCode = first.TemplateCode,
                        TemplateLabelSizeText = templateLabelSizeText,
                        ProductName = first.ProductName ?? string.Empty,
                        ProductCode = first.ProductCode ?? string.Empty,
                        ProductImageUrl = first.ProductImageUrl,
                        DisplayText = first.ProductDisplayText,
                        CodeValue = FormatProductCodeValueDisplay(first.ProductCodeValue),
                        ButtonAppearance = productAppearance,
                        CategoryPhotoUrl = first.ProductAppearancePhotoUrl,
                        Subtitle = subtitle,
                        LabelTypeCount = typeNodes.Count,
                        LabelTypes = typeNodes
                    });
                }

                l1.ProductCategories.Add(l2);
            }

            result.Add(l1);
        }

        return result;
    }

    /// <summary>
    /// App 打印预览：按标签编码解析模板并返回顶部展示字段 + 预览模板结构
    /// </summary>
    /// <remarks>
    /// 示例请求：
    /// ```json
    /// {
    ///   "locationId": "LOC001",
    ///   "labelCode": "LBL0001",
    ///   "productId": "PROD001",
    ///   "baseTime": "2026-03-26T10:30:00",
    ///   "printInputJson": {
    ///     "price": "12.99"
    ///   }
    /// }
    /// ```
    /// </remarks>
    /// <param name="input">预览入参</param>
    /// <returns>顶部字段 + 预览模板结构</returns>
    /// <response code="200">成功</response>
    /// <response code="400">参数错误/数据不存在</response>
    /// <response code="500">服务器错误</response>
    [Authorize]
    public virtual async Task<UsAppLabelPreviewDto> PreviewAsync(UsAppLabelPreviewInputVo input)
    {
        if (input is null)
        {
            throw new UserFriendlyException("入参不能为空");
        }

        var locationId = input.LocationId?.Trim();
        if (string.IsNullOrWhiteSpace(locationId))
        {
            throw new UserFriendlyException("门店Id不能为空");
        }

        var labelCode = input.LabelCode?.Trim();
        if (string.IsNullOrWhiteSpace(labelCode))
        {
            throw new UserFriendlyException("labelCode不能为空");
        }

        var labelRow = await _dbContext.SqlSugarClient
            .Queryable<FlLabelDbEntity, FlLabelCategoryDbEntity, FlLabelTypeDbEntity, FlLabelTemplateDbEntity>(
                (l, c, t, tpl) => l.LabelCategoryId == c.Id && l.LabelTypeId == t.Id && l.TemplateId == tpl.Id)
            .Where((l, c, t, tpl) => !l.IsDeleted && l.State)
            .Where((l, c, t, tpl) => !c.IsDeleted && c.State)
            .Where((l, c, t, tpl) => !t.IsDeleted && t.State)
            .Where((l, c, t, tpl) => !tpl.IsDeleted)
            .Where((l, c, t, tpl) => l.LabelCode == labelCode)
            .Select((l, c, t, tpl) => new
            {
                l.Id,
                l.LabelCode,
                l.LocationId,
                l.LabelTypeId,
                l.TemplateId,
                l.LastModificationTime,
                l.CreationTime,
                LabelCategoryName = c.CategoryName,
                TypeName = t.TypeName,
                TemplateCode = tpl.TemplateCode,
                TemplateWidth = tpl.Width,
                TemplateHeight = tpl.Height,
                TemplateUnit = tpl.Unit
            })
            .FirstAsync();

        if (labelRow is null)
        {
            throw new UserFriendlyException("标签不存在或不可用");
        }

        var labelForScope = new FlLabelDbEntity
        {
            Id = labelRow.Id,
            LocationId = labelRow.LocationId
        };
        var storeGroupIds = await LabelRegionScopeHelper.ResolveGroupIdsForLocationAsync(
            _dbContext.SqlSugarClient, locationId);
        if (!await LabelRegionScopeHelper.LabelAppliesToLocationAsync(
                _dbContext.SqlSugarClient, labelForScope, locationId, storeGroupIds))
        {
            throw new UserFriendlyException("该标签不属于当前门店");
        }

        var previewProductId = await ResolvePreviewProductIdAsync(labelRow.Id, input.ProductId);

        var template = await _labelAppService.PreviewAsync(new LabelPreviewResolveInputVo
        {
            LabelCode = labelCode,
            ProductId = previewProductId,
            BaseTime = input.BaseTime,
            LocationId = locationId,
            PrintInputJson = input.PrintInputJson?.ToDictionary(x => x.Key, x => (object?)x.Value)
        });

        string? printLabelDisplayId = null;
        var previewDay = input.BaseTime?.Date ?? DateTime.Now.Date;
        var nextDailyLabelId = await ReportsPrintLogDailyLabelIdHelper.ResolveNextDailyLabelIdAsync(
            _dbContext.SqlSugarClient,
            locationId,
            previewDay);
        if (LabelTemplateLabelIdHelper.TemplateContainsLabelId(template.Elements))
        {
            printLabelDisplayId = nextDailyLabelId;
            if (!string.IsNullOrWhiteSpace(printLabelDisplayId))
            {
                LabelTemplateLabelIdHelper.ApplyLabelIdToElements(template.Elements, printLabelDisplayId);
            }
        }

        Dictionary<string, object?>? templateProductDefaultValues = null;
        if (!string.IsNullOrWhiteSpace(previewProductId))
        {
            var productDefault = await _dbContext.SqlSugarClient.Queryable<FlLabelTemplateProductDefaultDbEntity>()
                .Where(x => x.TemplateId == labelRow.TemplateId)
                .Where(x => x.ProductId == previewProductId)
                .Where(x => x.LabelTypeId == labelRow.LabelTypeId)
                .OrderBy(x => x.OrderNum)
                .FirstAsync();

            if (!string.IsNullOrWhiteSpace(productDefault?.DefaultValuesJson))
            {
                try
                {
                    templateProductDefaultValues =
                        JsonSerializer.Deserialize<Dictionary<string, object?>>(productDefault.DefaultValuesJson!);
                }
                catch
                {
                    templateProductDefaultValues = null;
                }
            }
        }

        var productName = string.Empty;
        var productCategoryName = "无";
        if (!string.IsNullOrWhiteSpace(previewProductId))
        {
            var p = await _dbContext.SqlSugarClient.Queryable<FlProductDbEntity>()
                .FirstAsync(x => !x.IsDeleted && x.State && x.Id == previewProductId);
            if (p is not null)
            {
                productName = p.ProductName ?? string.Empty;
                if (!string.IsNullOrWhiteSpace(p.CategoryId))
                {
                    var pc = await _dbContext.SqlSugarClient.Queryable<FlProductCategoryDbEntity>()
                        .FirstAsync(x => !x.IsDeleted && x.State && x.Id == p.CategoryId);
                    productCategoryName = NormalizeCategoryName(pc?.CategoryName);
                }
            }
        }

        if (templateProductDefaultValues is { Count: > 0 })
        {
            ApplyTemplateProductDefaultValuesToPreviewElements(template.Elements, templateProductDefaultValues);
        }

        return new UsAppLabelPreviewDto
        {
            LabelId = nextDailyLabelId,
            PrintLabelDisplayId = printLabelDisplayId,
            LocationId = locationId,
            LabelCode = labelCode,
            TemplateCode = labelRow.TemplateCode,
            LabelSizeText = FormatLabelSize(labelRow.TemplateWidth, labelRow.TemplateHeight, labelRow.TemplateUnit),
            TypeName = labelRow.TypeName,
            ProductName = string.IsNullOrWhiteSpace(productName) ? null : productName,
            ProductCategoryName = productCategoryName,
            LabelCategoryName = labelRow.LabelCategoryName,
            LabelLastEdited = labelRow.LastModificationTime ?? labelRow.CreationTime,
            PreviewImageBase64Png = null,
            Template = template,
            TemplateProductDefaultValues = templateProductDefaultValues
        };
    }

    /// <summary>
    /// App 打印：创建打印任务并落库打印明细（fl_label_print_task / fl_label_print_data）
    /// </summary>
    /// <param name="input">打印入参</param>
    /// <returns>任务Id</returns>
    [Authorize]
    [UnitOfWork]
    public virtual async Task<UsAppLabelPrintOutputDto> PrintAsync(UsAppLabelPrintInputVo input)
    {
        if (input is null)
        {
            throw new UserFriendlyException("入参不能为空");
        }

        var locationId = input.LocationId?.Trim();
        if (string.IsNullOrWhiteSpace(locationId))
        {
            throw new UserFriendlyException("门店Id不能为空");
        }

        var labelCode = input.LabelCode?.Trim();
        if (string.IsNullOrWhiteSpace(labelCode))
        {
            throw new UserFriendlyException("labelCode不能为空");
        }

        var quantity = input.PrintQuantity <= 0 ? 1 : input.PrintQuantity;
        var clientRequestId = input.ClientRequestId?.Trim();
        if (!string.IsNullOrWhiteSpace(clientRequestId))
        {
            // 幂等：同一个 clientRequestId 重复调用，直接返回首次创建的任务集合
            var existed = await _dbContext.SqlSugarClient.Queryable<FlLabelPrintTaskDbEntity>()
                .Where(x => x.ClientRequestId == clientRequestId)
                .OrderBy(x => x.CopyIndex)
                .ToListAsync();

            if (existed is not null && existed.Count > 0)
            {
                var existedBatchId = existed.First().BatchId;
                var existedTaskIds = existed.Select(x => x.Id).ToList();
                return new UsAppLabelPrintOutputDto
                {
                    TaskId = existedTaskIds.FirstOrDefault() ?? string.Empty,
                    PrintQuantity = existedTaskIds.Count,
                    BatchId = existedBatchId,
                    TaskIds = existedTaskIds
                };
            }
        }

        // 校验 label + location，并补齐一些顶部字段用于任务表落库
        var labelRow = await _dbContext.SqlSugarClient
            .Queryable<FlLabelDbEntity, FlLabelTypeDbEntity, FlLabelTemplateDbEntity>(
                (l, t, tpl) => l.LabelTypeId == t.Id && l.TemplateId == tpl.Id)
            .Where((l, t, tpl) => !l.IsDeleted && l.State)
            .Where((l, t, tpl) => !t.IsDeleted && t.State)
            .Where((l, t, tpl) => !tpl.IsDeleted)
            .Where((l, t, tpl) => l.LabelCode == labelCode)
            .Select((l, t, tpl) => new
            {
                l.Id,
                l.LocationId,
                l.LabelTypeId,
                l.TemplateId
            })
            .FirstAsync();

        if (labelRow is null)
        {
            throw new UserFriendlyException("标签不存在或不可用");
        }

        await LabelRegionScopeHelper.EnsureLabelAppliesToLocationAsync(
            _dbContext.SqlSugarClient, labelRow.Id, locationId);

        var previewProductId = await ResolvePreviewProductIdAsync(labelRow.Id, input.ProductId);
        var normalizedPrintInput = ParsePrintInputJsonToDictionary(input.PrintInputJson);

        // 解析模板 elements（与预览一致的渲染数据）
        var resolvedTemplate = await _labelAppService.PreviewAsync(new LabelPreviewResolveInputVo
        {
            LabelCode = labelCode,
            ProductId = previewProductId,
            BaseTime = input.BaseTime,
            LocationId = locationId,
            PrintInputJson = normalizedPrintInput
        });

        var printDay = input.BaseTime?.Date ?? DateTime.Now.Date;
        List<string>? reservedDailyLabelIds = null;
        if (LabelTemplateLabelIdHelper.TemplateContainsLabelId(resolvedTemplate.Elements))
        {
            reservedDailyLabelIds = await ReportsPrintLogDailyLabelIdHelper.ResolveNextDailyLabelIdsAsync(
                _dbContext.SqlSugarClient,
                locationId,
                printDay,
                quantity);
        }

        var templateProductDefaultValuesJson = await ResolveTemplateProductDefaultValuesJsonAsync(
            labelRow.TemplateId,
            previewProductId,
            labelRow.LabelTypeId);

        var printInputJsonStr = input.PrintInputJson is null
            ? null
            : JsonSerializer.Serialize(input.PrintInputJson);

        var now = DateTime.Now;
        var currentUserId = CurrentUser?.Id?.ToString();
        var batchId = _guidGenerator.Create().ToString();
        var taskIds = new List<string>();

        for (var i = 1; i <= quantity; i++)
        {
            var taskId = _guidGenerator.Create().ToString();
            taskIds.Add(taskId);

            var renderTemplate = resolvedTemplate;
            if (reservedDailyLabelIds is { Count: > 0 })
            {
                var dailyId = reservedDailyLabelIds[Math.Min(i - 1, reservedDailyLabelIds.Count - 1)];
                renderTemplate = JsonSerializer.Deserialize<LabelTemplatePreviewDto>(
                                   JsonSerializer.Serialize(resolvedTemplate))
                               ?? resolvedTemplate;
                LabelTemplateLabelIdHelper.ApplyLabelIdToElements(renderTemplate.Elements, dailyId);
            }

            var renderTemplateJsonStr = JsonSerializer.Serialize(renderTemplate);

            var task = new FlLabelPrintTaskDbEntity
            {
                Id = taskId,
                BatchId = batchId,
                CopyIndex = i,
                ClientRequestId = string.IsNullOrWhiteSpace(clientRequestId) ? null : clientRequestId,
                LabelId = labelRow.Id,
                TemplateId = labelRow.TemplateId,
                LabelTypeId = labelRow.LabelTypeId,
                ProductId = previewProductId,
                LocationId = locationId,
                BaseTime = input.BaseTime,
                PrintInputJson = printInputJsonStr,
                TemplateProductDefaultValuesJson = templateProductDefaultValuesJson,
                RenderTemplateJson = renderTemplateJsonStr,
                PrinterId = input.PrinterId?.Trim(),
                PrinterMac = input.PrinterMac?.Trim(),
                PrinterAddress = input.PrinterAddress?.Trim(),
                Status = "CREATED",
                PrintedAt = null,
                ErrorMessage = null,
                CreatedBy = currentUserId,
                CreationTime = now
            };

            await _dbContext.SqlSugarClient.Insertable(task).ExecuteCommandAsync();

            var rows = renderTemplate.Elements.Select(e =>
            {
                var cfgJson = e.ConfigJson is null ? null : JsonSerializer.Serialize(e.ConfigJson);
                string? renderValue = null;
                if (e.ConfigJson is JsonElement je && je.ValueKind == JsonValueKind.Object && je.TryGetProperty("text", out var tv))
                {
                    renderValue = tv.ValueKind == JsonValueKind.String ? tv.GetString() : tv.ToString();
                }
                else if (e.ConfigJson is Dictionary<string, object?> dict && dict.TryGetValue("text", out var v))
                {
                    renderValue = v?.ToString();
                }

                return new FlLabelPrintDataDbEntity
                {
                    Id = _guidGenerator.Create().ToString(),
                    PrintTaskId = taskId,
                    ElementId = e.Id?.Trim() ?? string.Empty,
                    ElementName = e.ElementName?.Trim(),
                    RenderValue = renderValue,
                    RenderConfigJson = cfgJson
                };
            }).Where(x => !string.IsNullOrWhiteSpace(x.ElementId)).ToList();

            if (rows.Count > 0)
            {
                await _dbContext.SqlSugarClient.Insertable(rows).ExecuteCommandAsync();
            }
        }

        return new UsAppLabelPrintOutputDto
        {
            TaskId = taskIds.FirstOrDefault() ?? string.Empty,
            PrintQuantity = quantity,
            BatchId = batchId,
            TaskIds = taskIds,
            PrintLabelDisplayIds = reservedDailyLabelIds ?? new List<string>()
        };
    }

    /// <summary>
    /// App 重新打印：根据历史任务Id重打（创建新任务与明细）
    /// </summary>
    [Authorize]
    [UnitOfWork]
    public virtual async Task<UsAppLabelPrintOutputDto> ReprintAsync(UsAppLabelReprintInputVo input)
    {
        if (input is null)
        {
            throw new UserFriendlyException("入参不能为空");
        }

        var locationId = input.LocationId?.Trim();
        if (string.IsNullOrWhiteSpace(locationId))
        {
            throw new UserFriendlyException("门店Id不能为空");
        }

        var taskId = input.TaskId?.Trim();
        if (string.IsNullOrWhiteSpace(taskId))
        {
            throw new UserFriendlyException("taskId不能为空");
        }

        var quantity = input.PrintQuantity <= 0 ? 1 : input.PrintQuantity;
        var clientRequestId = input.ClientRequestId?.Trim();
        if (!string.IsNullOrWhiteSpace(clientRequestId))
        {
            var existed = await _dbContext.SqlSugarClient.Queryable<FlLabelPrintTaskDbEntity>()
                .Where(x => x.ClientRequestId == clientRequestId)
                .OrderBy(x => x.CopyIndex)
                .ToListAsync();

            if (existed is not null && existed.Count > 0)
            {
                var existedBatchId = existed.First().BatchId;
                var existedTaskIds = existed.Select(x => x.Id).ToList();
                return new UsAppLabelPrintOutputDto
                {
                    TaskId = existedTaskIds.FirstOrDefault() ?? string.Empty,
                    PrintQuantity = existedTaskIds.Count,
                    BatchId = existedBatchId,
                    TaskIds = existedTaskIds
                };
            }
        }

        var currentUserId = CurrentUser?.Id?.ToString();
        if (string.IsNullOrWhiteSpace(currentUserId))
        {
            throw new UserFriendlyException("未登录");
        }

        var old = await _dbContext.SqlSugarClient.Queryable<FlLabelPrintTaskDbEntity>()
            .FirstAsync(x => x.Id == taskId);
        if (old is null)
        {
            throw new UserFriendlyException("打印任务不存在");
        }

        // 已绑定该门店的账号可重打门店内任意历史任务（不限 CreatedBy）
        if (!string.Equals(old.LocationId?.Trim(), locationId, StringComparison.OrdinalIgnoreCase))
        {
            throw new UserFriendlyException("该任务不属于当前门店");
        }

        LabelTemplatePreviewDto? resolvedTemplate = null;
        try
        {
            resolvedTemplate = JsonSerializer.Deserialize<LabelTemplatePreviewDto>(old.RenderTemplateJson);
        }
        catch
        {
            resolvedTemplate = null;
        }

        if (resolvedTemplate is null)
        {
            throw new UserFriendlyException("历史任务渲染快照解析失败，无法重打");
        }

        var now = DateTime.Now;
        var batchId = _guidGenerator.Create().ToString();
        var taskIds = new List<string>();

        for (var i = 1; i <= quantity; i++)
        {
            var newTaskId = _guidGenerator.Create().ToString();
            taskIds.Add(newTaskId);

            var newTask = new FlLabelPrintTaskDbEntity
            {
                Id = newTaskId,
                BatchId = batchId,
                CopyIndex = i,
                ClientRequestId = string.IsNullOrWhiteSpace(clientRequestId) ? null : clientRequestId,
                LabelId = old.LabelId,
                TemplateId = old.TemplateId,
                LabelTypeId = old.LabelTypeId,
                ProductId = old.ProductId,
                LocationId = old.LocationId,
                BaseTime = old.BaseTime,
                PrintInputJson = old.PrintInputJson,
                TemplateProductDefaultValuesJson = old.TemplateProductDefaultValuesJson,
                RenderTemplateJson = old.RenderTemplateJson,
                PrinterId = string.IsNullOrWhiteSpace(input.PrinterId) ? old.PrinterId : input.PrinterId.Trim(),
                PrinterMac = string.IsNullOrWhiteSpace(input.PrinterMac) ? old.PrinterMac : input.PrinterMac.Trim(),
                PrinterAddress = string.IsNullOrWhiteSpace(input.PrinterAddress) ? old.PrinterAddress : input.PrinterAddress.Trim(),
                Status = "CREATED",
                PrintedAt = null,
                ErrorMessage = null,
                CreatedBy = currentUserId,
                CreationTime = now
            };

            await _dbContext.SqlSugarClient.Insertable(newTask).ExecuteCommandAsync();

            var rows = resolvedTemplate.Elements.Select(e =>
            {
                var cfgJson = e.ConfigJson is null ? null : JsonSerializer.Serialize(e.ConfigJson);
                string? renderValue = null;
                if (e.ConfigJson is JsonElement je && je.ValueKind == JsonValueKind.Object && je.TryGetProperty("text", out var tv))
                {
                    renderValue = tv.ValueKind == JsonValueKind.String ? tv.GetString() : tv.ToString();
                }
                else if (e.ConfigJson is Dictionary<string, object?> dict && dict.TryGetValue("text", out var v))
                {
                    renderValue = v?.ToString();
                }

                return new FlLabelPrintDataDbEntity
                {
                    Id = _guidGenerator.Create().ToString(),
                    PrintTaskId = newTaskId,
                    ElementId = e.Id?.Trim() ?? string.Empty,
                    ElementName = e.ElementName?.Trim(),
                    RenderValue = renderValue,
                    RenderConfigJson = cfgJson
                };
            }).Where(x => !string.IsNullOrWhiteSpace(x.ElementId)).ToList();

            if (rows.Count > 0)
            {
                await _dbContext.SqlSugarClient.Insertable(rows).ExecuteCommandAsync();
            }
        }

        return new UsAppLabelPrintOutputDto
        {
            TaskId = taskIds.FirstOrDefault() ?? string.Empty,
            PrintQuantity = quantity,
            BatchId = batchId,
            TaskIds = taskIds
        };
    }

    /// <summary>
    /// App 打印日志：当前门店打印记录（分页，时间倒序）
    /// </summary>
    /// <remarks>
    /// 数据范围（须已绑定 <c>input.locationId</c>）：返回该门店下<b>全部用户</b>的打印任务（不按 <c>CreatedBy</c> 过滤）。
    ///
    /// 可选按自然日筛选：<c>printDateDay</c>（<c>yyyy-MM-dd</c>，优先）或 <c>printDate</c>；均未传则返回该门店全部记录（分页）。
    /// 出参 <c>labelId</c> 为门店当日打印序号（<c>yyyyMMdd-n</c>）。
    /// ```json
    /// {
    ///   "locationId": "11111111-1111-1111-1111-111111111111",
    ///   "skipCount": 1,
    ///   "maxResultCount": 20
    /// }
    /// ```
    ///
    /// 参数说明：
    /// - locationId: 当前门店 Id（必填）
    /// - skipCount: 页码（从 1 开始，遵循本项目约定）
    /// - maxResultCount: 每页条数
    /// </remarks>
    /// <param name="input">分页查询入参</param>
    /// <returns>分页打印日志</returns>
    /// <response code="200">成功</response>
    /// <response code="400">参数错误/未登录</response>
    /// <response code="500">服务器错误</response>
    [Authorize]
    [HttpPost]
    public virtual async Task<PagedResultWithPageDto<PrintLogItemDto>> GetPrintLogListAsync(PrintLogGetListInputVo input)
    {
        if (input is null)
        {
            throw new UserFriendlyException("入参不能为空");
        }

        if (!CurrentUser.Id.HasValue)
        {
            throw new UserFriendlyException("用户未登录");
        }

        var locationId = input.LocationId?.Trim();
        if (string.IsNullOrWhiteSpace(locationId))
        {
            throw new UserFriendlyException("门店Id不能为空");
        }

        var currentUserIdStr = CurrentUser.Id.Value.ToString();
        await UsAppPrintLogScopeHelper.EnsureUserCanAccessLocationAsync(
            CurrentUser, _dbContext.SqlSugarClient, locationId);

        var locationName = "无";
        if (Guid.TryParse(locationId, out var locationGuid))
        {
            var loc = await _dbContext.SqlSugarClient.Queryable<LocationAggregateRoot>()
                .Where(x => !x.IsDeleted && x.Id == locationGuid)
                .Select(x => new { x.LocationCode, x.LocationName })
                .FirstAsync();
            if (loc is not null)
            {
                var name = loc.LocationName?.Trim();
                if (!string.IsNullOrWhiteSpace(name))
                {
                    locationName = name;
                }
            }
        }

        RefAsync<int> total = 0;

        var baseQuery = UsAppPrintLogScopeHelper.BuildLocationPrintTaskQuery(
            _dbContext.SqlSugarClient, locationId, restrictToCreator: false, currentUserIdStr);

        var (printDayStart, printDayEndExcl) = ResolvePrintLogDateFilter(input);
        if (printDayStart.HasValue && printDayEndExcl.HasValue)
        {
            var dayStart = printDayStart.Value;
            var dayEndExcl = printDayEndExcl.Value;
            baseQuery = baseQuery.Where((t, l, p, lt, tpl) =>
                SqlFunc.IsNull(t.PrintedAt, t.CreationTime) >= dayStart &&
                SqlFunc.IsNull(t.PrintedAt, t.CreationTime) < dayEndExcl);
        }

        var pageRows = await baseQuery
            .OrderBy((t, l, p, lt, tpl) => SqlFunc.IsNull(t.PrintedAt, t.CreationTime), OrderByType.Desc)
            .OrderBy((t, l, p, lt, tpl) => t.CreationTime, OrderByType.Desc)
            .Select((t, l, p, lt, tpl) => new
            {
                t.Id,
                t.BatchId,
                t.CopyIndex,
                t.LabelId,
                LabelCode = l.LabelCode,
                t.ProductId,
                ProductName = p.ProductName,
                TypeName = lt.TypeName,
                TemplateWidth = tpl.Width,
                TemplateHeight = tpl.Height,
                TemplateUnit = tpl.Unit,
                t.PrintInputJson,
                t.PrintedAt,
                t.CreationTime,
                t.CreatedBy
            })
            .ToPageListAsync(input.SkipCount, input.MaxResultCount, total);

        var pageTaskIds = pageRows.Select(x => x.Id).ToList();
        var createdByByTaskId = pageTaskIds.Count == 0
            ? new Dictionary<string, string?>(StringComparer.Ordinal)
            : (await _dbContext.SqlSugarClient.Queryable<FlLabelPrintTaskDbEntity>()
                .Where(t => pageTaskIds.Contains(t.Id))
                .Select(t => new { t.Id, t.CreatedBy })
                .ToListAsync())
            .ToDictionary(x => x.Id, x => x.CreatedBy, StringComparer.Ordinal);

        var operatorMap = await UsAppPrintLogScopeHelper.LoadOperatorNameMapAsync(
            _dbContext.SqlSugarClient,
            createdByByTaskId.Values.Concat(pageRows.Select(x => x.CreatedBy)));

        var dailyLabelIdMap = await ReportsPrintLogDailyLabelIdHelper.ResolveDailyLabelIdsAsync(
            _dbContext.SqlSugarClient,
            pageRows.Select(x => new ReportsPrintLogDailyLabelIdHelper.PrintTaskScopeKey(
                x.Id, locationId, x.PrintedAt ?? x.CreationTime)).ToList());

        var items = pageRows.Select(x => new PrintLogItemDto
        {
            TaskId = x.Id,
            BatchId = x.BatchId,
            CopyIndex = x.CopyIndex,
            LabelId = dailyLabelIdMap.TryGetValue(x.Id, out var dailyId) ? dailyId : "无",
            LabelEntityId = x.LabelId,
            LabelCode = x.LabelCode ?? string.Empty,
            ProductId = x.ProductId,
            ProductName = string.IsNullOrWhiteSpace(x.ProductName) ? "无" : x.ProductName.Trim(),
            TypeName = x.TypeName ?? string.Empty,
            LabelSizeText = FormatLabelSizeWithUnit(x.TemplateWidth, x.TemplateHeight, x.TemplateUnit),
            PrintInputJson = x.PrintInputJson,
            PrintedAt = x.PrintedAt ?? x.CreationTime,
            OperatorName = UsAppPrintLogScopeHelper.ResolveOperatorName(
                operatorMap,
                createdByByTaskId.TryGetValue(x.Id, out var createdBy) ? createdBy : x.CreatedBy),
            LocationName = locationName
        }).ToList();

        var pageSize = input.MaxResultCount <= 0 ? items.Count : input.MaxResultCount;
        var pageIndex = pageSize <= 0 ? 1 : PagedQueryConvention.PageIndexFromSkipCount(input.SkipCount);
        var totalCount = (long)total;
        var totalPages = pageSize <= 0 ? 0 : (int)Math.Ceiling(totalCount / (double)pageSize);

        return new PagedResultWithPageDto<PrintLogItemDto>
        {
            PageIndex = pageIndex,
            PageSize = pageSize,
            TotalCount = totalCount,
            TotalPages = totalPages,
            Items = items
        };
    }

    /// <summary>
    /// App Label Report：当前门店打印统计（该门店下全部用户的打印任务，不按 CreatedBy 过滤）
    /// </summary>
    /// <remarks>
    /// 示例：<c>POST /api/app/us-app-labeling/get-label-report</c>
    /// ```json
    /// { "locationId": "3a21220f-db37-3e32-7390-d55f64cd62a8", "startDate": "2026-04-07", "endDate": "2026-05-18" }
    /// ```
    /// </remarks>
    [Authorize]
    [HttpPost]
    public virtual async Task<ReportsLabelReportOutputDto> GetLabelReportAsync(UsAppLabelReportQueryInputVo input)
    {
        if (input is null)
        {
            throw new UserFriendlyException("入参不能为空");
        }

        if (!CurrentUser.Id.HasValue)
        {
            throw new UserFriendlyException("用户未登录");
        }

        var locationId = input.LocationId?.Trim();
        if (string.IsNullOrWhiteSpace(locationId))
        {
            throw new UserFriendlyException("门店Id不能为空");
        }

        await UsAppPrintLogScopeHelper.EnsureUserCanAccessLocationAsync(
            CurrentUser, _dbContext.SqlSugarClient, locationId);

        var keyword = input.Keyword?.Trim();

        var (curStart, curEndExcl) = ResolveAppDateRange(input.StartDate, input.EndDate);
        var span = curEndExcl - curStart;
        if (span.TotalDays < 1)
        {
            span = TimeSpan.FromDays(1);
        }

        var prevEndExcl = curStart;
        var prevStart = curStart - span;
        var db = _dbContext.SqlSugarClient;

        ISugarQueryable<FlLabelPrintTaskDbEntity, FlLabelDbEntity, FlProductDbEntity, FlLabelCategoryDbEntity,
            FlProductCategoryDbEntity, FlLabelTypeDbEntity, FlLabelTemplateDbEntity> Core() =>
            UsAppPrintLogScopeHelper.BuildLocationPrintTaskReportQuery(
                db, locationId, restrictToCreator: false, currentUserIdStr: string.Empty, keyword);

        var totalCur = await Core()
            .Where((t, l, p, lc, pc, lt, tpl) =>
                SqlFunc.IsNull(t.PrintedAt, t.CreationTime) >= curStart &&
                SqlFunc.IsNull(t.PrintedAt, t.CreationTime) < curEndExcl)
            .CountAsync();

        var totalPrev = await Core()
            .Where((t, l, p, lc, pc, lt, tpl) =>
                SqlFunc.IsNull(t.PrintedAt, t.CreationTime) >= prevStart &&
                SqlFunc.IsNull(t.PrintedAt, t.CreationTime) < prevEndExcl)
            .CountAsync();

        var dayCount = Math.Max(1, (int)Math.Ceiling((curEndExcl - curStart).TotalDays));
        var prevDayCount = Math.Max(1, (int)Math.Ceiling((prevEndExcl - prevStart).TotalDays));
        var avgDaily = Math.Round((decimal)totalCur / dayCount, 2);
        var avgDailyPrev = Math.Round((decimal)totalPrev / prevDayCount, 2);

        var categoryRows = await Core()
            .Where((t, l, p, lc, pc, lt, tpl) =>
                l.LabelCategoryId != null &&
                SqlFunc.IsNull(t.PrintedAt, t.CreationTime) >= curStart &&
                SqlFunc.IsNull(t.PrintedAt, t.CreationTime) < curEndExcl)
            .GroupBy((t, l, p, lc, pc, lt, tpl) => new { lc.Id, lc.CategoryName })
            .Select((t, l, p, lc, pc, lt, tpl) => new { lc.Id, lc.CategoryName, Cnt = SqlFunc.AggregateCount(t.Id) })
            .ToListAsync();

        var topCat = categoryRows.OrderByDescending(x => x.Cnt).FirstOrDefault();

        var productRows = await Core()
            .Where((t, l, p, lc, pc, lt, tpl) =>
                !string.IsNullOrEmpty(p.Id) &&
                SqlFunc.IsNull(t.PrintedAt, t.CreationTime) >= curStart &&
                SqlFunc.IsNull(t.PrintedAt, t.CreationTime) < curEndExcl)
            .GroupBy((t, l, p, lc, pc, lt, tpl) => new { p.Id, p.ProductName, Cat = pc.CategoryName })
            .Select((t, l, p, lc, pc, lt, tpl) => new
            {
                p.Id,
                p.ProductName,
                CategoryName = pc.CategoryName,
                Cnt = SqlFunc.AggregateCount(t.Id)
            })
            .ToListAsync();

        var topProd = productRows.OrderByDescending(x => x.Cnt).FirstOrDefault();
        var topList = productRows.OrderByDescending(x => x.Cnt).Take(20).ToList();

        var trendEndDay = curEndExcl.Date.AddDays(-1);
        var trendStartDay = trendEndDay.AddDays(-6);
        if (trendStartDay < curStart.Date)
        {
            trendStartDay = curStart.Date;
        }

        var trendEndExcl = trendEndDay.AddDays(1);

        var trendRaw = await Core()
            .Where((t, l, p, lc, pc, lt, tpl) =>
                SqlFunc.IsNull(t.PrintedAt, t.CreationTime) >= trendStartDay &&
                SqlFunc.IsNull(t.PrintedAt, t.CreationTime) < trendEndExcl)
            .Select((t, l, p, lc, pc, lt, tpl) => SqlFunc.IsNull(t.PrintedAt, t.CreationTime))
            .ToListAsync();

        var trendDict = trendRaw
            .Where(x => x.HasValue)
            .GroupBy(x => x!.Value.Date)
            .ToDictionary(g => g.Key, g => g.Count());

        var trend = new List<ReportsDailyCountDto>();
        for (var d = trendStartDay; d <= trendEndDay; d = d.AddDays(1))
        {
            trend.Add(new ReportsDailyCountDto
            {
                Date = d.ToString("yyyy-MM-dd"),
                Count = trendDict.TryGetValue(d, out var c) ? c : 0
            });
        }

        var byCategory = categoryRows
            .OrderByDescending(x => x.Cnt)
            .Select(x => new ReportsCategoryCountDto
            {
                CategoryId = string.IsNullOrWhiteSpace(x.Id) ? null : x.Id.Trim(),
                CategoryName = string.IsNullOrWhiteSpace(x.CategoryName) ? null : x.CategoryName.Trim(),
                Count = x.Cnt
            })
            .ToList();

        var mostUsed = topList.Select(x =>
        {
            var pct = totalCur <= 0 ? 0m : Math.Round(x.Cnt * 100m / totalCur, 2);
            return new ReportsTopProductRowDto
            {
                ProductId = string.IsNullOrWhiteSpace(x.Id) ? null : x.Id.Trim(),
                ProductName = string.IsNullOrWhiteSpace(x.ProductName) ? null : x.ProductName.Trim(),
                CategoryName = string.IsNullOrWhiteSpace(x.CategoryName) ? null : x.CategoryName!.Trim(),
                TotalPrinted = x.Cnt,
                UsagePercent = pct
            };
        }).ToList();

        return new ReportsLabelReportOutputDto
        {
            Summary = new ReportsLabelReportSummaryDto
            {
                TotalLabelsPrinted = totalCur,
                TotalLabelsPrintedPrevPeriod = totalPrev,
                TotalLabelsPrintedChangeRate = CalcAppChangeRate(totalCur, totalPrev),
                MostPrintedCategoryName = string.IsNullOrWhiteSpace(topCat?.CategoryName) ? null : topCat.CategoryName.Trim(),
                MostPrintedCategoryCount = topCat?.Cnt ?? 0,
                TopProductName = string.IsNullOrWhiteSpace(topProd?.ProductName) ? null : topProd.ProductName.Trim(),
                TopProductCount = topProd?.Cnt ?? 0,
                AvgDailyPrints = avgDaily,
                AvgDailyPrintsPrevPeriod = avgDailyPrev,
                AvgDailyPrintsChangeRate = CalcAppChangeRate(avgDaily, avgDailyPrev)
            },
            LabelsByCategory = byCategory,
            PrintVolumeTrend = trend,
            MostUsedProducts = mostUsed
        };
    }

    private static (DateTime? DayStart, DateTime? DayEndExcl) ResolvePrintLogDateFilter(PrintLogGetListInputVo input)
    {
        if (!string.IsNullOrWhiteSpace(input.PrintDateDay) &&
            DateTime.TryParse(input.PrintDateDay.Trim(), out var parsedDay))
        {
            var day = parsedDay.Date;
            return (day, day.AddDays(1));
        }

        if (input.PrintDate.HasValue)
        {
            var day = input.PrintDate.Value.Date;
            return (day, day.AddDays(1));
        }

        return (null, null);
    }

    private static (DateTime rangeStart, DateTime rangeEndExcl) ResolveAppDateRange(DateTime? startDate, DateTime? endDate)
    {
        var endDay = (endDate ?? DateTime.Today).Date;
        var endExcl = endDay.AddDays(1);
        var start = (startDate ?? endDay.AddDays(-29)).Date;
        if (start >= endExcl)
        {
            start = endExcl.AddDays(-1);
        }

        return (start, endExcl);
    }

    private static decimal CalcAppChangeRate(decimal current, decimal previous)
    {
        if (previous == 0)
        {
            return current > 0 ? 100m : 0m;
        }

        return Math.Round((current - previous) * 100m / previous, 2);
    }

    /// <summary>
    /// 将 fl_label_template_product_default 默认值写入预览模板元素 config（日期偏移保留 JSON，由客户端按 BaseTime 展开）。
    /// </summary>
    private static void ApplyTemplateProductDefaultValuesToPreviewElements(
        IList<LabelTemplateElementDto>? elements,
        Dictionary<string, object?> defaults)
    {
        if (elements == null || elements.Count == 0 || defaults == null || defaults.Count == 0)
        {
            return;
        }

        foreach (var el in elements)
        {
            var stored = ResolveTemplateProductDefaultValueForElement(el, defaults);
            if (string.IsNullOrWhiteSpace(stored))
            {
                continue;
            }

            var cfg = ParsePreviewElementConfig(el.ConfigJson);
            var type = (el.ElementType ?? string.Empty).Trim().ToUpperInvariant();

            switch (type)
            {
                case "DATE":
                case "TIME":
                case "DURATION":
                    cfg["text"] = stored;
                    cfg["Text"] = stored;
                    break;
                case "IMAGE":
                case "LOGO":
                    cfg["src"] = stored;
                    cfg["Src"] = stored;
                    cfg["url"] = stored;
                    cfg["Url"] = stored;
                    break;
                case "BARCODE":
                case "QRCODE":
                    cfg["data"] = stored;
                    cfg["Data"] = stored;
                    break;
                default:
                    cfg["text"] = stored;
                    cfg["Text"] = stored;
                    break;
            }

            el.ConfigJson = cfg;
        }
    }

    private static string? ResolveTemplateProductDefaultValueForElement(
        LabelTemplateElementDto el,
        Dictionary<string, object?> defaults)
    {
        var candidates = new[]
        {
            el.Id?.Trim(),
            el.InputKey?.Trim(),
            el.ElementName?.Trim(),
        }.Where(x => !string.IsNullOrWhiteSpace(x)).ToList();

        foreach (var key in candidates)
        {
            if (defaults.TryGetValue(key!, out var direct))
            {
                return TemplateProductDefaultValueToStoredString(direct);
            }
        }

        foreach (var kv in defaults)
        {
            foreach (var key in candidates)
            {
                if (string.Equals(kv.Key, key, StringComparison.OrdinalIgnoreCase))
                {
                    return TemplateProductDefaultValueToStoredString(kv.Value);
                }
            }
        }

        return null;
    }

    private static string? TemplateProductDefaultValueToStoredString(object? value)
    {
        if (value is null)
        {
            return null;
        }

        if (value is string s)
        {
            return s;
        }

        if (value is JsonElement je)
        {
            if (je.ValueKind == JsonValueKind.String)
            {
                return je.GetString();
            }

            if (je.ValueKind is JsonValueKind.Object or JsonValueKind.Array)
            {
                return je.GetRawText();
            }

            return je.ToString();
        }

        if (value is bool or int or long or decimal or double or float)
        {
            return Convert.ToString(value, CultureInfo.InvariantCulture);
        }

        return JsonSerializer.Serialize(value);
    }

    private static Dictionary<string, object?> ParsePreviewElementConfig(object? configJson)
    {
        if (configJson is null)
        {
            return new Dictionary<string, object?>();
        }

        if (configJson is Dictionary<string, object?> dict)
        {
            return new Dictionary<string, object?>(dict);
        }

        if (configJson is JsonElement je && je.ValueKind == JsonValueKind.Object)
        {
            try
            {
                return JsonSerializer.Deserialize<Dictionary<string, object?>>(je.GetRawText())
                       ?? new Dictionary<string, object?>();
            }
            catch
            {
                return new Dictionary<string, object?>();
            }
        }

        if (configJson is string raw && !string.IsNullOrWhiteSpace(raw))
        {
            try
            {
                return JsonSerializer.Deserialize<Dictionary<string, object?>>(raw)
                       ?? new Dictionary<string, object?>();
            }
            catch
            {
                return new Dictionary<string, object?>();
            }
        }

        try
        {
            var json = JsonSerializer.Serialize(configJson);
            return JsonSerializer.Deserialize<Dictionary<string, object?>>(json)
                   ?? new Dictionary<string, object?>();
        }
        catch
        {
            return new Dictionary<string, object?>();
        }
    }

    private async Task<string?> ResolveTemplateProductDefaultValuesJsonAsync(
        string templateId,
        string? productId,
        string labelTypeId)
    {
        if (string.IsNullOrWhiteSpace(templateId) || string.IsNullOrWhiteSpace(productId) || string.IsNullOrWhiteSpace(labelTypeId))
        {
            return null;
        }

        var productDefault = await _dbContext.SqlSugarClient.Queryable<FlLabelTemplateProductDefaultDbEntity>()
            .Where(x => x.TemplateId == templateId)
            .Where(x => x.ProductId == productId)
            .Where(x => x.LabelTypeId == labelTypeId)
            .OrderBy(x => x.OrderNum)
            .FirstAsync();

        return string.IsNullOrWhiteSpace(productDefault?.DefaultValuesJson) ? null : productDefault!.DefaultValuesJson;
    }

    private async Task<ISugarQueryable<FlLabelProductDbEntity, FlLabelDbEntity, FlProductDbEntity, FlLabelCategoryDbEntity, FlLabelTypeDbEntity, FlLabelTemplateDbEntity, FlProductCategoryDbEntity>> BuildLabelingJoinQueryAsync(
        string locationId,
        List<string> productIds,
        string? filterCategoryId,
        string? keyword)
    {
        var storeGroupIds = await LocationScopeBindingHelper.ResolveGroupIdsFromLocationIdsAsync(
            _dbContext.SqlSugarClient, new List<string> { locationId });
        var regionSchema = await LabelRegionSchemaHelper.GetStatusAsync(_dbContext.SqlSugarClient);
        var storeFilter = LabelRegionScopeHelper.BuildAppLabelingTreeStoreFilterSql(
            regionSchema, locationId, storeGroupIds);

        var q = _dbContext.SqlSugarClient
            .Queryable<FlLabelProductDbEntity>()
            .InnerJoin<FlLabelDbEntity>((lp, l) => lp.LabelId == l.Id)
            .InnerJoin<FlProductDbEntity>((lp, l, p) => lp.ProductId == p.Id)
            .InnerJoin<FlLabelCategoryDbEntity>((lp, l, p, c) => l.LabelCategoryId == c.Id)
            .InnerJoin<FlLabelTypeDbEntity>((lp, l, p, c, t) => l.LabelTypeId == t.Id)
            .InnerJoin<FlLabelTemplateDbEntity>((lp, l, p, c, t, tpl) => l.TemplateId == tpl.Id)
            .LeftJoin<FlProductCategoryDbEntity>((lp, l, p, c, t, tpl, pc) => p.CategoryId == pc.Id)
            .Where((lp, l, p, c, t, tpl, pc) => productIds.Contains(p.Id))
            .Where(storeFilter.Sql, storeFilter.Parameters);

        q = q
            .Where((lp, l, p, c, t, tpl, pc) => !l.IsDeleted && l.State)
            .Where((lp, l, p, c, t, tpl, pc) => !p.IsDeleted && p.State)
            .Where((lp, l, p, c, t, tpl, pc) => !c.IsDeleted && c.State)
            .Where((lp, l, p, c, t, tpl, pc) =>
                c.AvailabilityType == "ALL" ||
                SqlFunc.Subqueryable<FlLabelCategoryLocationDbEntity>()
                    .Where(cl => cl.CategoryId == c.Id && cl.LocationId == locationId)
                    .Any())
            .Where((lp, l, p, c, t, tpl, pc) => !t.IsDeleted && t.State)
            .Where((lp, l, p, c, t, tpl, pc) => !tpl.IsDeleted)
            .Where((lp, l, p, c, t, tpl, pc) =>
                pc.Id == null || (!pc.IsDeleted && pc.State))
            .WhereIF(!string.IsNullOrWhiteSpace(filterCategoryId), (lp, l, p, c, t, tpl, pc) => l.LabelCategoryId == filterCategoryId)
            .WhereIF(!string.IsNullOrWhiteSpace(keyword), (lp, l, p, c, t, tpl, pc) =>
                (l.LabelName != null && l.LabelName.Contains(keyword!)) ||
                (p.ProductName != null && p.ProductName.Contains(keyword!)) ||
                (p.CodeValue != null && p.CodeValue.Contains(keyword!)) ||
                (p.DisplayText != null && p.DisplayText.Contains(keyword!)) ||
                (pc.CategoryName != null && pc.CategoryName.Contains(keyword!)) ||
                (pc.DisplayText != null && pc.DisplayText.Contains(keyword!)) ||
                (c.CategoryName != null && c.CategoryName.Contains(keyword!)) ||
                (t.TypeName != null && t.TypeName.Contains(keyword!)) ||
                (l.LabelCode != null && l.LabelCode.Contains(keyword!)));

        return q;
    }

    private sealed class LabelingTreeRow
    {
        public string LabelCategoryId { get; set; } = string.Empty;

        public string? LabelCategoryName { get; set; }

        public string? LabelCategoryPhotoUrl { get; set; }

        public string? LabelCategoryDisplayText { get; set; }

        public string? LabelCategoryButtonAppearance { get; set; }

        public int LabelCategoryOrderNum { get; set; }

        public string? ProductCategoryId { get; set; }

        public string? ProductCategoryName { get; set; }

        public string? ProductCategoryPhotoUrl { get; set; }

        public string? ProductCategoryDisplayText { get; set; }

        public string? ProductCategoryButtonAppearance { get; set; }

        public string? ProductCategoryAvailabilityType { get; set; }

        public int ProductCategoryOrderNum { get; set; }

        public string ProductId { get; set; } = string.Empty;

        public string? ProductName { get; set; }

        public string? ProductCode { get; set; }

        public string? ProductImageUrl { get; set; }

        public string? ProductDisplayText { get; set; }

        public string? ProductCodeValue { get; set; }

        public string? ProductButtonAppearance { get; set; }

        /// <summary>产品级 CategoryPhotoUrl（fl_product），勿与 L2 产品分类字段混淆</summary>
        public string? ProductAppearancePhotoUrl { get; set; }

        public string LabelTypeId { get; set; } = string.Empty;

        public string? TypeName { get; set; }

        public int TypeOrderNum { get; set; }

        public string LabelCode { get; set; } = string.Empty;

        public string TemplateId { get; set; } = string.Empty;

        public string? TemplateCode { get; set; }

        public decimal TemplateWidth { get; set; }

        public decimal TemplateHeight { get; set; }

        public string TemplateUnit { get; set; } = "inch";
    }

    /// <summary>
    /// 将 App 入参中的 JsonElement（对象或 null）反序列化为 PreviewAsync 所需的扁平字典。
    /// </summary>
    private static Dictionary<string, object?>? ParsePrintInputJsonToDictionary(JsonElement? printInputJson)
    {
        if (printInputJson is null)
        {
            return null;
        }

        var je = printInputJson.Value;
        if (je.ValueKind is JsonValueKind.Null or JsonValueKind.Undefined)
        {
            return null;
        }

        try
        {
            return JsonSerializer.Deserialize<Dictionary<string, object?>>(je.GetRawText());
        }
        catch
        {
            return null;
        }
    }

    private static string FormatProductCodeValueDisplay(string? codeValue)
    {
        var s = codeValue?.Trim();
        return string.IsNullOrWhiteSpace(s) ? "无" : s;
    }

    private static string NormalizeCategoryName(string? categoryName)
    {
        var s = categoryName?.Trim();
        return string.IsNullOrWhiteSpace(s) ? "无" : s;
    }

    private static string? NormalizeNullableId(string? id)
    {
        var s = id?.Trim();
        return string.IsNullOrWhiteSpace(s) ? null : s;
    }

    private static string? NormalizeNullableUrl(string? url)
    {
        var s = url?.Trim();
        return string.IsNullOrWhiteSpace(s) ? null : s;
    }

    private static string? NormalizeNullableAppearance(string? appearance)
    {
        var s = appearance?.Trim();
        return string.IsNullOrWhiteSpace(s) ? null : s;
    }

    private static string? NormalizeAvailabilityType(string? availabilityType)
    {
        var s = availabilityType?.Trim();
        return string.IsNullOrWhiteSpace(s) ? null : s.ToUpperInvariant();
    }

    private async Task<string?> ResolvePreviewProductIdAsync(string labelId, string? productId)
    {
        var resolvedProductId = productId?.Trim();
        if (!string.IsNullOrWhiteSpace(resolvedProductId))
        {
            return resolvedProductId;
        }

        return await _dbContext.SqlSugarClient.Queryable<FlLabelProductDbEntity>()
            .Where(x => x.LabelId == labelId)
            .Select(x => x.ProductId)
            .FirstAsync();
    }

    private static UsAppLabelTypeNodeDto BuildLabelTypeNode(LabelingTreeRow r)
    {
        return new UsAppLabelTypeNodeDto
        {
            LabelTypeId = r.LabelTypeId,
            TypeName = r.TypeName ?? string.Empty,
            OrderNum = r.TypeOrderNum,
            LabelCode = r.LabelCode ?? string.Empty,
            TemplateCode = r.TemplateCode,
            LabelSizeText = FormatLabelSize(r.TemplateWidth, r.TemplateHeight, r.TemplateUnit)
        };
    }

    private static string? FormatLabelSize(decimal w, decimal h, string unit)
    {
        var u = (unit ?? "inch").Trim().ToLowerInvariant();
        var ws = w.ToString(CultureInfo.InvariantCulture);
        var hs = h.ToString(CultureInfo.InvariantCulture);
        return u is "inch" or "in"
            ? $"{ws}\"x{hs}\""
            : $"{ws}x{hs}{u}";
    }

    private static string? FormatLabelSizeWithUnit(decimal w, decimal h, string unit)
    {
        var u = (unit ?? "inch").Trim().ToLowerInvariant();
        var ws = w.ToString(CultureInfo.InvariantCulture);
        var hs = h.ToString(CultureInfo.InvariantCulture);
        var normalizedUnit = u is "in" ? "inch" : u;
        return $"{ws}x{hs}{normalizedUnit}";
    }
}