using Furion.DatabaseAccessor;
using Furion.DatabaseAccessor.Extensions;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using iWare.Wms.Core;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Linq.Dynamic.Core;

namespace iWare.Wms.Application
{
    /// <summary>
    /// 组盘管理服务
    /// </summary>
    [Route("api")]
    [ApiDescriptionSettings("基础信息", Name = "WareContainerVsMaterial", Order = 100)]
    [Route("api/[Controller]")]
    public class WareContainerVsMaterialService : IWareContainerVsMaterialService, IDynamicApiController, ITransient
    {
        private readonly IRepository<WareContainerVsMaterial, MasterDbContextLocator> _wareContainerVsMaterialRep;
        private readonly IRepository<WmsContainer, MasterDbContextLocator> _wmsContainerRep;
        private readonly IRepository<WareTask, MasterDbContextLocator> _wareTaskRep;
        private readonly IRepository<WmsMaterial, MasterDbContextLocator> _wmsMaterialRep;
        private readonly IRepository<WareLocationVsContainer, MasterDbContextLocator> _wareLocationVsContainerRep;

        public WareContainerVsMaterialService(
            IRepository<WareContainerVsMaterial, MasterDbContextLocator> wareContainerVsMaterialRep,
            IRepository<WmsContainer, MasterDbContextLocator> wmsContainerRep,
            IRepository<WareTask, MasterDbContextLocator> wareTaskRep,
            IRepository<WmsMaterial, MasterDbContextLocator> wmsMaterialRep,
            IRepository<WareLocationVsContainer, MasterDbContextLocator> wareLocationVsContainerRep
        )
        {
            _wareContainerVsMaterialRep = wareContainerVsMaterialRep;
            _wmsContainerRep = wmsContainerRep;
            _wareTaskRep = wareTaskRep;
            _wmsMaterialRep = wmsMaterialRep;
            _wareLocationVsContainerRep = wareLocationVsContainerRep;
        }

        /// <summary>
        /// 分页查询组盘管理
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("page")]
        public async Task<PageResult<WareContainerVsMaterialOutput>> Page([FromQuery] WareContainerVsMaterialSearch input)
        {
            var wareContainerVsMaterials = await _wareContainerVsMaterialRep.DetachedEntities
                                     .Where(!string.IsNullOrEmpty(input.WareContainerCode), u => EF.Functions.Like(u.WareContainerCode, $"%{input.WareContainerCode.Trim()}%"))
                                     .Where(!string.IsNullOrEmpty(input.WareMaterialCode), u => EF.Functions.Like(u.WareMaterialCode, $"%{input.WareMaterialCode.Trim()}%"))
                                     .Where(input.Quantity != null, u => u.Quantity == input.Quantity)
                                     .Where(!string.IsNullOrEmpty(input.PurchaseNo), u => u.PurchaseNo == input.PurchaseNo)
                                     .Where(!string.IsNullOrEmpty(input.DeliveryNo), u => u.DeliveryNo == input.DeliveryNo)
                                     .Where(!string.IsNullOrEmpty(input.CollectNo), u => u.CollectNo == input.CollectNo)
                                     .Where(!string.IsNullOrEmpty(input.OrdersNo), u => u.OrdersNo == input.OrdersNo)
                                     .Where(input.Status != null, u => u.Status == input.Status)
                                     .Where(!string.IsNullOrEmpty(input.Remarks), u => u.Remarks == input.Remarks)
                                     .Where(input.StockStatus != null, u => u.StockStatus == input.StockStatus)
                                     .Where(input.IsLocked != null, u => u.IsLocked == input.IsLocked)
                                     .Where(!string.IsNullOrEmpty(input.BarNo), u => u.BarNo == input.BarNo)
                                     .Where(!string.IsNullOrEmpty(input.OrderType), u => u.OrderType == input.OrderType)
                                     .Where(!string.IsNullOrEmpty(input.Unit), u => u.Unit == input.Unit)
                                     .Where(!string.IsNullOrEmpty(input.WareMaterialName), u => u.WareMaterialName == input.WareMaterialName)
                                     .OrderBy(PageInputOrder.OrderBuilder<WareContainerVsMaterialSearch>(input))
                                     .ProjectToType<WareContainerVsMaterialOutput>()
                                     .ToADPagedListAsync(input.PageNo, input.PageSize);

            foreach (var item in wareContainerVsMaterials.Rows)
            {
                var str = await _wmsContainerRep.DetachedEntities.Where(u => u.ContainerCode == item.WareContainerCode).Select(u => u.RealLocationCode).FirstOrDefaultAsync();
                item.RealLocationCode = str;
            }

            return wareContainerVsMaterials;
        }

