using Admin.NET.Core.Service;
using Admin.NET.Application.Entity;
using Microsoft.AspNetCore.Http;
using System.Data;
using System.Web;
using System.Text;
using System.Linq.Dynamic.Core;
using System.Linq;
using Admin.NET.Application.CommonHelper;
using Admin.NET.Application.Service.WmsBase.WmsBatchRuleDetail.Dto;

namespace Admin.NET.Application;
/// <summary>
/// 批次属性规则明细服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.WmsBaseGroupName, Order = 100)]
public class WmsBatchRuleDetailService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<WmsBaseBatchRule> _rep;
    private readonly SqlSugarRepository<WmsBaseMaterial> _wmsMaterialRep;

    public WmsBatchRuleDetailService(SqlSugarRepository<WmsBaseBatchRule> rep, SqlSugarRepository<WmsBaseMaterial> wmsMaterialRep)
    {
        _rep = rep;
        _wmsMaterialRep = wmsMaterialRep;
    }

    /// <summary>
    /// 分页查询批次属性规则明细
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Page")]
    [Description("WmsBatchRuleDetail/Page")]
    public async Task<SqlSugarPagedList<WmsBatchRuleDetailOutput>> Page(WmsBatchRuleDetailInput input)
    {
        var query = CommonPageFilter(input);
        return await query.OrderBuilder(input, "", "Id").ToPagedListAsync(input.Page, input.PageSize);
    }




    /// <summary>
    /// 分页查询批次属性规则明细 - ly 分组 父子集合
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "PageGroup")]
    [Description("WmsBatchRuleDetail/PageGroup")]
    public async Task<SqlSugarPagedList<WmsBatchRuleDetailOutputGroup>> PageGroup(WmsBatchRuleDetailInput input)
    {
        var BatchList = new SqlSugarPagedList<WmsBatchRuleDetailOutputGroup>();
        var items = new List<WmsBatchRuleDetailOutputGroup>();
        var batchModel = new WmsBatchRuleDetailOutputGroup();
        var WmsBatchRuleModel = await _rep.AsQueryable()
             .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.RuleCode.Contains(input.SearchKey.Trim())
                || u.RuleName.Contains(input.SearchKey.Trim())
            )
            .WhereIF(input.IsDisabled != null, u => u.IsDisabled == input.IsDisabled)
            .WhereIF(!string.IsNullOrWhiteSpace(input.RuleCode), p => p.RuleCode == input.RuleCode)
            .WhereIF(!string.IsNullOrWhiteSpace(input.RuleName), p => p.RuleName == input.RuleName)
            .Select<WmsBatchRuleDetailOutput>().ToListAsync();




        var newList = WmsBatchRuleModel.GroupBy(it => new
        {
            it.RuleCode,
            it.RuleName
        }).Select(s => new
        {
            s.Key.RuleCode
            ,
            s.Key.RuleName

        }).ToList();

        List<WmsBatchRuleDetailOutputGroup> resultList = newList.Adapt<List<WmsBatchRuleDetailOutputGroup>>();
        var groupList = resultList.OrderBy(o=>o.RuleCode).ToPagedList(input.Page, input.PageSize);
        foreach (var item in groupList.Items)
        {
            var detailsList = _rep.AsQueryable().Where(p => p.RuleCode == item.RuleCode).OrderBy(o=>o.Priority).Select<WmsBatchRuleDetailOutput>().ToList();
            ////batchModel.RuleCode = item.RuleCode;
            ////batchModel.RuleName = item.RuleName;
            ////batchModel.WmsBatchRuleDetailOutputsList = detailsList;
            //if (detailsList.Count() > 1)
            //{
            //    item.WmsBatchRuleDetailOutputsList = new List<WmsBatchRuleDetailOutput>()
            //    {
            //         detailsList[0]
            //    };
            //}
            //else
            //{
            //    item.WmsBatchRuleDetailOutputsList = detailsList;

            //}
            ////items.Add(batchModel);
            ///

            //update by liuwq 20240718
            item.WmsBatchRuleDetailOutputsList = detailsList;
        }
        BatchList.Items = items;

        return groupList;



    }



    /// <summary>
    /// 不分页查询批次属性规则明细
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "List")]
    [Description("WmsBatchRuleDetail/List")]
    public async Task<List<WmsBatchRuleDetailOutput>> List([FromQuery] WmsBatchRuleDetailInput input)
    {
        var query = CommonPageFilter(input);
        return await query.OrderBuilder(input, "", "Id").Select<WmsBatchRuleDetailOutput>().ToListAsync();
    }


    /// <summary>
    /// 根据批次规则获取批次规则属性格式
    /// </summary>
    /// <param name="batchRule"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "GetAttrForamtEnumList")]
    [Description("WmsBatchRuleDetail/GetAttrForamtEnumList")]
    public List<EnumOutput> GetAttrForamtEnumList([FromQuery] BatchRuleEnum batchRule)
    {
        return BatchRuleHelper.GetAttrForamtEnumList(batchRule);
    }




    /// <summary>
    /// 不分页分组查询批次属性规则明细
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "GroupList")]
    [Description("WmsBatchRuleDetail/GroupList")]
    public async Task<List<WmsBatchRuleDetailOutput>> GroupList([FromQuery] WmsBatchRuleDetailInput input)
    {
        var query = CommonPageFilter(input);
        return await query.OrderBuilder(input, "", "Id").Select<WmsBatchRuleDetailOutput>().ToListAsync();
    }

    /// <summary>
    /// 增加批次属性规则明细
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Add")]
    [Description("WmsBatchRuleDetail/Add")]
    public async Task<long> Add(List<AddWmsBatchRuleDetailInput> input)
    {
        if (input is null || input.Count == 0)
        {
            throw Oops.Oh("输入参不能为空");
        }
        var dbOrder = await _rep.GetFirstAsync(w => w.RuleCode == input[0].RuleCode);
        if (dbOrder != null)
        {
            throw Oops.Oh($"规则编号{dbOrder.RuleCode}已存在");
        }
        dbOrder = await _rep.GetFirstAsync(w => w.RuleName == input[0].RuleName);
        if (dbOrder != null)
        {
            throw Oops.Oh($"规则名称{dbOrder.RuleName}已存在");
        }
        var warehousDetails = input.Adapt<List<WmsBaseBatchRule>>();

        CheckDetails(warehousDetails);

        foreach (var w in warehousDetails)
        {

            w.IsDisabled = false;
            w.IsDelete = false;
        }

        try
        {
            await _rep.AsTenant().BeginTranAsync();
            await _rep.InsertRangeAsync(warehousDetails);//插入
            await _rep.AsTenant().CommitTranAsync();
        }
        catch
        {
            await _rep.AsTenant().RollbackTranAsync();
            throw;
        }

        return 200;


        //var entity = input.Adapt<WmsBatchRuleDetail>();

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

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

    private static void CheckDetails(List<WmsBaseBatchRule> warehousDetails)
    {
        var index = 0;
        foreach (var w in warehousDetails)
        {
            index++;
            string indexString = $"第{index}行";
            if (w.RuleName == null)
            {
                throw Oops.Oh($"{indexString}规则名称不能为空");
            }

            if (w.BatchRuleType == 0)
            {
                throw Oops.Oh($"{indexString}批次规则不能为空");
            }
            if (w.AttrForamt == 0)
            {
                throw Oops.Oh($"{indexString}属性格式不能为空");
            }
            if (w.InputControl == 0)
            {
                throw Oops.Oh($"{indexString}输入控制不能为空");
            }
            if (!w.Priority.HasValue)
            {
                throw Oops.Oh($"{indexString}优先级不能为空");
            }


            if (w.BatchRuleType == BatchRuleEnum.收货日期 && w.AttrForamt == AttrForamtEnum.字符)
            {
                throw Oops.Oh($"{indexString}批次规则是{BatchRuleEnum.收货日期.GetDescription()}，批次规则属性格式不能是{AttrForamtEnum.字符.GetDescription()}");

            }
            else if (w.BatchRuleType == BatchRuleEnum.物料颜色 && w.AttrForamt != AttrForamtEnum.字符)
            {
                throw Oops.Oh($"{indexString}批次规则是{BatchRuleEnum.物料颜色.GetDescription()}，批次规则属性格式只能是{AttrForamtEnum.字符.GetDescription()}");
            }

        }
    }

    /// <summary>
    /// 删除批次属性规则明细
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Delete")]
    [Description("WmsBatchRuleDetail/Delete")]
    public async Task Delete(DeleteWmsBatchRuleDetailInput input)
    {
        var entity = await _rep.GetFirstAsync(u => u.RuleCode == input.ruleCode) ?? throw Oops.Oh(ErrorCodeEnum.D1002);
        var wmsMaterialentity = await _wmsMaterialRep.GetFirstAsync(u => u.BatchRuleCode == entity.RuleCode && u.IsDelete == false);
        if (wmsMaterialentity != null)
        {
            throw Oops.Oh($"存在绑定关系，不可删除");
        }
        //await _rep.FakeDeleteAsync(entity);   //假删除
        await _rep.DeleteAsync(entity);   //真删除
    }

    /// <summary>
    /// 更新批次属性规则明细
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Update")]
    [Description("WmsBatchRuleDetail/Update")]
    public async Task Update(List<UpdateWmsBatchRuleDetailInput> input)
    {
        if (input is null || input.Count == 0)
        {
            throw Oops.Oh("输入参不能为空");
        }
        var dbOrder = await _rep.GetFirstAsync(w => w.RuleCode == input[0].RuleCode);
        if (dbOrder == null)
        {
            throw Oops.Oh($"规则编号{dbOrder.RuleCode}不存在");
        }

        //直接新增
        var warehousDetails = input.Adapt<List<WmsBaseBatchRule>>();


        //删除旧的数据
        var dbOrderDetails = await _rep.GetListAsync(w => w.RuleCode == input[0].RuleCode);

        CheckDetails(warehousDetails);
        foreach (var w in warehousDetails)
        {
            w.Id = 0;
            w.IsDisabled = false;
            w.IsDelete = false;
        }

        try
        {
            await _rep.AsTenant().BeginTranAsync();
            await _rep.InsertRangeAsync(warehousDetails);
            await _rep.DeleteAsync(dbOrderDetails);
            await _rep.AsTenant().CommitTranAsync();
        }
        catch
        {
            await _rep.AsTenant().RollbackTranAsync();
            throw;
        }

        //var entity = input.Adapt<WmsBatchRuleDetail>();
        ////重复性验证
        //await CheckExist(entity,true);

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

    /// <summary>
    /// 获取批次属性规则明细
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "Detail")]
    [Description("WmsBatchRuleDetail/Detail")]
    public async Task<WmsBaseBatchRule> Detail([FromQuery] QueryByIdWmsBatchRuleDetailInput input)
    {
        return await _rep.GetFirstAsync(u => u.Id == input.Id);
    }






    #region 私有方法

    /// <summary>
    /// 公共查询批次属性规则明细条件
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private ISugarQueryable<WmsBatchRuleDetailOutput> CommonPageFilter(WmsBatchRuleDetailInput input)
    {
        var query = _rep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.RuleCode.Contains(input.SearchKey.Trim())
                || u.RuleName.Contains(input.SearchKey.Trim())
                || u.BatchTag.Contains(input.SearchKey.Trim())
                || u.RFTag.Contains(input.SearchKey.Trim())
                || u.KeyAttr.Contains(input.SearchKey.Trim())
                || u.RuleDesc.Contains(input.SearchKey.Trim())
                || u.CreateUserName.Contains(input.SearchKey.Trim())
                || u.UpdateUserName.Contains(input.SearchKey.Trim())
            )
            .WhereIF(!string.IsNullOrWhiteSpace(input.RuleCode), u => u.RuleCode.Contains(input.RuleCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.RuleCodeAccurate), u => u.RuleCode == input.RuleCodeAccurate) //ly-物料信息页面 精准查询
            .WhereIF(!string.IsNullOrWhiteSpace(input.RuleName), u => u.RuleName.Contains(input.RuleName.Trim()))
            .WhereIF(input.BatchRuleType.HasValue, u => u.BatchRuleType == input.BatchRuleType)
            .WhereIF(!string.IsNullOrWhiteSpace(input.BatchTag), u => u.BatchTag.Contains(input.BatchTag.Trim()))
            .WhereIF(input.AttrForamt.HasValue, u => u.AttrForamt == input.AttrForamt)
            .WhereIF(input.AttrOption.HasValue, u => u.AttrOption == input.AttrOption)
            .WhereIF(input.InputControl.HasValue, u => u.InputControl == input.InputControl)
            .WhereIF(input.Priority.HasValue, u => u.Priority == input.Priority)
            .WhereIF(!string.IsNullOrWhiteSpace(input.RFTag), u => u.RFTag.Contains(input.RFTag.Trim()))
            .WhereIF(input.RFShow.HasValue, u => u.RFShow == input.RFShow)
            .WhereIF(!string.IsNullOrWhiteSpace(input.KeyAttr), u => u.KeyAttr.Contains(input.KeyAttr.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.RuleDesc), u => u.RuleDesc.Contains(input.RuleDesc.Trim()))
            .WhereIF(input.IsDisabled.HasValue, u => u.IsDisabled == input.IsDisabled)
            .Select<WmsBatchRuleDetailOutput>();
        return query;
    }

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



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


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

    /// <summary>
    /// 根据组合校验和单独校验验证数据是否已存在-导入时验证
    /// </summary>
    /// <param name="inputs"></param>
    /// <returns></returns>
    private async Task CheckExisitForImport(List<WmsBaseBatchRule> inputs)
    {
        if (inputs?.Count <= 0)
        {
            throw Oops.Oh($"导入数据不能为空");
        }
        //根据组合校验验证表格中中是否已存在相同数据  








        //根据单独校验验证表格中中是否已存在相同数据  



    }
    #endregion

}