using System.Text.Json;
using FoodLabeling.Application.Helpers;
using FoodLabeling.Application.Contracts.Dtos.Common;
using FoodLabeling.Application.Contracts.Dtos.LabelTemplate;
using FoodLabeling.Application.Contracts.IServices;
using FoodLabeling.Application.Services.DbModels;
using SqlSugar;
using Volo.Abp;
using Volo.Abp.Application.Services;
using Volo.Abp.Guids;
using Volo.Abp.Uow;
using Yi.Framework.SqlSugarCore.Abstractions;

namespace FoodLabeling.Application.Services;

/// <summary>
/// 标签模板管理（Label Templates）
/// </summary>
public class LabelTemplateAppService : ApplicationService, ILabelTemplateAppService
{
    private readonly ISqlSugarDbContext _dbContext;
    private readonly IGuidGenerator _guidGenerator;

    public LabelTemplateAppService(ISqlSugarDbContext dbContext, IGuidGenerator guidGenerator)
    {
        _dbContext = dbContext;
        _guidGenerator = guidGenerator;
    }

    public async Task<PagedResultWithPageDto<LabelTemplateGetListOutputDto>> GetListAsync(LabelTemplateGetListInputVo input)
    {
        RefAsync<int> total = 0;
        var keyword = input.Keyword?.Trim();
        var scopedLocationIds = await TeamMemberListScopeHelper.ResolveListLocationIdsAsync(
            CurrentUser,
            _dbContext,
            input.PartnerId,
            input.GroupId,
            input.LocationId);

        var query = _dbContext.SqlSugarClient.Queryable<FlLabelTemplateDbEntity>()
            .Where(x => !x.IsDeleted)
            .WhereIF(!string.IsNullOrWhiteSpace(keyword), x =>
                x.TemplateName.Contains(keyword!) || x.TemplateCode.Contains(keyword!))
            .WhereIF(!string.IsNullOrWhiteSpace(input.LabelType), x => x.LabelType == input.LabelType)
            .WhereIF(input.State != null, x => x.State == input.State);

        query = await LabelTemplateScopeHelper.ApplyTemplateScopeFilterAsync(
            _dbContext.SqlSugarClient,
            query,
            scopedLocationIds,
            input.PartnerId,
            input.GroupId,
            input.LocationId);

        query = LabelTemplateQueryHelper.ApplyListSorting(query, input.Sorting);
        query = LabelTemplateQueryHelper.ProjectListColumns(query);

        var pageEntities = await query.ToPageListAsync(input.SkipCount, input.MaxResultCount, total);
        var templateIds = pageEntities.Select(x => x.Id).ToList();

        // element count (Contents)
        var elementCounts = await _dbContext.SqlSugarClient.Queryable<FlLabelTemplateElementDbEntity>()
            .Where(x => templateIds.Contains(x.TemplateId))
            .GroupBy(x => x.TemplateId)
            .Select(x => new { TemplateId = x.TemplateId, Count = SqlFunc.AggregateCount(x.Id) })
            .ToListAsync();
        var elementCountMap = elementCounts.ToDictionary(x => x.TemplateId, x => (int)x.Count);

        var scopeMap = await LabelTemplateScopeHelper.BuildScopeDisplayMapAsync(
            _dbContext.SqlSugarClient, pageEntities);
        var itemsMap = await LabelTemplateListItemsHelper.ResolveTemplateItemsMapAsync(
            _dbContext.SqlSugarClient, templateIds);
        var contentsFromElementsMap = await LabelTemplateContentsHelper.ResolveContentsMapFromElementsAsync(
            _dbContext.SqlSugarClient, templateIds);

        var items = pageEntities.Select(x =>
        {
            scopeMap.TryGetValue(x.Id, out var scope);
            itemsMap.TryGetValue(x.Id, out var itemsDisplay);
            var lastEdited = x.LastModificationTime ?? x.CreationTime;
            var contentsCount = elementCountMap.TryGetValue(x.Id, out var c) ? c : 0;
            var locationDisplay = scope?.Location ?? EmptyDisplay;
            var sizeText = $"{x.Width}x{x.Height}{x.Unit}";
            contentsFromElementsMap.TryGetValue(x.Id, out var fromElements);
            var contentsText = !string.IsNullOrWhiteSpace(fromElements)
                ? fromElements!
                : (itemsDisplay?.Items ?? FoodLabelingDisplayConsts.NotAvailable);

            return new LabelTemplateGetListOutputDto
            {
                Id = x.TemplateCode, // front-end uses templateCode as identifier
                TemplateCode = x.TemplateCode,
                TemplateName = x.TemplateName,
                LabelType = x.LabelType,
                LocationText = locationDisplay,
                Company = scope?.Company ?? string.Empty,
                Region = scope?.Region ?? string.Empty,
                Location = locationDisplay,
                PartnerIds = scope?.PartnerIds ?? new List<string>(),
                CompanyIds = scope?.PartnerIds ?? new List<string>(),
                RegionIds = scope?.RegionIds ?? new List<string>(),
                GroupIds = scope?.RegionIds ?? new List<string>(),
                LocationIds = scope?.LocationIds ?? new List<string>(),
                ContentsCount = contentsCount,
                Contents = contentsText,
                Items = contentsText,
                ItemNames = itemsDisplay?.ItemNames ?? new List<string>(),
                SizeText = sizeText,
                PrintOrientation = LabelTemplatePrintOrientationHelper.Normalize(x.PrintOrientation),
                VersionNo = x.VersionNo,
                LastEdited = lastEdited
            };
        }).ToList();

        return BuildPagedResult(input.SkipCount, input.MaxResultCount, total, items);
    }

