using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;
using CMS.Plugin.HIAWms.Application.Contracts.Services;
using CMS.Plugin.HIAWms.Domain.WmsMaterialStocks;
using CMS.Plugin.HIAWms.Domain.Shared;
using CMS.Plugin.HIAWms.Domain.Shared.WmsMaterialStocks;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Data;
using Volo.Abp.ObjectExtending;
using CMS.Plugin.HIAWms.Domain.Shared.Util;

namespace CMS.Plugin.HIAWms.Application.Implements;

/// <inheritdoc />
public class WmsMaterialStockAppService : CMSPluginAppService, IWmsMaterialStockAppService
{
    private readonly IWmsMaterialStockRepository _wmsmaterialstockRepository;

    /// <summary>
    /// Initializes a new instance of the <see cref="WmsMaterialStockAppService"/> class.
    /// </summary>
    /// <param name="wmsmaterialstockRepository">The task job repository.</param>
    public WmsMaterialStockAppService(IWmsMaterialStockRepository wmsmaterialstockRepository)
    {
        _wmsmaterialstockRepository = wmsmaterialstockRepository;
    }

    /// <inheritdoc />
    public virtual async Task<WmsMaterialStockDto> GetAsync(Guid id)
    {
        return ObjectMapper.Map<WmsMaterialStock, WmsMaterialStockDto>(await _wmsmaterialstockRepository.GetAsync(id));
    }

    /// <inheritdoc />
    public virtual async Task<PagedResultDto<WmsMaterialStockDto>> GetListAsync(GetWmsMaterialStocksInput input)
    {
        Check.NotNull(input, nameof(input));

        if (input.Sorting.IsNullOrWhiteSpace())
        {
            input.Sorting = nameof(WmsMaterialStock.Sort);
        }

        var specification = new WmsMaterialStockSpecification(input.Name);
        var stock = ObjectMapper.Map<GetWmsMaterialStocksInput, WmsMaterialStock>(input);
        var count = await _wmsmaterialstockRepository.GetCountAsync(stock, input.StartTime, input.EndTime, input.Filter, specification);
        var list = await _wmsmaterialstockRepository.GetListAsync(stock, input.StartTime, input.EndTime, input.Sorting, input.MaxResultCount, input.SkipCount, input.Filter, specification);

        return new PagedResultDto<WmsMaterialStockDto>(count, ObjectMapper.Map<List<WmsMaterialStock>, List<WmsMaterialStockDto>>(list));
    }

