王明 / Food-Labeling-Management-Platform

using System.IO;
using FoodLabeling.Application.Helpers;
using FoodLabeling.Application.Contracts.Dtos.Location;
using FoodLabeling.Application.Contracts.Dtos.Common;
using FoodLabeling.Application.Contracts.IServices;
using FoodLabeling.Application.Options;
using FoodLabeling.Domain.Entities;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using SqlSugar;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
using Yi.Framework.SqlSugarCore.Abstractions;

namespace FoodLabeling.Application.Services;

/// <summary>
/// 门店管理服务（美国版）
/// </summary>
public class LocationAppService : ApplicationService, ILocationAppService
{
    private readonly ISqlSugarRepository<LocationAggregateRoot, Guid> _locationRepository;
    private readonly ISqlSugarDbContext _dbContext;
    private readonly IOptionsSnapshot<FoodLabelingBatchImportOptions> _batchImportOptions;

    public LocationAppService(
        ISqlSugarRepository<LocationAggregateRoot, Guid> locationRepository,
        ISqlSugarDbContext dbContext,
        IOptionsSnapshot<FoodLabelingBatchImportOptions> batchImportOptions)
    {
        _locationRepository = locationRepository;
        _dbContext = dbContext;
        _batchImportOptions = batchImportOptions;
    }

    /// <inheritdoc />
    public async Task<PagedResultWithPageDto<LocationGetListOutputDto>> GetListAsync([FromQuery] LocationGetListInputVo input)
    {
        RefAsync<int> total = 0;

        var query = await BuildFilteredQueryAsync(input);
        if (!string.IsNullOrWhiteSpace(input.Sorting))
        {
            query = query.OrderBy(input.Sorting);
        }
        else
        {
            query = query.OrderBy(x => x.CreationTime, OrderByType.Desc);
        }

        var entities = await query.ToPageListAsync(input.SkipCount, input.MaxResultCount, total);

        var items = entities.Select(ToListDto).ToList();

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

        return new PagedResultWithPageDto<LocationGetListOutputDto>
        {
            PageIndex = pageIndex,
            PageSize = pageSize,
            TotalCount = total.Value,
            TotalPages = totalPages,
            Items = items
        };
    }

    /// <inheritdoc />
    public async Task<LocationGetListOutputDto> CreateAsync([FromBody] LocationCreateInputVo input)
    {
        await AccountManagementStructureHelper.EnsureCanMutateRegionAndLocationAsync(CurrentUser, _dbContext);
        await AccountManagementStructureHelper.EnsureLocationPartnerAllowedForMutationAsync(
            CurrentUser, _dbContext, input.Partner);

        var locationCode = input.LocationCode?.Trim();
        if (string.IsNullOrWhiteSpace(locationCode))
        {
            throw new UserFriendlyException("Location ID不能为空");
        }

        var locationName = input.LocationName?.Trim();
        if (string.IsNullOrWhiteSpace(locationName))
        {
            throw new UserFriendlyException("Location Name不能为空");
        }

        var isExist = await _locationRepository.IsAnyAsync(x => x.LocationCode == locationCode);
        if (isExist)
        {
            throw new UserFriendlyException("Location ID已存在");
        }

        var entity = new LocationAggregateRoot(GuidGenerator.Create())
        {
            Partner = input.Partner?.Trim(),
            GroupName = input.GroupName?.Trim(),
            LocationCode = locationCode,
            LocationName = locationName,
            Street = input.Street?.Trim(),
            City = input.City?.Trim(),
            StateCode = input.StateCode?.Trim(),
            Country = input.Country?.Trim(),
            ZipCode = input.ZipCode?.Trim(),
            Phone = input.Phone?.Trim(),
            Email = input.Email?.Trim(),
            Latitude = input.Latitude,
            Longitude = input.Longitude,
            OperatingHours = input.OperatingHours?.Trim(),
            State = input.State
        };

        await _locationRepository.InsertAsync(entity);

        await LocationScopeBindingHelper.TryAutoBindCompanyAdminToNewLocationAsync(
            _dbContext.SqlSugarClient,
            CurrentUser,
            GuidGenerator,
            entity.Id.ToString(),
            entity.Partner,
            CurrentUser?.Id?.ToString());

        return ToListDto(entity);
    }

    /// <inheritdoc />
    public async Task<LocationGetListOutputDto> UpdateAsync(Guid id, [FromBody] LocationUpdateInputVo input)
    {
        await AccountManagementStructureHelper.EnsureCanMutateRegionAndLocationAsync(CurrentUser, _dbContext);
        await AccountManagementStructureHelper.EnsureLocationPartnerAllowedForMutationAsync(
            CurrentUser, _dbContext, input.Partner);

        var entity = await _locationRepository.GetSingleAsync(x => x.Id == id && x.IsDeleted == false);
        if (entity is null)
        {
            throw new UserFriendlyException("门店不存在");
        }

        var locationName = input.LocationName?.Trim();
        if (string.IsNullOrWhiteSpace(locationName))
        {
            throw new UserFriendlyException("Location Name不能为空");
        }

        entity.Partner = input.Partner?.Trim();
        entity.GroupName = input.GroupName?.Trim();
        entity.LocationName = locationName;
        entity.Street = input.Street?.Trim();
        entity.City = input.City?.Trim();
        entity.StateCode = input.StateCode?.Trim();
        entity.Country = input.Country?.Trim();
        entity.ZipCode = input.ZipCode?.Trim();
        entity.Phone = input.Phone?.Trim();
        entity.Email = input.Email?.Trim();
        entity.Latitude = input.Latitude;
        entity.Longitude = input.Longitude;
        entity.OperatingHours = input.OperatingHours?.Trim();
        entity.State = input.State;

        await _locationRepository.UpdateAsync(entity);

        return ToListDto(entity);
    }