    public async Task<LabelTemplateGetOutputDto> GetAsync(string id)
    {
        var template = await LabelTemplateQueryHelper.QueryProjected(_dbContext.SqlSugarClient)
            .FirstAsync(x => !x.IsDeleted && x.TemplateCode == id);
        if (template is null)
        {
            throw new UserFriendlyException("模板不存在");
        }

        var elements = await _dbContext.SqlSugarClient.Queryable<FlLabelTemplateElementDbEntity>()
            .Where(x => x.TemplateId == template.Id)
            .OrderBy(x => x.OrderNum)
            .ToListAsync();

        List<LabelTemplateElementDto> MapElements()
        {
            return elements.Select(e =>
            {
                object? cfg = null;
                if (!string.IsNullOrWhiteSpace(e.ConfigJson))
                {
                    cfg = JsonSerializer.Deserialize<object>(e.ConfigJson);
                }

                return new LabelTemplateElementDto
                {
                    Id = e.ElementKey,
                    ElementType = e.ElementType,
                    TypeAdd = e.TypeAdd,
                    ElementName = e.ElementName,
                    PosX = e.PosX,
                    PosY = e.PosY,
                    Width = e.Width,
                    Height = e.Height,
                    Rotation = e.Rotation,
                    BorderType = e.BorderType,
                    ZIndex = e.ZIndex,
                    OrderNum = e.OrderNum,
                    ValueSourceType = e.ValueSourceType,
                    BindingExpr = e.BindingExpr,
                    AutoQueryKey = e.AutoQueryKey,
                    InputKey = e.InputKey,
                    IsRequiredInput = e.IsRequiredInput,
                    ConfigJson = cfg
                };
            }).ToList();
        }

        var defaultRows = await _dbContext.SqlSugarClient.Queryable<FlLabelTemplateProductDefaultDbEntity>()
            .Where(x => x.TemplateId == template.Id)
            .OrderBy(x => x.OrderNum)
            .ToListAsync();

        var productDefaults = defaultRows.Select(x =>
        {
            object? defaults = null;
            if (!string.IsNullOrWhiteSpace(x.DefaultValuesJson))
            {
                defaults = JsonSerializer.Deserialize<object>(x.DefaultValuesJson);
            }

            return new LabelTemplateProductDefaultDto
            {
                ProductId = x.ProductId,
                LabelTypeId = x.LabelTypeId,
                DefaultValues = defaults,
                OrderNum = x.OrderNum
            };
        }).ToList();

        var borderType = await LabelTemplateScopeSchemaHelper.GetBorderTypeForTemplateAsync(
            _dbContext.SqlSugarClient, template.Id);

        var mappedElements = MapElements();
        var contents = LabelTemplateContentsHelper.BuildFromElements(mappedElements);
        if (string.IsNullOrWhiteSpace(contents))
        {
            var storedContents = await LabelTemplateScopeSchemaHelper.GetContentsForTemplateAsync(
                _dbContext.SqlSugarClient, template.Id);
            contents = storedContents?.Trim() ?? string.Empty;
        }

        var dto = new LabelTemplateGetOutputDto
        {
            Id = template.TemplateCode,
            TemplateCode = template.TemplateCode,
            TemplateName = template.TemplateName,
            LabelType = template.LabelType,
            Unit = template.Unit,
            Width = template.Width,
            Height = template.Height,
            PrintOrientation = LabelTemplatePrintOrientationHelper.Normalize(template.PrintOrientation),
            AppliedLocationType = template.AppliedLocationType,
            ShowRuler = template.ShowRuler,
            ShowGrid = template.ShowGrid,
            BorderType = NormalizeTemplateBorderType(borderType),
            VersionNo = template.VersionNo,
            State = template.State,
            Contents = contents,
            Elements = mappedElements,
            TemplateProductDefaults = productDefaults
        };

        await FillTemplateScopeOnDtoAsync(dto, template);

        var collapsed = await ScopeAllEchoHelper.CollapseScopeIdsToAllSentinelAsync(
            _dbContext.SqlSugarClient,
            dto.PartnerIds,
            dto.RegionIds,
            dto.LocationIds,
            ScopeAllEchoHelper.ForLabelTemplateDimensions(
                dto.AppliedPartnerType,
                dto.AppliedRegionType,
                dto.AppliedLocationType));
        dto.PartnerIds = collapsed.PartnerIds;
        dto.CompanyIds = collapsed.PartnerIds;
        dto.RegionIds = collapsed.RegionIds;
        dto.GroupIds = collapsed.RegionIds;
        dto.LocationIds = collapsed.LocationIds;
        dto.AppliedLocationIds = collapsed.LocationIds;

        return dto;
    }

