using EFCore.BulkExtensions;
using Magicodes.ExporterAndImporter.Core;
using Magicodes.ExporterAndImporter.Csv;
using Magicodes.ExporterAndImporter.Excel;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Shouldly;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Caching;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Guids;
using Win.Abp.Snowflakes;
using Win.Sfs.BaseData.ImportExcelCommon;
using Win.Sfs.SettleAccount.CommonManagers;
using Win.Sfs.SettleAccount.Constant;
using Win.Sfs.SettleAccount.ExcelImporter;
using Win.Sfs.Shared.Filter;

namespace Win.Sfs.SettleAccount.Entities.UnHQSettleAccounts
{

    /// <summary>
    /// 红旗主机场明细导入
    /// </summary>
    [Authorize(SettleAccountPermissions.HQ_HPlatform.Default)]
    //[AllowAnonymous]
    [Route("api/settleaccount/UnHQSettle")]
    public class UnHQSettleAppService : SettleAccountApplicationBase<UnHQSettleAccount>, IUnHQSettleAppService
    {
        private readonly IGuidGenerator _guidGenerator;

        private readonly IExcelImportAppService _excelImportService;

        private readonly ISettleAccountBranchEfCoreRepository<UnHQSettleAccountVersion, Guid> _versionRepository;

        private readonly ISettleAccountBranchEfCoreRepository<UnHQSettleAccount, Guid> _repository;


        private readonly ISettleAccountBranchEfCoreRepository<UnHQSettleAccountVersion, Guid> _versionMRepository;

        private readonly ISettleAccountBranchEfCoreRepository<UnHQSettleAccount, Guid> _repositoryM;
        /// <summary>
        /// 构建方法
        /// </summary>
        /// <param name="guidGenerator">构建UID</param>
        /// <param name="repository">仓储接口</param>
        /// <param name="cache">缓存</param>
        public UnHQSettleAppService(IGuidGenerator guidGenerator,
         ISettleAccountBranchEfCoreRepository<UnHQSettleAccountVersion, Guid> versionRepository,
           ISettleAccountBranchEfCoreRepository<UnHQSettleAccount, Guid> repository,
            IDistributedCache<UnHQSettleAccount> cache,
            IExcelImportAppService excelImportService,
            ISnowflakeIdGenerator snowflakeIdGenerator,
            ICommonManager commonManager,
             ISettleAccountBranchEfCoreRepository<UnHQSettleAccountVersion, Guid> versionMRepository
        ) : base(cache, excelImportService, snowflakeIdGenerator, commonManager)
        {
            _versionRepository = versionRepository;
            _guidGenerator = guidGenerator;
            _excelImportService = excelImportService;
            _repository = repository;
            _versionMRepository = versionMRepository;
        }

        /// <summary>
        /// 统一导入红旗主机场数据
        /// </summary>
        /// <param name="files"></param>
        /// <param name="branchId"></param>
        /// <param name="year"></param>
        /// <param name="period"></param>
        /// <param name="version"></param>
        /// <param name="customerCode"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("ExcelImport")]
        [DisableRequestSizeLimit]
        //[Authorize(SettleAccountPermissions.HQ_HPlatform.Create)]
        public async Task<string> UnHQSettleUploadExcelImport([FromForm] IFormFileCollection files, Guid branchId, string year, string period, string version, string customerCode)
        {
            ExportImporter _exportImporter = new ExportImporter();
            var result_org = await _exportImporter.UploadExcelImport<UnHQSettleImportDto>(files, _excelImportService);

            if (result_org == null || result_org.Count == 0)
            {
                throw new BusinessException("导入模板数据不能为空！");
            }
            var result = result_org.Where(p => p.Factory != "L").ToList();//去掉工厂L

            var entityList = ObjectMapper.Map<List<UnHQSettleImportDto>, List<UnHQSettleAccount>>(result);
            //删除版本
            var _versionQuery = _versionRepository.Where(p => p.Version == version);
            await _versionQuery.BatchDeleteAsync();
            //删除明细
            var _query = _repository.Where(p => p.Version == version);
            await _query.BatchDeleteAsync();

            var _id = GuidGenerator.Create();
            var _bomList = new List<UnHQSettleAccountVersion>();
            _bomList.Add(new UnHQSettleAccountVersion(_id, branchId, year, period, version, customerCode));
            foreach (var itm in entityList)
            {
                if (string.IsNullOrEmpty(itm.HQHKanBan) && itm.StorageLocationDesc.Contains("备品"))
                {
                    //赋值上主键ID
                    itm.SetValue(GuidGenerator.Create(), branchId, year, period, version, "BJ");//备品库没有看板号，需要特殊标识一下BJ,已经和客户确认
                }
                else
                {
                    itm.SetValue(GuidGenerator.Create(), branchId, year, period, version);
                }
            }

            await _repository.GetDbContext().BulkInsertAsync<UnHQSettleAccount>(entityList);
            await _versionRepository.GetDbContext().BulkInsertAsync(_bomList);

            return ApplicationConsts.SuccessStr;
        }



        /// <summary>
        /// 按ID获取唯一实体
        /// </summary>
        /// <remarks>
        /// 返回实体全部属性
        /// </remarks>
        /// <param name="id">ID</param>
        /// <returns>实体DTO</returns>
        [HttpGet]
        [Route("{id}")]
        virtual public async Task<UnHQSettleDto> GetAsync(Guid id)
        {
            var result = await GetFromCacheAsync(id);
            var dto = ObjectMapper.Map<UnHQSettleAccount, UnHQSettleDto>(result);
            return dto;
        }