    /// <inheritdoc />
    public async Task DeleteAsync(Guid id)
    {
        await AccountManagementStructureHelper.EnsureCanMutateRegionAndLocationAsync(CurrentUser, _dbContext);

        var entity = await _locationRepository.GetSingleAsync(x => x.Id == id && x.IsDeleted == false);
        if (entity is null)
        {
            throw new UserFriendlyException("门店不存在");
        }

        await AccountManagementStructureHelper.EnsureLocationPartnerAllowedForMutationAsync(
            CurrentUser, _dbContext, entity.Partner);

        entity.IsDeleted = true;
        await _locationRepository.UpdateAsync(entity);
    }

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

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

        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> ExportLocationsExcelAsync([FromQuery] LocationGetListInputVo input)
    {
        var exportFilter = new LocationGetListInputVo
        {
            Sorting = input.Sorting,
            Keyword = input.Keyword,
            Partner = input.Partner,
            GroupName = input.GroupName,
            State = input.State
        };

        var query = await BuildFilteredQueryAsync(exportFilter);
        if (!string.IsNullOrWhiteSpace(exportFilter.Sorting))
        {
            query = query.OrderBy(exportFilter.Sorting);
        }
        else
        {
            query = query.OrderBy(x => x.CreationTime, OrderByType.Desc);
        }

        var entities = await query.ToListAsync();
        var rows = entities.Select(ToListDto).ToList();

        var ms = LocationBatchExcelHelper.BuildExportWorkbook(rows);
        const string contentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
        var downloadName = $"locations-export-{Clock.Now:yyyyMMdd-HHmmss}.xlsx";
        return new FileStreamResult(ms, contentType) { FileDownloadName = downloadName };
    }

    /// <inheritdoc />
    public async Task<LocationBatchImportResultDto> ImportLocationsBatchAsync([FromForm] LocationBatchImportInputVo 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 文件");
        }

        await using var uploadStream = input.File.OpenReadStream();
        var parseErrors = new List<LocationBatchImportErrorDto>();
        var rows = LocationBatchExcelHelper.ParseImportWorkbook(
            uploadStream,
            opt.MaxImportRows <= 0 ? 5000 : opt.MaxImportRows,
            out var headerErrors);
        parseErrors.AddRange(headerErrors);

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

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

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

    /// <inheritdoc />
    public async Task<LocationBulkUpdateResultDto> UpdateLocationsBulkAsync([FromBody] LocationBulkUpdateInputVo 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，空行请使用 id 为空 GUID 或从列表中移除）");
        }

        var result = new LocationBulkUpdateResultDto();
        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 LocationBulkUpdateErrorDto
                {
                    RowNumber = i + 1,
                    Id = item.Id,
                    Message = ex.Message
                });
            }
        }

        return result;
    }

    private async Task<ISugarQueryable<LocationAggregateRoot>> BuildFilteredQueryAsync(LocationGetListInputVo input)
    {
        var scope = await LocationRegionScopeHelper.ResolveLocationListScopeAsync(CurrentUser, _dbContext);

        var keyword = input.Keyword?.Trim();
        var partner = input.Partner?.Trim();
        var groupName = input.GroupName?.Trim();

        var query = _locationRepository._DbQueryable
            .Where(x => x.IsDeleted == false);

        query = LocationRegionScopeHelper.ApplyLocationListScope(query, scope);

        return query
            .WhereIF(!string.IsNullOrEmpty(partner), x => x.Partner == partner)
            .WhereIF(!string.IsNullOrEmpty(groupName), x => x.GroupName == groupName)
            .WhereIF(input.State is not null, x => x.State == input.State)
            .WhereIF(!string.IsNullOrEmpty(keyword),
                x =>
                    x.LocationCode.Contains(keyword!) ||
                    x.LocationName.Contains(keyword!) ||
                    (x.Street != null && x.Street.Contains(keyword!)) ||
                    (x.City != null && x.City.Contains(keyword!)) ||
                    (x.StateCode != null && x.StateCode.Contains(keyword!)) ||
                    (x.Country != null && x.Country.Contains(keyword!)) ||
                    (x.ZipCode != null && x.ZipCode.Contains(keyword!)) ||
                    (x.Phone != null && x.Phone.Contains(keyword!)) ||
                    (x.Email != null && x.Email.Contains(keyword!)) ||
                    (x.OperatingHours != null && x.OperatingHours.Contains(keyword!)));
    }

    private static LocationGetListOutputDto ToListDto(LocationAggregateRoot x) =>
        new()
        {
            Id = x.Id,
            Partner = x.Partner,
            GroupName = x.GroupName,
            LocationCode = x.LocationCode,
            LocationName = x.LocationName,
            Street = x.Street,
            City = x.City,
            StateCode = x.StateCode,
            Country = x.Country,
            ZipCode = x.ZipCode,
            Phone = x.Phone,
            Email = x.Email,
            Latitude = x.Latitude,
            Longitude = x.Longitude,
            OperatingHours = x.OperatingHours,
            State = x.State
        };
}