    /// <summary>
    /// 新增标签模板。Company / Region / Location 三维范围；
    /// <c>regionIds</c>、<c>groupIds</c>、<c>locationIds</c>、<c>appliedLocationIds</c> 可传 <c>ALL</c> 哨兵归档为对应维度 ALL。
    /// </summary>
    [UnitOfWork]
    public async Task<LabelTemplateGetOutputDto> CreateAsync(LabelTemplateCreateInputVo input)
    {
        var code = input.TemplateCode?.Trim();
        var name = input.TemplateName?.Trim();
        if (string.IsNullOrWhiteSpace(code))
        {
            throw new UserFriendlyException("模板编码不能为空");
        }
        if (string.IsNullOrWhiteSpace(name))
        {
            throw new UserFriendlyException("模板名称不能为空");
        }

        var duplicated = await _dbContext.SqlSugarClient.Queryable<FlLabelTemplateDbEntity>()
            .AnyAsync(x => !x.IsDeleted && x.TemplateCode == code);
        if (duplicated)
        {
            throw new UserFriendlyException("模板编码已存在");
        }

        await PurgeSoftDeletedTemplatesByCodeAsync(code);

        var scope = await LabelTemplateScopeHelper.ResolveScopeForSaveAsync(_dbContext.SqlSugarClient, input);
        LabelTemplatePrintOrientationHelper.EnsureValidOrThrow(input.PrintOrientation);
        var printOrientation = LabelTemplatePrintOrientationHelper.Normalize(input.PrintOrientation);
        var contents = LabelTemplateContentsHelper.ResolveForSave(input.Contents, input.Elements);

        var now = DateTime.Now;
        var templateId = _guidGenerator.Create().ToString();
        var entity = new FlLabelTemplateDbEntity
        {
            Id = templateId,
            IsDeleted = false,
            CreationTime = now,
            CreatorId = CurrentUser?.Id?.ToString(),
            LastModifierId = CurrentUser?.Id?.ToString(),
            LastModificationTime = now,
            ConcurrencyStamp = string.Empty,
            TemplateCode = code,
            TemplateName = name,
            LabelType = input.LabelType,
            Unit = string.IsNullOrWhiteSpace(input.Unit) ? "inch" : input.Unit.Trim(),
            Width = input.Width,
            Height = input.Height,
            PrintOrientation = printOrientation,
            AppliedLocationType = scope.AppliedLocationType,
            ShowRuler = input.ShowRuler,
            ShowGrid = input.ShowGrid,
            VersionNo = 1,
            State = input.State
        };

        await _dbContext.SqlSugarClient.Insertable(entity).ExecuteCommandAsync();
        await LabelTemplateScopeSchemaHelper.SetBorderTypeAsync(
            _dbContext.SqlSugarClient,
            entity.Id,
            NormalizeTemplateBorderType(input.BorderType));

        await RebuildTemplateElementsAndDefaultsAsync(
            entity.Id,
            input.Elements,
            new List<LabelTemplateProductDefaultDto>());

        await PersistTemplateContentsAsync(entity.Id, contents);

        await LabelTemplateScopeHelper.SaveTemplateScopeAsync(
            _dbContext.SqlSugarClient,
            _guidGenerator,
            entity.Id,
            scope,
            CurrentUser?.Id?.ToString(),
            now);

        return await GetAsync(code);
    }