    /// <inheritdoc />
    public virtual async Task<WmsMaterialStockDto> CreateAsync(WmsMaterialStockCreateDto input)
    {
        await CheckCreateOrUpdateDtoAsync(input);

        var exist = await _wmsmaterialstockRepository.NameExistAsync(input.MaterialNo);
        if (exist)
        {
            throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.MaterialNo]);
        }

        var maxSort = await _wmsmaterialstockRepository.GetMaxSortAsync();
        var sort = input.Sort ?? maxSort;
        var wmsmaterialstock = ObjectMapper.Map<WmsMaterialStockCreateDto, WmsMaterialStock>(input);
        input.MapExtraPropertiesTo(wmsmaterialstock, MappingPropertyDefinitionChecks.None);
        wmsmaterialstock.Sort = sort;
        wmsmaterialstock.InStockTime = DateTime.Now;
        await _wmsmaterialstockRepository.InsertAsync(wmsmaterialstock);

        if (input.Sort.HasValue && wmsmaterialstock.Sort != maxSort)
        {
            await AdjustSortAsync(wmsmaterialstock.Id, wmsmaterialstock.Sort);
        }

        return ObjectMapper.Map<WmsMaterialStock, WmsMaterialStockDto>(wmsmaterialstock);
    }

    /// <inheritdoc />
    public virtual async Task<WmsMaterialStockDto> UpdateAsync(Guid id, WmsMaterialStockUpdateDto input)
    {
        await CheckCreateOrUpdateDtoAsync(input);

        var wmsmaterialstock = await _wmsmaterialstockRepository.GetAsync(id);
        var exist = await _wmsmaterialstockRepository.NameExistAsync(input.MaterialNo, wmsmaterialstock.Id);
        if (exist)
        {
            throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.MaterialNo]);
        }

        wmsmaterialstock.SetConcurrencyStampIfNotNull(input.ConcurrencyStamp);
        input.MapExtraPropertiesTo(wmsmaterialstock, MappingPropertyDefinitionChecks.None);

        wmsmaterialstock.MaterialNo = input.MaterialNo;
        wmsmaterialstock.MaterialName = input.MaterialName;
        wmsmaterialstock.ContainerNo = input.ContainerNo;
        wmsmaterialstock.ContainerStatus = input.ContainerStatus;
        wmsmaterialstock.ContainerType = input.ContainerType;
        wmsmaterialstock.StockNumber = input.StockNumber;
        wmsmaterialstock.MaterialBatch = input.MaterialBatch;
        wmsmaterialstock.SupplierCode = input.SupplierCode;
        wmsmaterialstock.MaterialModel = input.MaterialModel;
        wmsmaterialstock.PlaceNo = input.PlaceNo;
        wmsmaterialstock.PlaceStatus = input.PlaceStatus;
        wmsmaterialstock.StorageTypeNo = input.StorageTypeNo;
        wmsmaterialstock.AreaCode = input.AreaCode;
        wmsmaterialstock.AreaName = input.AreaName;
        wmsmaterialstock.IsLock = input.IsLock;
        wmsmaterialstock.InStockTime = input.InStockTime;
        wmsmaterialstock.Remark = input.Remark;

        await _wmsmaterialstockRepository.UpdateAsync(wmsmaterialstock);

        return ObjectMapper.Map<WmsMaterialStock, WmsMaterialStockDto>(wmsmaterialstock);
    }

    /// <inheritdoc />
    public async Task<List<WmsMaterialStockDto>> CloneAsync(IEnumerable<Guid> ids)
    {
        var wmsmaterialstocks = new List<WmsMaterialStock>();
        if (ids != null)
        {
            var sort = await _wmsmaterialstockRepository.GetMaxSortAsync();
            foreach (var id in ids)
            {
                var wmsmaterialstock = await _wmsmaterialstockRepository.FindAsync(id);
                if (wmsmaterialstock != null)
                {
                    var name = wmsmaterialstock.MaterialNo + WmsMaterialStockConsts.CloneTag;
                    var notExist = false;
                    while (!notExist)
                    {
                        var exist = await _wmsmaterialstockRepository.NameExistAsync(name);
                        if (exist || wmsmaterialstocks.Any(x => x.MaterialNo == name))
                        {
                            name += WmsMaterialStockConsts.CloneTag;
                            continue;
                        }

                        notExist = true;
                    }

                    //wmsmaterialstock = await _wmsmaterialstockRepository.InsertAsync(wmsmaterialstock.Clone(GuidGenerator.Create(), name, sort++));
                    wmsmaterialstocks.Add(wmsmaterialstock);
                }
            }
        }

        return ObjectMapper.Map<List<WmsMaterialStock>, List<WmsMaterialStockDto>>(wmsmaterialstocks);
    }

    /// <inheritdoc />
    public virtual Task DeleteAsync(Guid id)
    {
        return _wmsmaterialstockRepository.DeleteAsync(id);
    }

    /// <inheritdoc />
    public async Task DeleteManyAsync(IEnumerable<Guid> ids)
    {
        foreach (var id in ids)
        {
            await DeleteAsync(id);
        }
    }

    /// <inheritdoc />
    public virtual async Task AdjustSortAsync(Guid id, int sort)
    {
        var list = await _wmsmaterialstockRepository.GetListAsync(null, null, null, nameof(WmsMaterialStock.Sort));
        if (list != null && list.Any())
        {
            var initSort = 1;
            list.ForEach(x => x.AdjustSort(initSort++));
            var entity = list.FirstOrDefault(x => x.Id == id);
            if (entity != null)
            {
                if (sort == 1)
                {
                    list.Where(x => x.Id != id).ToList()?.ForEach(x => x.AdjustSort(x.Sort + 1));
                }
                else if (entity.Sort > sort)
                {
                    list.Where(x => x.Id != id && x.Sort >= sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort + 1));
                    list.Where(x => x.Id != id && x.Sort < sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort - 1));
                }
                else if (entity.Sort < sort)
                {
                    list.Where(x => x.Id != id && x.Sort > sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort + 1));
                    list.Where(x => x.Id != id && x.Sort <= sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort - 1));
                }

                entity.AdjustSort(sort);
            }
        }

        await _wmsmaterialstockRepository.UpdateManyAsync(list);
    }

    /// <inheritdoc />
    public async Task ImportAsync(WmsMaterialStocksImportModel input)
    {
        Check.NotNull(input, nameof(input));

        var wmsmaterialstockCreateDtos = new List<(int RowIndex, WmsMaterialStockCreateDto Item)>();
        var wmsmaterialstockUpdateDtos = new List<(int RowIndex, Guid Id, WmsMaterialStockUpdateDto Item)>();
        var wmsmaterialstocks = input.WmsMaterialStocks;

        if (wmsmaterialstocks != null && wmsmaterialstocks.Any())
        {
            #region 导入校验

            // 判断名称是否重复，并输出第几行重复
            var duplicateWmsMaterialStocks = wmsmaterialstocks.GroupBy(x => x.MaterialNo).Where(x => x.Count() > 1).ToList();
            if (duplicateWmsMaterialStocks?.Any() == true)
            {
                var duplicateWmsMaterialStockMsgs = duplicateWmsMaterialStocks.Select(x => $"第 {string.Join(",", x.Select(x => x.RowIndex))} 行：{x.Key}  名称重复");
                var errorMsg = $"导入失败！配置， {string.Join(",", duplicateWmsMaterialStockMsgs)}，终止导入";
                throw new UserFriendlyException(errorMsg);
            }

            #endregion

            foreach (var wmsmaterialstock in wmsmaterialstocks)
            {
                if (wmsmaterialstock.MaterialNo.IsNullOrWhiteSpace() && wmsmaterialstock.MaterialNo.IsNullOrWhiteSpace())
                {
                    continue;
                }

                if (wmsmaterialstock.MaterialNo.IsNullOrWhiteSpace())
                {
                    var errorMsg = $"导入失败！配置，第{wmsmaterialstock.RowIndex}行：WmsMaterialStock名称不能为空";
                    throw new UserFriendlyException(errorMsg);
                }

                var oldWmsMaterialStock = await _wmsmaterialstockRepository.FindByNameAsync(wmsmaterialstock.MaterialNo);
                if (oldWmsMaterialStock != null)
                {
                    var wmsMaterialStockUpdateDto = new WmsMaterialStockUpdateDto
                    {
                        // 基础信息
                        MaterialNo = wmsmaterialstock.MaterialNo,
                        MaterialName = wmsmaterialstock.MaterialName,
                        Remark = wmsmaterialstock.Remark,

                        // 容器信息
                        ContainerNo = wmsmaterialstock.ContainerNo,
                        ContainerStatus = wmsmaterialstock.ContainerStatus,
                        ContainerType = wmsmaterialstock.ContainerType,

                        // 库存信息
                        StockNumber = wmsmaterialstock.StockNumber,
                        MaterialBatch = wmsmaterialstock.MaterialBatch,

                        // 供应商信息
                        SupplierCode = wmsmaterialstock.SupplierCode,
                        MaterialModel = wmsmaterialstock.MaterialModel,

                        // 库位信息
                        PlaceNo = wmsmaterialstock.PlaceNo,
                        PlaceStatus = wmsmaterialstock.PlaceStatus,
                        StorageTypeNo = wmsmaterialstock.StorageTypeNo,

                        // 库区信息
                        AreaCode = wmsmaterialstock.AreaCode,
                        AreaName = wmsmaterialstock.AreaName,

                        // 状态信息
                        IsLock = wmsmaterialstock.IsLock,
                        InStockTime = wmsmaterialstock.InStockTime,

                        // 并发控制
                        ConcurrencyStamp = oldWmsMaterialStock.ConcurrencyStamp
                    };

                    wmsmaterialstockUpdateDtos.Add((wmsmaterialstock.RowIndex, oldWmsMaterialStock.Id, wmsMaterialStockUpdateDto));
                }
                else
                {
                    var wmsmaterialstockCreateDto = new WmsMaterialStockCreateDto
                    {
                        // 基础信息
                        MaterialNo = wmsmaterialstock.MaterialNo,
                        MaterialName = wmsmaterialstock.MaterialName,
                        Remark = wmsmaterialstock.Remark,

                        // 容器信息
                        ContainerNo = wmsmaterialstock.ContainerNo,
                        ContainerStatus = wmsmaterialstock.ContainerStatus,
                        ContainerType = wmsmaterialstock.ContainerType,

                        // 库存信息
                        StockNumber = wmsmaterialstock.StockNumber,
                        MaterialBatch = wmsmaterialstock.MaterialBatch,

                        // 供应商信息
                        SupplierCode = wmsmaterialstock.SupplierCode,
                        MaterialModel = wmsmaterialstock.MaterialModel,

                        // 库位信息
                        PlaceNo = wmsmaterialstock.PlaceNo,
                        PlaceStatus = wmsmaterialstock.PlaceStatus,
                        StorageTypeNo = wmsmaterialstock.StorageTypeNo,

                        // 库区信息
                        AreaCode = wmsmaterialstock.AreaCode,
                        AreaName = wmsmaterialstock.AreaName,

                        // 状态信息
                        IsLock = wmsmaterialstock.IsLock,
                        InStockTime = wmsmaterialstock.InStockTime,
                    };

                    wmsmaterialstockCreateDtos.Add((wmsmaterialstock.RowIndex, wmsmaterialstockCreateDto));
                }
            }
        }

        // 新增
        foreach (var wmsmaterialstockDto in wmsmaterialstockCreateDtos)
        {
            try
            {
                await CreateAsync(wmsmaterialstockDto.Item);
            }
            catch (Exception e)
            {
                var errorMsg = $"导入失败！配置，第{wmsmaterialstockDto.RowIndex}行：{e.Message}，终止导入";
                throw new UserFriendlyException(errorMsg);
            }
        }

        // 更新
        foreach (var wmsmaterialstockDto in wmsmaterialstockUpdateDtos)
        {
            try
            {
                await UpdateAsync(wmsmaterialstockDto.Id, wmsmaterialstockDto.Item);
            }
            catch (Exception e)
            {
                var errorMsg = $"导入失败！配置，第{wmsmaterialstockDto.RowIndex}行：{e.Message}，终止导入";
                throw new UserFriendlyException(errorMsg);
            }
        }
    }

    /// <inheritdoc />
    public async Task<(Dictionary<string, object> Sheets, string FileName)> ExportAsync(GetWmsMaterialStocksInput input)
    {
        Check.NotNull(input, nameof(input));

        if (input.Sorting.IsNullOrWhiteSpace())
        {
            input.Sorting = nameof(WmsMaterialStock.Sort);
        }

        var specification = new WmsMaterialStockSpecification(input.Name);
        var stock = ObjectMapper.Map<GetWmsMaterialStocksInput, WmsMaterialStock>(input);
        var list = await _wmsmaterialstockRepository.GetListAsync(stock, input.StartTime, input.EndTime, input.Sorting, input.MaxResultCount, input.SkipCount, input.Filter, specification, includeDetails: true);
        var result = ObjectMapper.Map<List<WmsMaterialStock>, List<WmsMaterialStockDto>>(list);

        var sheets = new Dictionary<string, object>
        {
            ["配置"] = ExportHelper.ConvertListToExportData(result),
        };

        var fileName = result.Count > 1 ? "WmsMaterialStock列表" : result.Count == 1 ? result.First()?.MaterialNo : "WmsMaterialStock模版";
        return (sheets, fileName);
    }

    /// <summary>
    /// Checks the create or update dto asynchronous.
    /// </summary>
    /// <param name="input">The input.</param>
    protected Task CheckCreateOrUpdateDtoAsync(WmsMaterialStockCreateOrUpdateDtoBase input)
    {
        Check.NotNull(input, nameof(input));
        Check.NotNullOrWhiteSpace(input.MaterialNo, "编号", WmsMaterialStockConsts.MaxCodeLength);
        Check.NotNullOrWhiteSpace(input.MaterialName, "名称", WmsMaterialStockConsts.MaxNameLength);
        Check.Length(input.Remark, "备注", WmsMaterialStockConsts.MaxRemarkLength);
        return Task.CompletedTask;
    }
}