using System.IO;
using FoodLabeling.Application.Contracts.Dtos.Common;
using FoodLabeling.Application.Contracts.Dtos.TeamMember;
using FoodLabeling.Application.Contracts.IServices;
using FoodLabeling.Application.Helpers;
using FoodLabeling.Application.Options;
using FoodLabeling.Application.Services.DbModels;
using FoodLabeling.Domain.Entities;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;
using SqlSugar;
using Volo.Abp;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Entities;
using Volo.Abp.Guids;
using Yi.Framework.Rbac.Domain.Entities;
using Yi.Framework.Rbac.Domain.Entities.ValueObjects;
using Yi.Framework.Rbac.Domain.Helpers;
using Yi.Framework.Rbac.Domain.Managers;
using Yi.Framework.SqlSugarCore.Abstractions;

namespace FoodLabeling.Application.Services;

/// <summary>
/// 成员（Team Member）服务，对外仅在 food-labeling-us 暴露
/// </summary>
public class TeamMemberAppService : ApplicationService, ITeamMemberAppService
{
    private readonly ISqlSugarRepository<UserAggregateRoot, Guid> _userRepository;
    private readonly UserManager _userManager;
    private readonly ISqlSugarDbContext _dbContext;
    private readonly IGuidGenerator _guidGenerator;
    private readonly IOptionsSnapshot<FoodLabelingBatchImportOptions> _batchImportOptions;

    public TeamMemberAppService(
        ISqlSugarRepository<UserAggregateRoot, Guid> userRepository,
        UserManager userManager,
        ISqlSugarDbContext dbContext,
        IGuidGenerator guidGenerator,
        IOptionsSnapshot<FoodLabelingBatchImportOptions> batchImportOptions)
    {
        _userRepository = userRepository;
        _userManager = userManager;
        _dbContext = dbContext;
        _guidGenerator = guidGenerator;
        _batchImportOptions = batchImportOptions;
    }

    /// <inheritdoc />
    public async Task<PagedResultWithPageDto<TeamMemberGetListOutputDto>> GetListAsync(TeamMemberGetListInputVo input)
    {
        var pageIndex = PagedQueryConvention.PageIndexFromSkipCount(input.SkipCount);
        var pageSize = input.MaxResultCount;
        RefAsync<int> total = 0;

        var scopeLocationIds = await LocationScopeBindingHelper.ResolveFilteredLocationIdsForListAsync(
            _dbContext.SqlSugarClient, input.PartnerId, input.GroupId, input.LocationId);

        var query = await BuildFilteredUserQueryAsync(input, scopeLocationIds);
        var users = await query
            .OrderByIF(!string.IsNullOrWhiteSpace(input.Sorting), input.Sorting!)
            .OrderByDescending(u => u.CreationTime)
            .ToPageListAsync(input.SkipCount, input.MaxResultCount, total);

        var items = await MapUsersToOutputAsync(
            users,
            scopeLocationIds,
            restrictAssignedLocationsToFilter: scopeLocationIds is not null);

        var totalCount = (long)total;
        return new PagedResultWithPageDto<TeamMemberGetListOutputDto>
        {
            PageIndex = pageIndex,
            PageSize = pageSize,
            TotalCount = totalCount,
            TotalPages = (int)Math.Ceiling(totalCount / (double)pageSize),
            Items = items
        };
    }