    /// <summary>
    /// 编辑标签模板（版本号 +1）。适用范围经 <see cref="LabelTemplateScopeHelper.ResolveScopeForSaveAsync"/> 与
    /// <see cref="LabelTemplateScopeHelper.SaveTemplateScopeAsync"/> 落库（含主表 <c>AppliedLocationType</c> 及
    /// <c>AppliedPartnerType</c> / <c>AppliedRegionType</c>）；
    /// <c>regionIds</c>、<c>groupIds</c>、<c>locationIds</c>、<c>appliedLocationIds</c> 可传 <c>ALL</c>，与 GET 回显对称。
    /// </summary>
    [UnitOfWork]
    public async Task<LabelTemplateGetOutputDto> UpdateAsync(string id, LabelTemplateUpdateInputVo input)
    {
        var template = await LabelTemplateQueryHelper.QueryProjected(_dbContext.SqlSugarClient)
            .FirstAsync(x => !x.IsDeleted && x.TemplateCode == id);
        if (template is null)
        {
            throw new UserFriendlyException("模板不存在");
        }

        var code = input.TemplateCode?.Trim();
        var name = input.TemplateName?.Trim();
        if (!string.IsNullOrWhiteSpace(code) && !string.Equals(code, template.TemplateCode, StringComparison.OrdinalIgnoreCase))
        {
            var duplicated = await _dbContext.SqlSugarClient.Queryable<FlLabelTemplateDbEntity>()
                .AnyAsync(x => !x.IsDeleted && x.TemplateCode == code);
            if (duplicated)
            {
                throw new UserFriendlyException("模板编码已存在");
            }
        }

        var scope = await LabelTemplateScopeHelper.ResolveScopeForSaveAsync(_dbContext.SqlSugarClient, input);
        LabelTemplatePrintOrientationHelper.EnsureValidOrThrow(input.PrintOrientation);
        var printOrientation = string.IsNullOrWhiteSpace(input.PrintOrientation)
            ? LabelTemplatePrintOrientationHelper.Normalize(template.PrintOrientation)
            : LabelTemplatePrintOrientationHelper.Normalize(input.PrintOrientation);
        var contents = LabelTemplateContentsHelper.ResolveForSave(input.Contents, input.Elements);

        template.TemplateName = name ?? template.TemplateName;
        template.LabelType = input.LabelType;
        template.Unit = string.IsNullOrWhiteSpace(input.Unit) ? template.Unit : input.Unit.Trim();
        template.Width = input.Width;
        template.Height = input.Height;
        template.PrintOrientation = printOrientation;
        template.AppliedLocationType = scope.AppliedLocationType;
        template.ShowRuler = input.ShowRuler;
        template.ShowGrid = input.ShowGrid;
        template.State = input.State;
        template.VersionNo = template.VersionNo + 1;
        template.LastModifierId = CurrentUser?.Id?.ToString();
        template.LastModificationTime = DateTime.Now;
        if (!string.IsNullOrWhiteSpace(code))
        {
            template.TemplateCode = code;
        }

        await _dbContext.SqlSugarClient.Updateable(template).ExecuteCommandAsync();
        // 强制落库 PrintOrientation（避免 ORM 元数据未刷新时 UPDATE 漏写该列）
        await _dbContext.SqlSugarClient.Updateable<FlLabelTemplateDbEntity>()
            .SetColumns(it => it.PrintOrientation == printOrientation)
            .Where(it => it.Id == template.Id)
            .ExecuteCommandAsync();

        await RebuildTemplateElementsAndDefaultsAsync(
            template.Id,
            input.Elements,
            input.TemplateProductDefaults);

        await PersistTemplateContentsAsync(template.Id, contents);

        await LabelTemplateScopeHelper.SaveTemplateScopeAsync(
            _dbContext.SqlSugarClient,
            _guidGenerator,
            template.Id,
            scope,
            CurrentUser?.Id?.ToString(),
            template.LastModificationTime ?? DateTime.Now);
        await LabelTemplateScopeSchemaHelper.SetBorderTypeAsync(
            _dbContext.SqlSugarClient,
            template.Id,
            NormalizeTemplateBorderType(input.BorderType));

        return await GetAsync(template.TemplateCode);
    }