        /// <summary>
        /// 增加组盘管理
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("add")]
        public async Task<int> Add(AddWareContainerVsMaterialInput input)
        {
            //托盘信息
            var containerModel = await _wmsContainerRep.DetachedEntities.FirstOrDefaultAsync(n => n.ContainerCode == input.WareContainerCode);
            if (containerModel == null) throw Oops.Oh("小车信息不存在!");

            var isExit = await _wareTaskRep.DetachedEntities.AnyAsync(p => p.ContainerCode == containerModel.ContainerCode);
            if (isExit) throw Oops.Oh("小车存在未完成的任务!");

            isExit = await _wareContainerVsMaterialRep.DetachedEntities.AnyAsync(p => p.WareContainerCode == containerModel.ContainerCode);
            if (isExit) throw Oops.Oh("该小车已经组盘!");

            var material = await _wmsMaterialRep.DetachedEntities.Where(u => u.MaterialNo == input.WareMaterialCode).FirstOrDefaultAsync();
            if (material == null)
            {
                throw Oops.Oh("物料没有基础信息!");
            }

            var cvmExist = await _wareContainerVsMaterialRep.DetachedEntities.AnyAsync(u => u.WareMaterialCode == material.MaterialNo);
            if (cvmExist)
            {
                throw Oops.Oh("该端拾器已经绑定小车");
            }

            var cvm = new WareContainerVsMaterial()
            {
                OrdersNo = Yitter.IdGenerator.YitIdHelper.NextId().ToString(),
                WareContainerCode = input.WareContainerCode,
                WareMaterialName = material.MaterialName,
                WareMaterialCode = material.MaterialNo,
                Quantity = 1,
                Status = 0,
                Remarks = "入库组盘",
                StockStatus = StockStatusEnum.新建,
            };

            using (var tran = await _wareContainerVsMaterialRep.Database.BeginTransactionAsync())
            {
                try
                {
                    if (cvm != null)
                    {
                        await _wareContainerVsMaterialRep.InsertAsync(cvm);
                    }
                    await tran.CommitAsync();
                }
                catch
                {
                    await tran.RollbackAsync();
                }
            }

            return 1;
        }

        /// <summary>
        /// 删除组盘管理
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("delete")]
        public async Task<int> Delete(DeleteWareContainerVsMaterialInput input)
        {
            var wareContainerVsMaterial = await _wareContainerVsMaterialRep.FirstOrDefaultAsync(u => u.Id == input.Id);
            if (wareContainerVsMaterial == null)
            {
                throw Oops.Oh("解绑失败，查询异常");
            }

            var isExist = await _wareLocationVsContainerRep.DetachedEntities.AnyAsync(u => u.WareContainerCode == wareContainerVsMaterial.WareContainerCode);
           
            if (isExist)
            {
                throw Oops.Oh("解绑失败，托盘存在库位绑定关系");
            }

            using (var tran = await _wareContainerVsMaterialRep.Database.BeginTransactionAsync())
            {
                try
                {
                    await _wareContainerVsMaterialRep.DeleteAsync(wareContainerVsMaterial);
                    await tran.CommitAsync();
                }
                catch
                {
                    await tran.RollbackAsync();
                }
            }
            return 1;
        }

        /// <summary>
        /// 更新组盘管理
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("edit")]
        public async Task Update(UpdateWareContainerVsMaterialInput input)
        {
            var isExist = await _wareContainerVsMaterialRep.AnyAsync(u => u.Id == input.Id, false);
            if (!isExist) throw Oops.Oh(ErrorCode.D3000);

            var wareContainerVsMaterial = input.Adapt<WareContainerVsMaterial>();
            await _wareContainerVsMaterialRep.UpdateAsync(wareContainerVsMaterial, ignoreNullValues: true);
        }

        /// <summary>
        /// 获取组盘管理
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("detail")]
        public async Task<WareContainerVsMaterialOutput> Get([FromQuery] QueryeWareContainerVsMaterialInput input)
        {
            return (await _wareContainerVsMaterialRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == input.Id)).Adapt<WareContainerVsMaterialOutput>();
        }

        /// <summary>
        /// 获取组盘管理列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("list")]
        public async Task<List<WareContainerVsMaterialOutput>> List([FromQuery] WareContainerVsMaterialInput input)
        {
            return await _wareContainerVsMaterialRep.DetachedEntities.ProjectToType<WareContainerVsMaterialOutput>().ToListAsync();
        }

    }
}