    /// <inheritdoc />
    public async Task<TeamMemberGetOutputDto> GetAsync(Guid id)
    {
        var user = await _userRepository.GetByIdAsync(id);
        if (user is null || user.IsDeleted)
        {
            throw new UserFriendlyException("成员不存在");
        }

        var userIdString = id.ToString();
        var links = await _dbContext.SqlSugarClient.Queryable<UserLocationDbEntity>()
            .Where(x => !x.IsDeleted && x.UserId == userIdString)
            .ToListAsync();

        var locationIds = links.Select(x => x.LocationId).Distinct().ToList();
        var locations = await _dbContext.SqlSugarClient.Queryable<LocationAggregateRoot>()
            .Where(x => !x.IsDeleted)
            .WhereIF(locationIds.Count > 0, x => locationIds.Contains(x.Id.ToString()))
            .Select(x => new { x.Id, x.LocationCode, x.LocationName })
            .ToListAsync();

        var assigned = locations.Select(x => new TeamMemberAssignedLocationDto
        {
            Id = x.Id.ToString(),
            LocationCode = x.LocationCode,
            LocationName = x.LocationName
        }).ToList();

        var role = await _dbContext.SqlSugarClient.Queryable<UserRoleEntity>().FirstAsync(x => x.UserId == id);

        var partnerIds = await LocationScopeBindingHelper.ResolvePartnerIdsFromLocationIdsAsync(
            _dbContext.SqlSugarClient, locationIds);
        var regionIds = await LocationScopeBindingHelper.ResolveGroupIdsFromLocationIdsAsync(
            _dbContext.SqlSugarClient, locationIds);

        return new TeamMemberGetOutputDto
        {
            Id = user.Id,
            FullName = user.Name ?? string.Empty,
            UserName = user.UserName,
            Email = user.Email,
            Phone = user.Phone,
            State = user.State,
            RoleId = role?.RoleId,
            PartnerIds = partnerIds,
            RegionIds = regionIds,
            GroupIds = regionIds,
            LocationIds = locationIds,
            AssignedLocations = assigned
        };
    }

    /// <inheritdoc />
    public async Task<TeamMemberGetOutputDto> CreateAsync(TeamMemberCreateInputVo input)
    {
        var mergedLocationIds = await ResolveTeamMemberLocationIdsForSaveAsync(input);

        var user = new UserAggregateRoot
        {
            UserName = input.UserName.Trim(),
            Name = input.FullName.Trim(),
            Nick = input.FullName.Trim(),
            Email = input.Email?.Trim(),
            Phone = input.Phone,
            State = input.State,
            EncryPassword = new EncryPasswordValueObject(input.Password.Trim())
        };

        EntityHelper.TrySetId(user, _guidGenerator.Create);
        user.BuildPassword();

        await _userManager.CreateAsync(user);

        if (input.RoleId != null)
        {
            await _userManager.GiveUserSetRoleAsync(new List<Guid> { user.Id }, new List<Guid> { input.RoleId.Value });
        }

        await UpsertUserLocationsAsync(user.Id, mergedLocationIds);

        return await GetAsync(user.Id);
    }

    /// <inheritdoc />
    public async Task<TeamMemberGetOutputDto> UpdateAsync(Guid id, TeamMemberUpdateInputVo input)
    {
        var mergedLocationIds = await ResolveTeamMemberLocationIdsForSaveAsync(input);

        var user = await _userRepository.GetByIdAsync(id);
        if (user is null || user.IsDeleted)
        {
            throw new UserFriendlyException("成员不存在");
        }

        user.Name = input.FullName.Trim();
        user.UserName = input.UserName.Trim();
        user.Email = input.Email?.Trim();
        user.Phone = input.Phone;
        user.State = input.State;

        var passwordChanged = false;
        if (!string.IsNullOrWhiteSpace(input.Password))
        {
            UserPasswordHelper.ApplyPlainPassword(user, input.Password);
            passwordChanged = true;
        }

        await _userRepository.UpdateAsync(user);
        if (passwordChanged)
        {
            await UserPasswordHelper.EnsurePasswordColumnsPersistedAsync(
                _userRepository,
                user.Id,
                user.EncryPassword.Password,
                user.EncryPassword.Salt);
        }

        if (input.RoleId != null)
        {
            await _userManager.GiveUserSetRoleAsync(new List<Guid> { id }, new List<Guid> { input.RoleId.Value });
        }
        else
        {
            await _userManager.GiveUserSetRoleAsync(new List<Guid> { id }, new List<Guid>());
        }

        await UpsertUserLocationsAsync(id, mergedLocationIds);

        return await GetAsync(id);
    }

    /// <inheritdoc />
    public async Task DeleteAsync(Guid id)
    {
        var user = await _userRepository.GetByIdAsync(id);
        if (user is null || user.IsDeleted)
        {
            return;
        }

        user.IsDeleted = true;
        await _userRepository.UpdateAsync(user);

        var userIdString = id.ToString();
        var currentUserId = CurrentUser?.Id?.ToString();
        await _dbContext.SqlSugarClient.Updateable<UserLocationDbEntity>()
            .SetColumns(x => new UserLocationDbEntity
            {
                IsDeleted = true,
                LastModificationTime = DateTime.Now,
                LastModifierId = currentUserId
            })
            .Where(x => x.UserId == userIdString && !x.IsDeleted)
            .ExecuteCommandAsync();
    }