    [UnitOfWork]
    public async Task DeleteAsync(string id)
    {
        var template = await LabelTemplateQueryHelper.QueryProjected(_dbContext.SqlSugarClient)
            .FirstAsync(x => !x.IsDeleted && x.TemplateCode == id);
        if (template is null)
        {
            return;
        }

        var used = await _dbContext.SqlSugarClient.Queryable<FlLabelDbEntity>()
            .AnyAsync(x => !x.IsDeleted && x.TemplateId == template.Id);

        if (used)
        {
            throw new UserFriendlyException("该模板已被标签引用，无法删除");
        }

        template.IsDeleted = true;
        template.LastModifierId = CurrentUser?.Id?.ToString();
        template.LastModificationTime = DateTime.Now;
        await _dbContext.SqlSugarClient.Updateable(template).ExecuteCommandAsync();

        // 删除子表数据（子表无 IsDeleted 字段）
        await _dbContext.SqlSugarClient.Deleteable<FlLabelTemplateElementDbEntity>()
            .Where(x => x.TemplateId == template.Id)
            .ExecuteCommandAsync();
        await LabelTemplateScopeHelper.DeleteTemplateScopeChildRowsAsync(
            _dbContext.SqlSugarClient, template.Id);
        await _dbContext.SqlSugarClient.Deleteable<FlLabelTemplateProductDefaultDbEntity>()
            .Where(x => x.TemplateId == template.Id)
            .ExecuteCommandAsync();
    }