        private async Task<UnHQSettleAccount> GetFromCacheAsync(Guid id)
        {
            var result = await _repository.GetAsync(id);
            return result;
        }


        private async Task<long> GetCountAsync(UnHQSettleRequestDto input)
        {
            return await _repository.GetCountByFilterAsync(input.BranchId, input.Filters);
        }

        private async Task<long> GetCountAsync(UnHQSettleVersionRequestDto input)
        {
            return await _versionRepository.GetCountByFilterAsync(input.BranchId, input.Filters);
        }


        /// <summary>
        /// 导出文件
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("Export")]
        virtual public async Task<string> ExportAsync(UnHQSettleRequestDto input)
        {

            IExporter _csv = new CsvExporter();
            IExporter _excel = new ExcelExporter();
            if (!string.IsNullOrEmpty(input.Version))
            {
                input.Filters.Add(new FilterCondition() { Action = EnumFilterAction.Equal, Column = "Version", Logic = EnumFilterLogic.And, Value = input.Version });
            }
            var entities = await _repository.GetListByFilterAsync(input.BranchId, input.Filters, input.Sorting, int.MaxValue,
               0, true);

            var dtoDetails = ObjectMapper.Map<List<UnHQSettleAccount>, List<UnHQSettleExportDto>>(entities);

            string _fileName = string.Empty;
            //声明导出容器

            byte[] result = null;
            switch (input.FileType)
            {
                case 0:
                    _fileName = string.Format("红旗未结明细_{0}.csv", input.UserId.ToString());
                    result = await _csv.ExportAsByteArray(dtoDetails);
                    break;
                case 1:
                    _fileName = string.Format("红旗未结明细_{0}.xlsx", input.UserId.ToString());
                    result = await _excel.ExportAsByteArray(dtoDetails);
                    break;
            }
            result.ShouldNotBeNull();

            //保存导出文件到服务器存成二进制
            await _excelImportService.SaveBlobAsync(
                     new SaveExcelImportInputDto
                     {
                         Name = _fileName,
                         Content = result
                     }
                 );
            return _fileName;
        }


        /// <summary>
        /// 根据筛选条件获取实体列表
        /// </summary>
        /// <remarks>
        /// 请求条件包括:筛选条件列表,排序条件,数据数量,页码
        /// </remarks>
        /// <param name="input">请求条件</param>
        /// <returns>实体DTO列表</returns>
        [HttpPost]
        [Route("list")]
        virtual public async Task<PagedResultDto<UnHQSettleDto>> GetListAsync(UnHQSettleRequestDto input)
        {
            if (!string.IsNullOrEmpty(input.Version))
            {
                input.Filters.Add(new FilterCondition() { Action = EnumFilterAction.Equal, Column = "Version", Logic = EnumFilterLogic.And, Value = input.Version });
            }
            else
            {
                return new PagedResultDto<UnHQSettleDto>(0, new List<UnHQSettleDto>());
            }
            var entities = await _repository.GetListByFilterAsync(input.BranchId, input.Filters, input.Sorting, input.MaxResultCount,
                 input.SkipCount, true);

            var totalCount = await GetCountAsync(input);
            var dtos = ObjectMapper.Map<List<UnHQSettleAccount>, List<UnHQSettleDto>>(entities);

            return new PagedResultDto<UnHQSettleDto>(totalCount, dtos);
        }


        /// <summary>
        /// 获取实体总数
        /// </summary>
        /// <returns>实体总数</returns>
        [HttpGet]
        [Route("count")]
        virtual public async Task<long> GetTotalCountAsync(Guid branchId)
        {
            return await _repository.GetCountAsync(branchId);
        }

        /// <summary>
        /// 获取全部实体列表
        /// </summary>
        /// <returns>实体DTO列表</returns>
        [HttpGet]
        [Route("all")]
        virtual public async Task<ListResultDto<UnHQSettleDto>> GetAllAsync(Guid branchId)
        {
            var entities = await _repository.GetAllAsync(branchId, true);


            var dtos = ObjectMapper.Map<List<UnHQSettleAccount>, List<UnHQSettleDto>>(entities);


            return new ListResultDto<UnHQSettleDto>(dtos);
        }



        /// <summary>
        /// 删除实体
        /// </summary>
        /// <param name="id">ID</param>
        /// <returns>无</returns>
        [HttpDelete]
        [Route("{id}")]
        virtual public async Task DeleteAsync(Guid id)
        {
            await _repository.DeleteAsync(id);
        }

        /// <summary>
        /// 按IDs删除实体列表
        /// </summary>
        /// <param name="ids">IDs</param>
        /// <returns>是否执行成功</returns>
        [HttpPost]
        [Route("delete")]
        virtual public async Task<bool> DeleteListAsync(List<Guid> ids)
        {
            foreach (var id in ids)
            {
                var entity = await GetFromCacheAsync(id);
                //await Cache.DeleteAsync<SettleAccount>(id.ToString());
            }

            return await _repository.DeleteListAsync(ids);
        }



        /// <summary>
        /// 版本列表查询
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("listversion")]
        public async Task<PagedResultDto<UnHQSettleVersionDto>> GetVersionListAsync(UnHQSettleVersionRequestDto input)
        {
            var entities = await _versionRepository.GetListByFilterAsync(input.BranchId, input.Filters, input.Sorting, int.MaxValue,
               input.SkipCount, true);

            var totalCount = await GetCountAsync(input);
            var dtos = ObjectMapper.Map<List<UnHQSettleAccountVersion>, List<UnHQSettleVersionDto>>(entities);

            return new PagedResultDto<UnHQSettleVersionDto>(totalCount, dtos);
        }

    }
}