    /// <inheritdoc />
    public Task<IActionResult> DownloadTeamMemberImportTemplateAsync()
    {
        var opt = _batchImportOptions.Value;
        var dir = opt.TemplateDirectory?.Trim();
        if (string.IsNullOrWhiteSpace(dir))
        {
            throw new UserFriendlyException("未配置批量导入模板目录 FoodLabeling:BatchImport:TemplateDirectory");
        }

        var fileName = opt.TeamMemberTemplateFileName?.Trim();
        if (string.IsNullOrWhiteSpace(fileName))
        {
            throw new UserFriendlyException("未配置模板文件名 FoodLabeling:BatchImport:TeamMemberTemplateFileName");
        }

        var fullPath = Path.Combine(dir, fileName);
        if (!File.Exists(fullPath))
        {
            throw new UserFriendlyException($"模板文件不存在：{fullPath}");
        }

        var stream = new FileStream(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read);
        const string contentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
        return Task.FromResult<IActionResult>(new FileStreamResult(stream, contentType)
        {
            FileDownloadName = fileName
        });
    }

    /// <inheritdoc />
    public async Task<IActionResult> ExportTeamMembersPdfAsync([FromQuery] TeamMemberGetListInputVo input)
    {
        QuestPDF.Settings.License = LicenseType.Community;

        var scopeLocationIds = await LocationScopeBindingHelper.ResolveFilteredLocationIdsForListAsync(
            _dbContext.SqlSugarClient, input.PartnerId, input.GroupId, input.LocationId);

        var query = await BuildFilteredUserQueryAsync(input, scopeLocationIds);
        var users = await query
            .OrderByIF(!string.IsNullOrWhiteSpace(input.Sorting), input.Sorting!)
            .OrderByDescending(u => u.CreationTime)
            .ToListAsync();

        var rows = await MapUsersToOutputAsync(
            users,
            scopeLocationIds,
            restrictAssignedLocationsToFilter: scopeLocationIds is not null);

        var fileName = $"team-members_{Clock.Now:yyyy-MM-dd_HH-mm-ss}.pdf";
        var document = Document.Create(container =>
        {
            container.Page(page =>
            {
                page.Margin(22);
                page.DefaultTextStyle(x => x.FontSize(8));
                page.Header().Text("Team Members").SemiBold().FontSize(16);
                page.Content().PaddingTop(8).Table(table =>
                {
                    table.ColumnsDefinition(c =>
                    {
                        c.RelativeColumn(1.4f);
                        c.RelativeColumn(1.6f);
                        c.RelativeColumn(1.1f);
                        c.RelativeColumn(1.1f);
                        c.RelativeColumn(2.2f);
                        c.RelativeColumn(0.7f);
                    });

                    static IContainer CellHeader(IContainer c) =>
                        c.Background(Colors.Grey.Lighten3).Padding(4).DefaultTextStyle(x => x.SemiBold());

                    table.Cell().Element(CellHeader).Text("Name");
                    table.Cell().Element(CellHeader).Text("Email");
                    table.Cell().Element(CellHeader).Text("Phone");
                    table.Cell().Element(CellHeader).Text("Role");
                    table.Cell().Element(CellHeader).Text("Assigned Locations");
                    table.Cell().Element(CellHeader).Text("Status");

                    foreach (var e in rows)
                    {
                        var locText = e.AssignedLocations.Count == 0
                            ? "无"
                            : string.Join("; ",
                                e.AssignedLocations.Select(a =>
                                    $"{a.LocationCode} - {a.LocationName}"));
                        var status = e.State ? "Active" : "Inactive";
                        table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)
                            .Text(e.FullName ?? string.Empty);
                        table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)
                            .Text(e.Email ?? "无");
                        table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)
                            .Text(e.Phone?.ToString() ?? "无");
                        table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)
                            .Text(string.IsNullOrWhiteSpace(e.RoleName) ? "无" : e.RoleName);
                        table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)
                            .Text(locText);
                        table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)
                            .Text(status);
                    }
                });
            });
        });

        var stream = new MemoryStream();
        document.GeneratePdf(stream);
        stream.Position = 0;
        return new FileStreamResult(stream, "application/pdf") { FileDownloadName = fileName };
    }

    /// <inheritdoc />
    public async Task<TeamMemberBatchImportResultDto> ImportTeamMembersBatchAsync(
        [FromForm] TeamMemberBatchImportInputVo input)
    {
        if (input?.File is null || input.File.Length == 0)
        {
            throw new UserFriendlyException("请上传 Excel 文件（form 字段名：file）");
        }

        var opt = _batchImportOptions.Value;
        if (input.File.Length > opt.MaxUploadBytes)
        {
            throw new UserFriendlyException($"文件过大，最大允许 {opt.MaxUploadBytes / 1024 / 1024} MB");
        }

        var ext = Path.GetExtension(input.File.FileName)?.ToLowerInvariant();
        if (ext != ".xlsx")
        {
            throw new UserFriendlyException("仅支持 .xlsx 格式的 Excel 文件");
        }

        var roleMap = await BuildRoleNameToIdMapAsync();
        await using var uploadStream = input.File.OpenReadStream();
        var parseErrors = new List<TeamMemberBatchImportErrorDto>();
        var rows = TeamMemberBatchExcelHelper.ParseImportWorkbook(
            uploadStream,
            opt.MaxImportRows <= 0 ? 5000 : opt.MaxImportRows,
            roleMap,
            opt.TeamMemberImportDefaultPassword?.Trim() ?? string.Empty,
            out var headerErrors);
        parseErrors.AddRange(headerErrors);

        var result = new TeamMemberBatchImportResultDto();
        if (rows.Count == 0 && parseErrors.Count > 0)
        {
            result.Errors = parseErrors;
            result.FailCount = parseErrors.Count;
            return result;
        }

        foreach (var (rowNum, vo) in rows)
        {
            try
            {
                vo.LocationIds = await ResolveLocationIdsFromImportTokensAsync(vo.LocationIds);
                await CreateAsync(vo);
                result.SuccessCount++;
            }
            catch (UserFriendlyException ex)
            {
                result.FailCount++;
                result.Errors.Add(new TeamMemberBatchImportErrorDto
                {
                    RowNumber = rowNum,
                    UserName = vo.UserName,
                    Message = ex.Message
                });
            }
        }

        result.Errors.InsertRange(0, parseErrors);
        return result;
    }

    /// <inheritdoc />
    public async Task<TeamMemberBulkUpdateResultDto> UpdateTeamMembersBulkAsync(
        [FromBody] TeamMemberBulkUpdateInputVo input)
    {
        if (input?.Items is null || input.Items.Count == 0)
        {
            throw new UserFriendlyException("请至少提交一条编辑数据（items 不能为空）");
        }

        var opt = _batchImportOptions.Value;
        var maxItems = opt.MaxBulkUpdateItems <= 0 ? 500 : opt.MaxBulkUpdateItems;
        if (input.Items.Count > maxItems)
        {
            throw new UserFriendlyException($"单次批量编辑最多允许 {maxItems} 条，请分批提交");
        }

        var effectiveCount = input.Items.Count(static x => x is not null && x.Id != Guid.Empty);
        if (effectiveCount == 0)
        {
            throw new UserFriendlyException("没有有效的成员 Id（请为待保存行填写 id）");
        }

        var result = new TeamMemberBulkUpdateResultDto();
        for (var i = 0; i < input.Items.Count; i++)
        {
            var item = input.Items[i];
            if (item is null || item.Id == Guid.Empty)
            {
                continue;
            }

            try
            {
                await UpdateAsync(item.Id, item);
                result.SuccessCount++;
            }
            catch (UserFriendlyException ex)
            {
                result.FailCount++;
                result.Errors.Add(new TeamMemberBulkUpdateErrorDto
                {
                    RowNumber = i + 1,
                    Id = item.Id,
                    Message = ex.Message
                });
            }
        }

        return result;
    }

    private async Task<Dictionary<string, Guid>> BuildRoleNameToIdMapAsync()
    {
        var roles = await _dbContext.SqlSugarClient.Queryable<RoleAggregateRoot>()
            .Where(r => !r.IsDeleted)
            .Select(r => new { r.Id, r.RoleName })
            .ToListAsync();

        return roles
            .Where(r => !string.IsNullOrWhiteSpace(r.RoleName))
            .GroupBy(r => TeamMemberBatchExcelHelper.NormalizeRoleKey(r.RoleName!))
            .ToDictionary(g => g.Key, g => g.First().Id);
    }

    private async Task<List<string>> ResolveLocationIdsFromImportTokensAsync(List<string> tokens)
    {
        var result = new List<string>();
        foreach (var raw in tokens)
        {
            var s = raw.Trim();
            if (string.IsNullOrEmpty(s))
            {
                continue;
            }

            var idx = s.IndexOf(" -", StringComparison.Ordinal);
            var key = idx > 0 ? s[..idx].Trim() : s.Trim();
            if (Guid.TryParse(key, out var gid))
            {
                var byId = await _dbContext.SqlSugarClient.Queryable<LocationAggregateRoot>()
                    .Where(x => !x.IsDeleted && x.Id == gid)
                    .FirstAsync();
                if (byId is null)
                {
                    throw new UserFriendlyException($"无效门店 Id：{key}");
                }

                result.Add(byId.Id.ToString());
                continue;
            }

            var byCode = await _dbContext.SqlSugarClient.Queryable<LocationAggregateRoot>()
                .Where(x => !x.IsDeleted && x.LocationCode == key)
                .FirstAsync();
            if (byCode is null)
            {
                throw new UserFriendlyException($"未找到门店编码：{key}");
            }

            result.Add(byCode.Id.ToString());
        }

        return result.Distinct().ToList();
    }

    private async Task<ISugarQueryable<UserAggregateRoot>> BuildFilteredUserQueryAsync(
        TeamMemberGetListInputVo input,
        List<string>? scopeLocationIds)
    {
        var keyword = input.Keyword?.Trim();
        var query = _userRepository._DbQueryable
            .Where(u => !u.IsDeleted)
            .WhereIF(!string.IsNullOrWhiteSpace(keyword),
                u => (u.Name != null && u.Name.Contains(keyword!)) ||
                     u.UserName.Contains(keyword!) ||
                     (u.Email != null && u.Email.Contains(keyword!)) ||
                     (u.Phone != null && u.Phone.ToString()!.Contains(keyword!)))
            .WhereIF(input.State != null, u => u.State == input.State);

        if (input.RoleId != null)
        {
            var userIds = await _dbContext.SqlSugarClient.Queryable<UserRoleEntity>()
                .Where(ur => ur.RoleId == input.RoleId.Value)
                .Select(ur => ur.UserId)
                .ToListAsync();
            query = query.Where(u => userIds.Contains(u.Id));
        }

        if (scopeLocationIds is not null)
        {
            if (scopeLocationIds.Count == 0)
            {
                query = query.Where(_ => false);
            }
            else
            {
                var scopeSet = new HashSet<string>(scopeLocationIds, StringComparer.Ordinal);
                var userIdStrs = await _dbContext.SqlSugarClient.Queryable<UserLocationDbEntity>()
                    .Where(x => !x.IsDeleted && scopeSet.Contains(x.LocationId))
                    .Select(x => x.UserId)
                    .ToListAsync();
                var allowed = new HashSet<string>(userIdStrs);
                query = query.Where(u => allowed.Contains(u.Id.ToString()));
            }
        }

        return query;
    }

    private async Task<List<TeamMemberGetListOutputDto>> MapUsersToOutputAsync(
        List<UserAggregateRoot> users,
        List<string>? scopeLocationIds,
        bool restrictAssignedLocationsToFilter)
    {
        if (users.Count == 0)
        {
            return new List<TeamMemberGetListOutputDto>();
        }

        var userIds = users.Select(x => x.Id).ToList();
        var userIdStrings = userIds.Select(x => x.ToString()).ToList();

        var userRolePairs = await _dbContext.SqlSugarClient.Queryable<UserRoleEntity, RoleAggregateRoot>((ur, r) => ur.RoleId == r.Id)
            .Where(ur => userIds.Contains(ur.UserId))
            .Select((ur, r) => new { ur.UserId, r.Id, r.RoleName })
            .ToListAsync();

        var roleMap = userRolePairs
            .GroupBy(x => x.UserId)
            .ToDictionary(g => g.Key, g => g.FirstOrDefault());

        var userLocQuery = _dbContext.SqlSugarClient.Queryable<UserLocationDbEntity>()
            .Where(x => !x.IsDeleted)
            .Where(x => userIdStrings.Contains(x.UserId));
        if (restrictAssignedLocationsToFilter && scopeLocationIds is { Count: > 0 })
        {
            var scopeSet = new HashSet<string>(scopeLocationIds, StringComparer.Ordinal);
            userLocQuery = userLocQuery.Where(x => scopeSet.Contains(x.LocationId));
        }

        var userLocations = await userLocQuery.ToListAsync();

        var locationIds = userLocations.Select(x => x.LocationId).Distinct().ToList();
        var locations = await _dbContext.SqlSugarClient.Queryable<LocationAggregateRoot>()
            .Where(x => !x.IsDeleted)
            .WhereIF(locationIds.Count > 0, x => locationIds.Contains(x.Id.ToString()))
            .Select(x => new { x.Id, x.LocationCode, x.LocationName })
            .ToListAsync();
        var locationMap = locations.ToDictionary(x => x.Id.ToString(), x => x);

        var assignedMap = userLocations
            .GroupBy(x => x.UserId)
            .ToDictionary(
                g => g.Key,
                g => g.Select(x =>
                {
                    if (locationMap.TryGetValue(x.LocationId, out var loc))
                    {
                        return new TeamMemberAssignedLocationDto
                        {
                            Id = loc.Id.ToString(),
                            LocationCode = loc.LocationCode,
                            LocationName = loc.LocationName
                        };
                    }

                    return null;
                }).Where(x => x != null).Cast<TeamMemberAssignedLocationDto>().ToList());

        var scopeIdsMap = await BuildTeamMemberScopeIdsMapAsync(assignedMap);

        return users.Select(u =>
        {
            roleMap.TryGetValue(u.Id, out var role);
            assignedMap.TryGetValue(u.Id.ToString(), out var assigned);
            scopeIdsMap.TryGetValue(u.Id.ToString(), out var scopeIds);

            return new TeamMemberGetListOutputDto
            {
                Id = u.Id,
                FullName = u.Name ?? string.Empty,
                UserName = u.UserName,
                Email = u.Email,
                Phone = u.Phone,
                State = u.State,
                RoleId = role?.Id,
                RoleName = role?.RoleName,
                PartnerIds = scopeIds?.PartnerIds ?? new List<string>(),
                RegionIds = scopeIds?.RegionIds ?? new List<string>(),
                AssignedLocations = assigned ?? new List<TeamMemberAssignedLocationDto>()
            };
        }).ToList();
    }

    private async Task<Dictionary<string, TeamMemberScopeIds>> BuildTeamMemberScopeIdsMapAsync(
        Dictionary<string, List<TeamMemberAssignedLocationDto>> assignedMap)
    {
        var result = new Dictionary<string, TeamMemberScopeIds>(StringComparer.Ordinal);
        foreach (var (userId, assigned) in assignedMap)
        {
            var locationIds = assigned
                .Select(x => x.Id)
                .Where(x => !string.IsNullOrWhiteSpace(x))
                .Select(x => x.Trim())
                .Distinct(StringComparer.Ordinal)
                .ToList();
            if (locationIds.Count == 0)
            {
                result[userId] = new TeamMemberScopeIds();
                continue;
            }

            var partnerIds = await LocationScopeBindingHelper.ResolvePartnerIdsFromLocationIdsAsync(
                _dbContext.SqlSugarClient, locationIds);
            var regionIds = await LocationScopeBindingHelper.ResolveGroupIdsFromLocationIdsAsync(
                _dbContext.SqlSugarClient, locationIds);
            result[userId] = new TeamMemberScopeIds
            {
                PartnerIds = partnerIds,
                RegionIds = regionIds
            };
        }

        return result;
    }

    private sealed class TeamMemberScopeIds
    {
        public List<string> PartnerIds { get; init; } = new();
        public List<string> RegionIds { get; init; } = new();
    }

    private Task<List<string>> ResolveTeamMemberLocationIdsForSaveAsync(TeamMemberUpdateInputVo input) =>
        ResolveTeamMemberLocationIdsForSaveAsync(new TeamMemberCreateInputVo
        {
            PartnerId = input.PartnerId,
            PartnerIds = input.PartnerIds,
            RegionIds = input.RegionIds,
            GroupIds = input.GroupIds,
            LocationIds = input.LocationIds
        });

    private async Task<List<string>> ResolveTeamMemberLocationIdsForSaveAsync(TeamMemberCreateInputVo input)
    {
        var partnerIds = NormalizePartnerIds(input);
        var regionIds = NormalizeRegionIds(input);
        var merged = await LocationScopeBindingHelper.MergeToLocationIdsAsync(
            _dbContext.SqlSugarClient, partnerIds, regionIds, input.LocationIds);

        if (merged.Count == 0)
        {
            throw new UserFriendlyException("成员必须至少分配一个门店（公司/区域/门店至少选一项）");
        }

        await LocationScopeBindingHelper.ValidateLocationIdsExistAsync(_dbContext.SqlSugarClient, merged);
        return merged;
    }

    private static List<string> NormalizePartnerIds(TeamMemberCreateInputVo input)
    {
        var merged = new HashSet<string>(StringComparer.Ordinal);
        if (!string.IsNullOrWhiteSpace(input.PartnerId))
        {
            merged.Add(input.PartnerId.Trim());
        }

        foreach (var id in LocationScopeBindingHelper.NormalizeIds(input.PartnerIds))
        {
            merged.Add(id);
        }

        return merged.OrderBy(x => x, StringComparer.Ordinal).ToList();
    }

    private static List<string> NormalizeRegionIds(TeamMemberCreateInputVo input)
    {
        var merged = new HashSet<string>(StringComparer.Ordinal);
        foreach (var id in LocationScopeBindingHelper.NormalizeIds(input.RegionIds))
        {
            merged.Add(id);
        }

        foreach (var id in LocationScopeBindingHelper.NormalizeIds(input.GroupIds))
        {
            merged.Add(id);
        }

        return merged.OrderBy(x => x, StringComparer.Ordinal).ToList();
    }

    private async Task UpsertUserLocationsAsync(Guid userId, List<string> locationIds)
    {
        var now = DateTime.Now;
        var userIdString = userId.ToString();
        var wanted = locationIds.Where(x => !string.IsNullOrWhiteSpace(x)).Select(x => x.Trim()).Distinct().ToList();
        var currentUserId = CurrentUser?.Id?.ToString();

        var validCount = await _dbContext.SqlSugarClient.Queryable<LocationAggregateRoot>()
            .Where(x => !x.IsDeleted)
            .Where(x => wanted.Contains(x.Id.ToString()))
            .CountAsync();
        if (validCount != wanted.Count)
        {
            throw new UserFriendlyException("存在无效门店，请刷新后重试");
        }

        var existing = await _dbContext.SqlSugarClient.Queryable<UserLocationDbEntity>()
            .Where(x => x.UserId == userIdString)
            .ToListAsync();

        var existingActive = existing.Where(x => !x.IsDeleted).ToList();
        var existingActiveSet = existingActive.Select(x => x.LocationId).ToHashSet();

        var toDelete = existingActive.Where(x => !wanted.Contains(x.LocationId)).ToList();
        if (toDelete.Count > 0)
        {
            var ids = toDelete.Select(x => x.Id).ToList();
            await _dbContext.SqlSugarClient.Updateable<UserLocationDbEntity>()
                .SetColumns(x => new UserLocationDbEntity
                {
                    IsDeleted = true,
                    LastModificationTime = now,
                    LastModifierId = currentUserId
                })
                .Where(x => ids.Contains(x.Id))
                .ExecuteCommandAsync();
        }

        var toInsert = wanted.Where(x => !existingActiveSet.Contains(x)).ToList();
        if (toInsert.Count > 0)
        {
            var rows = toInsert.Select(locationId => new UserLocationDbEntity
            {
                Id = _guidGenerator.Create().ToString(),
                IsDeleted = false,
                CreationTime = now,
                CreatorId = currentUserId,
                UserId = userIdString,
                LocationId = locationId,
                ConcurrencyStamp = string.Empty
            }).ToList();

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