    private async Task RebuildTemplateElementsAndDefaultsAsync(
        string templateDbId,
        List<LabelTemplateElementDto> elements,
        List<LabelTemplateProductDefaultDto>? templateProductDefaults)
    {
        // elements 重建
        await _dbContext.SqlSugarClient.Deleteable<FlLabelTemplateElementDbEntity>()
            .Where(x => x.TemplateId == templateDbId)
            .ExecuteCommandAsync();

        if (elements is not null && elements.Count > 0)
        {
            var rows = elements.Select(e =>
            {
                var elementName = EnsureElementName(e.ElementName);
                object? cfg = e.ConfigJson;
                var configJson = cfg == null ? null : JsonSerializer.Serialize(cfg);
                return new FlLabelTemplateElementDbEntity
                {
                    Id = _guidGenerator.Create().ToString(),
                    TemplateId = templateDbId,
                    ElementKey = e.Id,
                    ElementType = e.ElementType,
                    TypeAdd = string.IsNullOrWhiteSpace(e.TypeAdd) ? null : e.TypeAdd.Trim(),
                    ElementName = elementName,
                    PosX = e.PosX,
                    PosY = e.PosY,
                    Width = e.Width,
                    Height = e.Height,
                    Rotation = string.IsNullOrWhiteSpace(e.Rotation) ? "horizontal" : e.Rotation,
                    BorderType = string.IsNullOrWhiteSpace(e.BorderType) ? "none" : e.BorderType,
                    ZIndex = e.ZIndex,
                    OrderNum = e.OrderNum,
                    ValueSourceType = string.IsNullOrWhiteSpace(e.ValueSourceType) ? "FIXED" : e.ValueSourceType,
                    BindingExpr = e.BindingExpr,
                    AutoQueryKey = e.AutoQueryKey,
                    InputKey = e.InputKey,
                    IsRequiredInput = e.IsRequiredInput,
                    ConfigJson = configJson
                };
            }).ToList();

            await _dbContext.SqlSugarClient.Insertable(rows).ExecuteCommandAsync();
        }

        // 模板-产品-标签类型默认值：仅在显式传入时重建，避免普通编辑误清空
        if (templateProductDefaults is not null)
        {
            var duplicateCheckSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            foreach (var row in templateProductDefaults)
            {
                var productId = row.ProductId?.Trim();
                var labelTypeId = row.LabelTypeId?.Trim();
                if (string.IsNullOrWhiteSpace(productId) || string.IsNullOrWhiteSpace(labelTypeId))
                {
                    continue;
                }

                var key = $"{productId}::{labelTypeId}";
                if (!duplicateCheckSet.Add(key))
                {
                    throw new UserFriendlyException($"模板默认值绑定重复：产品[{productId}]与标签类型[{labelTypeId}]只能存在一条");
                }
            }

            await _dbContext.SqlSugarClient.Deleteable<FlLabelTemplateProductDefaultDbEntity>()
                .Where(x => x.TemplateId == templateDbId)
                .ExecuteCommandAsync();

            if (templateProductDefaults.Count > 0)
            {
                var rows = templateProductDefaults.Select((x, idx) =>
                {
                    var productId = x.ProductId?.Trim();
                    var labelTypeId = x.LabelTypeId?.Trim();
                    if (string.IsNullOrWhiteSpace(productId))
                    {
                        throw new UserFriendlyException("模板默认值绑定中，产品Id不能为空");
                    }

                    if (string.IsNullOrWhiteSpace(labelTypeId))
                    {
                        throw new UserFriendlyException("模板默认值绑定中，标签类型Id不能为空");
                    }

                    var json = x.DefaultValues is null ? null : JsonSerializer.Serialize(x.DefaultValues);
                    return new FlLabelTemplateProductDefaultDbEntity
                    {
                        Id = _guidGenerator.Create().ToString(),
                        TemplateId = templateDbId,
                        ProductId = productId,
                        LabelTypeId = labelTypeId,
                        DefaultValuesJson = json,
                        OrderNum = x.OrderNum <= 0 ? idx + 1 : x.OrderNum
                    };
                }).ToList();

                await _dbContext.SqlSugarClient.Insertable(rows).ExecuteCommandAsync();
            }
        }
    }

    private const string EmptyDisplay = FoodLabelingDisplayConsts.NotAvailable;

    private async Task FillTemplateScopeOnDtoAsync(LabelTemplateGetOutputDto dto, FlLabelTemplateDbEntity template)
    {
        var scopeMap = await LabelTemplateScopeHelper.BuildScopeDisplayMapAsync(
            _dbContext.SqlSugarClient, new List<FlLabelTemplateDbEntity> { template });
        scopeMap.TryGetValue(template.Id, out var scope);

        dto.Company = scope?.Company ?? string.Empty;
        dto.Region = scope?.Region ?? string.Empty;
        dto.Location = scope?.Location ?? string.Empty;
        dto.AppliedPartnerType = scope?.AppliedPartnerType ?? LabelTemplateScopeHelper.ScopeAll;
        dto.AppliedRegionType = scope?.AppliedRegionType ?? LabelTemplateScopeHelper.ScopeAll;
        dto.AppliedLocationType = scope?.AppliedLocationType ?? template.AppliedLocationType;
        dto.PartnerIds = scope?.PartnerIds ?? new List<string>();
        dto.CompanyIds = scope?.PartnerIds ?? new List<string>();
        dto.RegionIds = scope?.RegionIds ?? new List<string>();
        dto.GroupIds = scope?.RegionIds ?? new List<string>();
        dto.LocationIds = scope?.LocationIds ?? new List<string>();
        dto.AppliedLocationIds = dto.LocationIds;
    }

