using Admin.NET.Core.Service;
using Admin.NET.Application.Entity;
using Microsoft.AspNetCore.Http;
using Flurl.Util;
using SqlSugar;
using NetTaste;
using System.DirectoryServices.ActiveDirectory;
using System.Reflection;
using System.Linq;

namespace Admin.NET.Application;
/// <summary>
/// ASN明细表服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.WmsOrderGroupName, Order = 100)]
public class WmsOrderAsnDetailsService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<WmsOrderAsnDetails> _rep;
    private readonly SqlSugarRepository<WmsConfigSncodeRule> _WmsSncodeCreateRuleRep;

    public WmsOrderAsnDetailsService(SqlSugarRepository<WmsOrderAsnDetails> rep, SqlSugarRepository<WmsConfigSncodeRule> wmsSncodeCreateRuleRep)
    {
        _rep = rep;
        _WmsSncodeCreateRuleRep = wmsSncodeCreateRuleRep;
    }

    /// <summary>
    /// 分页查询ASN明细表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Page")]
    [Description("WmsOrderAsnDetails/Page")]
    public async Task<SqlSugarPagedList<WmsOrderAsnDetailsOutput>> Page(WmsOrderAsnDetailsInput input)
    {
        var query = CommonPageFilter(input);
        return await query
             .OrderBy(x => x.AsnLineNumber)
            //.OrderBuilder(input)
            .ToPagedListAsync(input.Page, input.PageSize);
    }

    /// <summary>
    /// 不分页查询ASN明细表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "List")]
    [Description("WmsOrderAsnDetails/List")]
    public async Task<List<WmsOrderAsnDetailsOutput>> List([FromQuery] WmsOrderAsnDetailsInput input)
    {
        var query = CommonPageFilter(input);
        return await query.OrderBuilder(input).Select<WmsOrderAsnDetailsOutput>().ToListAsync();
    }

    /// <summary>
    /// 增加ASN明细表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Add")]
    [Description("WmsOrderAsnDetails/Add")]
    public async Task<long> Add(AddWmsOrderAsnDetailsInput input)
    {
        var entity = input.Adapt<WmsOrderAsnDetails>();

        //重复性验证
        await CheckExist(entity);

        await _rep.InsertAsync(entity);
        return entity.Id;
    }

    /// <summary>
    /// 删除ASN明细表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Delete")]
    [Description("WmsOrderAsnDetails/Delete")]
    public async Task Delete(DeleteWmsOrderAsnDetailsInput input)
    {
        var entity = await _rep.GetFirstAsync(u => u.Id == input.Id) ?? throw Oops.Oh(ErrorCodeEnum.D1002);
        //await _rep.FakeDeleteAsync(entity);   //假删除
        await _rep.DeleteAsync(entity);   //真删除
    }

    /// <summary>
    /// 更新ASN明细表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Update")]
    [Description("WmsOrderAsnDetails/Update")]
    public async Task Update(UpdateWmsOrderAsnDetailsInput input)
    {
        var entity = input.Adapt<WmsOrderAsnDetails>();

        //重复性验证
        await CheckExist(entity,true);

        await _rep.AsUpdateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
    }


    /// <summary>
    /// 更新ASN明细表 - 生成条码 -ly
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "UpdateBarCode")]
    [Description("WmsOrderAsnDetails/UpdateBarCode")]
    public async Task UpdateBarCode(UpdateWmsOrderAsnIdsInput input)
    {



        //var entity = input.Adapt<WmsOrderAsnDetails>();
        ////await CheckExist(entity, true);//重复性验证
        //await _rep.AsUpdateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
        if (input is null || input.Id.Count == 0)
        {
            throw Oops.Oh("输入参不能为空"); 
        }

        var WmsSncodeCreateRuleItem = await _WmsSncodeCreateRuleRep
      .GetFirstAsync(w => (w.CreateCodeType == CreateCodeTypeEnum.ASN单一维码 || 
      w.CreateCodeType == CreateCodeTypeEnum.ASN单二维码) && w.IsDisabled == false);

        if (WmsSncodeCreateRuleItem == null)
        {
            throw Oops.Oh($"条码生成规则-规则编号ASN不存在");
        }
       
        var ruleArr = WmsSncodeCreateRuleItem.SNCodeRule.Replace('，', ',').Split(',').ToList();
        //if (!ruleArr.Any(s => s.IndexOf("Id", StringComparison.OrdinalIgnoreCase) >= 0))
        //{
        //    throw Oops.Oh("该条码生成规则不包含必须的字段“Id”！");
        //}
        var Details = new List<WmsOrderAsnDetails>();
        foreach(var item in input.Id)
        {
            var getSnCodeModel = await _rep.AsQueryable().FirstAsync(p => p.Id == item);
            if(getSnCodeModel != null)
            {
                Details.Add(getSnCodeModel);
            }
        }
        var flag = 0;
        foreach( var item in Details) 
        {
            if (item.AsnStatus != OrderStatusEnum.新建) { throw Oops.Oh("状态不是新建"); }
            var sn_2dStr = "";
            foreach (var mark in ruleArr)
            {
                Type type = item.GetType();
                List<PropertyInfo> PropertyList = type.GetProperties().ToList();
                var propertyItem = PropertyList.Find(p => p.Name.ToUpper() == mark.ToUpper());
                string itemModelName = Convert.ToString(propertyItem.GetValue(item, null));
                if (WmsSncodeCreateRuleItem.CreateCodeType == CreateCodeTypeEnum.ASN单一维码)//ly-一维码组成：单号和行号 不用分隔符分割
                {
                    sn_2dStr = mark == ruleArr[ruleArr.Count - 1] ? sn_2dStr += itemModelName : sn_2dStr += itemModelName;
                    item.SN_1d = sn_2dStr;
                    item.SN_2d = "";
                }
                else
                {
                    sn_2dStr = mark == ruleArr[ruleArr.Count - 1] ? sn_2dStr += itemModelName : sn_2dStr += itemModelName + WmsSncodeCreateRuleItem.Delimiter;
                    item.SN_2d = sn_2dStr;
                    item.SN_1d = "";
                }
                       
            }
        }
        await _rep.UpdateRangeAsync(Details);//更新

    }


    /// <summary>
    /// 获取ASN明细表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "Detail")]
    [Description("WmsOrderAsnDetails/Detail")]
    public async Task<WmsOrderAsnDetails> Detail([FromQuery] QueryByIdWmsOrderAsnDetailsInput input)
    {
        return await _rep.GetFirstAsync(u => u.Id == input.Id);
    }





      #region 私有方法

    /// <summary>
    /// 公共查询ASN明细表条件
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private ISugarQueryable<WmsOrderAsnDetailsOutput> CommonPageFilter(WmsOrderAsnDetailsInput input)
    {
        var query = _rep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.PoNo.Contains(input.SearchKey.Trim())
                || u.MaterialCode.Contains(input.SearchKey.Trim())
                || u.MaterialName.Contains(input.SearchKey.Trim())
                || u.SupplierCode.Contains(input.SearchKey.Trim())
                || u.SupplierName.Contains(input.SearchKey.Trim())
                || u.SN_1d.Contains(input.SearchKey.Trim())
                || u.SN_2d.Contains(input.SearchKey.Trim())
                || u.ProjectNo.Contains(input.SearchKey.Trim())
                || u.AsnNo.Contains(input.SearchKey.Trim())
                || u.SupplierBatch.Contains(input.SearchKey.Trim())
                || u.ErpCode.Contains(input.SearchKey.Trim())
                || u.ErpOrderNo.Contains(input.SearchKey.Trim())
            )
            .WhereIF(input.PoId>0, u => u.PoId == input.PoId)
            .WhereIF(!string.IsNullOrWhiteSpace(input.PoNo), u => u.PoNo.Contains(input.PoNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.PoLineNumber), u => u.PoLineNumber.Contains(input.PoLineNumber.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialCode), u => u.MaterialCode.Contains(input.MaterialCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialName), u => u.MaterialName.Contains(input.MaterialName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierCode), u => u.SupplierCode.Contains(input.SupplierCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierName), u => u.SupplierName.Contains(input.SupplierName.Trim()))
          //  .WhereIF(!string.IsNullOrWhiteSpace(input.POUnit), u => u.POUnit.Contains(input.Unit.Trim()))
            .WhereIF(input.AsnStatus.HasValue, u => u.AsnStatus == input.AsnStatus)
            .WhereIF(!string.IsNullOrWhiteSpace(input.AsnStatusName), u => u.AsnStatusName.Contains(input.AsnStatusName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SN_1d), u => u.SN_1d.Contains(input.SN_1d.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SN_2d), u => u.SN_2d.Contains(input.SN_2d.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Package), u => u.Package.Contains(input.Package.Trim()))
            .WhereIF(input.IsFreeze.HasValue, u => u.IsFreeze == input.IsFreeze)
            .WhereIF(!string.IsNullOrWhiteSpace(input.FreezeReason), u => u.FreezeReason.Contains(input.FreezeReason.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.ProjectNo), u => u.ProjectNo.Contains(input.ProjectNo.Trim()))
            .WhereIF(input.FactoryId>0, u => u.FactoryId == input.FactoryId)
            .WhereIF(!string.IsNullOrWhiteSpace(input.FactoryName), u => u.FactoryName.Contains(input.FactoryName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.FactoryCode), u => u.FactoryCode.Contains(input.FactoryCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Dock), u => u.Dock.Contains(input.Dock.Trim()))
            .WhereIF(input.AsnId>0, u => u.AsnId == input.AsnId)
            .WhereIF(!string.IsNullOrWhiteSpace(input.AsnNo), u => u.AsnNo.Contains(input.AsnNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierBatch), u => u.SupplierBatch.Contains(input.SupplierBatch.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Batch), u => u.Batch.Contains(input.Batch.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpCode), u => u.ErpCode.Contains(input.ErpCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpOrderNo), u => u.ErpOrderNo.Contains(input.ErpOrderNo.Trim()))
            .Select<WmsOrderAsnDetailsOutput>();
        if(input.PlannedStartTimeRange != null && input.PlannedStartTimeRange.Count >0)
        {
            DateTime? start= input.PlannedStartTimeRange[0].Value.AddDays(-1);
            query = query.WhereIF(start.HasValue, u => u.PlannedStartTime > start);
            if (input.PlannedStartTimeRange.Count >1 && input.PlannedStartTimeRange[1].HasValue)
            {
                var end = input.PlannedStartTimeRange[1].Value.AddDays(1);
                query = query.Where(u => u.PlannedStartTime < end);
            }
        } 
        if(input.PlannedEndTimeRange != null && input.PlannedEndTimeRange.Count >0)
        {
            DateTime? start= input.PlannedEndTimeRange[0].Value.AddDays(-1);
            query = query.WhereIF(start.HasValue, u => u.PlannedEndTime > start);
            if (input.PlannedEndTimeRange.Count >1 && input.PlannedEndTimeRange[1].HasValue)
            {
                var end = input.PlannedEndTimeRange[1].Value.AddDays(1);
                query = query.Where(u => u.PlannedEndTime < end);
            }
        } 
        return query;
       }

        /// <summary>
        /// 重复性验证
        /// </summary>
        /// <param name="input">验证对象</param>
        /// <param name="isEdit">是否是编辑</param>
        /// <returns></returns>
        private async Task CheckExist( WmsOrderAsnDetails input,bool isEdit=false)
        {
           


            //没有配置组合校验，不需要验重

           
            //没有配置单独校验，不需要验重
       }
     #endregion

}