    /// <summary>模板编码唯一键不区分软删：同编码软删行会挡住新建，创建前物理清理关联与主表。</summary>
    private async Task PurgeSoftDeletedTemplatesByCodeAsync(string templateCode)
    {
        var softDeleted = await _dbContext.SqlSugarClient.Queryable<FlLabelTemplateDbEntity>()
            .Where(x => x.IsDeleted && x.TemplateCode == templateCode)
            .ToListAsync();
        if (softDeleted.Count == 0)
        {
            return;
        }

        foreach (var row in softDeleted)
        {
            await _dbContext.SqlSugarClient.Deleteable<FlLabelTemplatePartnerDbEntity>()
                .Where(x => x.TemplateId == row.Id)
                .ExecuteCommandAsync();
            await _dbContext.SqlSugarClient.Deleteable<FlLabelTemplateRegionDbEntity>()
                .Where(x => x.TemplateId == row.Id)
                .ExecuteCommandAsync();
            await _dbContext.SqlSugarClient.Deleteable<FlLabelTemplateLocationDbEntity>()
                .Where(x => x.TemplateId == row.Id)
                .ExecuteCommandAsync();
            await _dbContext.SqlSugarClient.Deleteable<FlLabelTemplateElementDbEntity>()
                .Where(x => x.TemplateId == row.Id)
                .ExecuteCommandAsync();
            await _dbContext.SqlSugarClient.Deleteable<FlLabelTemplateProductDefaultDbEntity>()
                .Where(x => x.TemplateId == row.Id)
                .ExecuteCommandAsync();
            await _dbContext.SqlSugarClient.Deleteable<FlLabelTemplateDbEntity>()
                .Where(x => x.Id == row.Id)
                .ExecuteCommandAsync();
        }
    }

    /// <summary>落库 Contents（列未迁移时 no-op）。</summary>
    private Task PersistTemplateContentsAsync(string templateDbId, string contents) =>
        LabelTemplateScopeSchemaHelper.SetContentsAsync(_dbContext.SqlSugarClient, templateDbId, contents);

    private static string EnsureElementName(string? elementName)
    {
        var normalizedName = elementName?.Trim();
        if (string.IsNullOrWhiteSpace(normalizedName))
        {
            throw new UserFriendlyException("组件名字不能为空");
        }

        return normalizedName;
    }

    private static PagedResultWithPageDto<T> BuildPagedResult<T>(int skipCount, int maxResultCount, int total, List<T> items)
    {
        var pageSize = maxResultCount <= 0 ? items.Count : maxResultCount;
        var pageIndex = pageSize <= 0 ? 1 : PagedQueryConvention.PageIndexFromSkipCount(skipCount);
        var totalPages = pageSize <= 0 ? 0 : (int)Math.Ceiling(total / (double)pageSize);
        return new PagedResultWithPageDto<T>
        {
            PageIndex = pageIndex,
            PageSize = pageSize,
            TotalCount = total,
            TotalPages = totalPages,
            Items = items
        };
    }

    private static PagedResultWithPageDto<T> BuildPagedResult<T>(int skipCount, int maxResultCount, RefAsync<int> total, List<T> items)
    {
        var pageSize = maxResultCount <= 0 ? items.Count : maxResultCount;
        var pageIndex = pageSize <= 0 ? 1 : PagedQueryConvention.PageIndexFromSkipCount(skipCount);
        var totalPages = pageSize <= 0 ? 0 : (int)Math.Ceiling(total.Value / (double)pageSize);
        return new PagedResultWithPageDto<T>
        {
            PageIndex = pageIndex,
            PageSize = pageSize,
            TotalCount = total.Value,
            TotalPages = totalPages,
            Items = items
        };
    }

    private static string NormalizeTemplateBorderType(string? raw)
    {
        var v = (raw ?? string.Empty).Trim().ToLowerInvariant();
        return v is "line" or "dotted" ? v : "none";
    }
}