using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using AutoMapper;
using Model.InterFaceModel;
using Model.ModelDto.BllSoDto;
using Model.ModelDto.SysDto;
using Model.ModelVm.SysVm;
using SqlSugar;
using Utility;
using WMS.DAL;
using WMS.Entity.BllSoEntity;
using WMS.Entity.Context;
using WMS.Entity.SysEntity;
using WMS.IBLL.ISysServer;
using WMS.IDAL.ISysInterface;

namespace WMS.BLL.SysServer
{
    public class MaterialsServer : DbHelper<SysMaterials>, IMaterialsServer
    {
        /// <summary>
        /// 依赖注入
        /// </summary>
        public IMaterialsRepository _mate { get; set; }
        private readonly IMapper _mapper;
        private static readonly SqlSugarScope Db = DataContext.Db;
        private readonly UserManager _userManager;
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="mate">物料编码</param>
        /// <param name="mapper">automapper</param>
        public MaterialsServer(IMaterialsRepository mate, IMapper mapper, UserManager userManager) : base(Db)
        {
            _mate = mate; //物料编码
            _mapper = mapper; //automapper
            _userManager = userManager;
        }

        #region wms

        /// <summary>
        /// 获取物料信息列表
        /// </summary>
        /// <param name="skuNo">物料编码</param>
        /// <param name="skuName">物料名称</param>
        /// <param name="auditStatusNo">审核状态</param>
        /// <param name="type">类型</param>
        /// <param name="isControlled">是否受控</param>
        /// <param name="isInspect">是否免检</param>
        /// <param name="environment">存储环境</param>
        /// <param name="categoryNo">类别编码</param>
        /// <returns></returns>
        public async Task<List<MaterialsDto>> GetMateList(GetMaterialsVm model, RefAsync<int> count)
        {
            Expression<Func<SysMaterials, bool>> item = Expressionable.Create<SysMaterials>()
             .AndIF(!string.IsNullOrWhiteSpace(model.SkuNo), it => it.SkuNo.Contains(model.SkuNo.Trim()))
             .AndIF(!string.IsNullOrWhiteSpace(model.SkuName), it => it.SkuName.Contains(model.SkuName.Trim()))
             .AndIF(!string.IsNullOrWhiteSpace(model.AuditStatusNo), it => it.AuditStatusNo == model.AuditStatusNo)
             .AndIF(!string.IsNullOrWhiteSpace(model.Type), it => it.Type == model.Type)
             .AndIF(!string.IsNullOrWhiteSpace(model.IsControlled), it => it.IsControlled == model.IsControlled)
             .AndIF(!string.IsNullOrWhiteSpace(model.IsInspect), it => it.IsInspect == model.IsInspect)
             .AndIF(!string.IsNullOrWhiteSpace(model.Environment), it => it.Environment == model.Environment)
             .AndIF(!string.IsNullOrWhiteSpace(model.CategoryNo), it => it.CategoryNo == model.CategoryNo)
             .And(it => it.IsDel == "0")
             .ToExpression();//注意 这一句 不能少
            //Db.Aop.OnLogExecuting = (sql, data) =>
            //{
            //    var nl = sql;
            //};
            var data = await GetAllWhereAsync(item)
               .LeftJoin<SysUserInfor>((a, b) => a.CreateUser == b.Id && b.IsDel == "0")
               .LeftJoin<SysPackag>((a, b, c) => a.PackagNo == c.PackagNo && c.IsDel == "0")
               .LeftJoin<SysMaterialCategory>((a, b, c, d) => a.CategoryNo == d.CategoryNo && d.IsDel == "0")
               .Select((a, b, c, d) => new MaterialsDto()
               {
                   Id = a.Id,
                   SkuNo = a.SkuNo,
                   SkuName = a.SkuName,
                   Standard = a.Standard,
                   Type = a.Type,
                   IsControlled = a.IsControlled,
                   IsInspect = a.IsInspect,
                   IsPasteCode = a.IsPasteCode,
                   Origin = a.Origin,
                   UnitNo = a.UnitNo,
                   PackagName = c.PackagName,
                   Environment = a.Environment,
                   CategoryNo = d.CategoryNo,
                   Weight = a.Weight,
                   Warranty = a.Warranty,
                   UnpackWarranty = a.UnpackWarranty,
                   AdventTime = a.AdventTime,
                   LowInventory = a.LowInventory,
                   Demo = a.Demo,
                   CreateUserName = b.UserName,
                   CreateTime = a.CreateTime
               })
               .Distinct()
               .OrderByDescending(a => a.CreateTime)
               .ToPageListAsync(model.Page, model.Limit, count);

            return data;
        }

        /// <summary>
        /// 根据id查询物料信息
        /// </summary>
        /// <param name="id">物料id</param>
        /// <returns></returns>
        public async Task<SysMaterials> GetMateById(int id)
        {
            return await Db.Queryable<SysMaterials>().FirstAsync(s => s.Id == id);
        }

        /// <summary>
        /// 根据编号查询物料信息
        /// </summary>
        /// <param name="SkuNo">物料编号</param>
        /// <returns></returns>
        public async Task<int> GetMateByNo(string SkuNo)
        {
            return await Db.Queryable<SysMaterials>().CountAsync(s => s.SkuNo == SkuNo && s.IsDel == "0");
        }


        /// <summary>
        /// 根据编号查询物料信息
        /// </summary>
        /// <param name="PackagNo">包装编号</param>
        /// <returns></returns>
        public async Task<int> GetMateByPa(string PackagNo)
        {
            return await Db.Queryable<SysMaterials>().CountAsync(s => s.PackagNo == PackagNo && s.IsDel == "0");
        }
        /// <summary>
        /// 新增物料信息
        /// </summary>
        /// <param name="matedto">物料dto</param>
        /// <returns></returns>
        /// <exception cref="Exception">捕获异常</exception>
        public async Task<int> AddMate(MaterialsDto matedto)
        {
            if (string.IsNullOrWhiteSpace(matedto.PackagNo))
                throw Oops.Bah("包装信息不能为空");
            if (await GetMateByNo(matedto.SkuNo) > 0)
                throw Oops.Bah("系统中已存在该物料");
            //映射模型
            SysMaterials mate = _mapper.Map<SysMaterials>(matedto);
            mate.AuditStatusNo = "9"; //审核状态
            mate.Type = mate.Type; //类型
            mate.IsControlled = string.IsNullOrWhiteSpace(mate.IsControlled) ? "0" : mate.IsControlled; //是否受控
            mate.IsInspect = string.IsNullOrWhiteSpace(mate.IsInspect) ? "0" : mate.IsInspect; //是否免检
            mate.IsPasteCode = string.IsNullOrWhiteSpace(mate.IsPasteCode) ? "0" : mate.IsPasteCode; //是否免检
            mate.Origin = "WMS"; //来源
            mate.IsDel = "0";
            mate.CreateTime = DateTime.Now;
            mate.CreateUser = _userManager.UserId;
            return await Db.Insertable(mate).ExecuteCommandAsync();
        }

        /// <summary>
        /// 删除物料信息
        /// </summary>
        /// <param name="mate">物料实体模型</param>
        /// <returns></returns>
        /// <exception cref="Exception">捕获异常</exception>
        public async Task<int> DelMate(SysMaterials mate)
        {
            return await Db.Updateable<SysMaterials>()
                           .Where(s => s.Id == mate.Id)
                           .SetColumns(s => s.IsDel == "1")
                           .SetColumns(s => s.UpdateTime == DateTime.Now)
                           .SetColumns(s => s.UpdateUser == _userManager.UserId)
                           .ExecuteCommandAsync();
        }

        /// <summary>
        /// 编辑物料信息
        /// </summary>
        /// <param name="matedto">物料dto</param>
        /// <returns></returns>
        /// <exception cref="Exception">捕获异常</exception>
        public async Task<int> ExitMate(MaterialsDto matedto)
        {
            if (matedto.AdventTime > 365 && matedto.AdventTime < 30)
            {
                throw Oops.Bah("临期天数不可大于365及小于30");
            }
            else if (string.IsNullOrWhiteSpace(matedto.PackagNo))
            {
                throw Oops.Bah("包装不能为空");
            }
            //映射模型
            SysMaterials mate = _mapper.Map<SysMaterials>(matedto);
            //编辑
            //根据id获取物料信息
            var modMaterial = await Db.Queryable<SysMaterials>().FirstAsync(a => a.IsDel == "0" && a.Id == mate.Id);
            //mate.CategoryNo = list.CategoryNo;
            mate.Origin = modMaterial.Origin;
            mate.CreateUser = modMaterial.CreateUser;
            mate.UpdateTime = DateTime.Now;
            mate.UpdateUser = _userManager.UserId;
            mate.CreateTime = modMaterial.CreateTime;
            int i = Db.Updateable(mate).ExecuteCommand();
            return i;
        }

        #region 包装 单位

        /// <summary>
        /// 获取计量单位信息列表
        /// </summary>
        /// <returns></returns>
        public async Task<List<SysUnit>> GetUnitList()
        {
            return await Db.Queryable<SysUnit>().Where(s => s.IsDel == "0").ToListAsync();
        }

        /// <summary>
        /// 获取包装信息列表
        /// </summary>
        /// <returns></returns>
        public async Task<List<SysPackag>> GetPackagList(int page)
        {
            int pageSize = 3000;
            int skipCount = pageSize * (page - 1);
            return await Db.Queryable<SysPackag>().Where(s => s.IsDel == "0").Skip(skipCount).Take(pageSize).ToListAsync();
        }

        #endregion

        #endregion

        #region erp
        
        /// <summary>
        /// 获取erp数据
        /// </summary>
        /// <returns></returns>
        public List<ERPTestDto> GetERPList()
        {
            List<ERPTestDto> list = _mate.GetERPList();
            return list;
        }

        /// <summary>
        /// 根据id获取erp数据
        /// </summary>
        /// <param name="id">id</param>
        /// <returns></returns>
        public SysERPTest GetERPListById(int id)
        {
            SysERPTest erp = _mate.GetERPListById(id);
            return erp;
        }

        /// <summary>
        /// 新增erp数据
        /// </summary>
        /// <param name="erpdto">erp测试dto</param>
        /// <returns></returns>
        /// <exception cref="Exception">捕获异常</exception>
        public async Task<int> AddERP(ERPTestDto erpdto)
        {
            //捕获异常
            try
            {
                //模型映射
                SysERPTest erp = _mapper.Map<SysERPTest>(erpdto);
                //判断是否唯一
                //新增
                int i = await _mate.AddERP(erp);
                return i;
            }
            catch (Exception ex)
            {
                //抛出异常
                throw new Exception("新增erp数据异常", ex);
            }
        }

        /// <summary>
        /// 删除erp信息
        /// </summary>
        /// <param name="erp">erp测试实体</param>
        /// <returns></returns>
        /// <exception cref="Exception">捕获异常</exception>
        public async Task<int> DelERP(SysERPTest erp)
        {
            //捕获异常
            try
            {
                //删除
                int i = await _mate.DelERP(erp);
                return i;
            }
            catch (Exception ex)
            {
                //抛出异常
                throw new Exception("删除erp异常", ex);
            }
        }

        /// <summary>
        /// 编辑erp数据
        /// </summary>
        /// <param name="erpdto">erp测试dto</param>
        /// <returns></returns>
        /// <exception cref="Exception">捕获异常</exception>
        public async Task<int> EditERP(ERPTestDto erpdto)
        {
            //捕获异常
            try
            {
                //模型映射
                SysERPTest erp = _mapper.Map<SysERPTest>(erpdto);
                //编辑
                int i = await _mate.EditERP(erp);
                return i;
            }
            catch (Exception ex)
            {
                //抛出异常
                throw new Exception("编辑erp数据异常", ex);
            }
        }

        #endregion

        #region sap

        /// <summary>
        /// SAP新增物料主数据数据
        /// </summary>
        /// <param name="model">erp实体</param>
        /// <returns></returns>
        /// <exception cref="Exception">捕获异常</exception>
        public async Task<string> AddSkuSap(SendSkuInfoVm model)
        {
            //捕获异常
            try
            {
                if (string.IsNullOrWhiteSpace(model.skuNo.ToString()) || string.IsNullOrWhiteSpace(model.skuName) || string.IsNullOrWhiteSpace(model.categoryNo))
                {
                    throw new Exception("参数错误");
                }
                //判断是否唯一
                var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == model.skuNo.ToString());
                if (sku != null)
                {
                    throw new Exception("当前物料已存在");
                }
                //开启事务
                Db.BeginTran();

                var category = Db.Queryable<SysMaterialCategory>().First(w => w.IsDel == "0" && w.CategoryNo == model.categoryNo);
                if (category == null)
                {
                    category = new SysMaterialCategory()
                    {
                        CategoryNo = model.categoryNo,
                        CategoryName = model.categoryName,
                        CreateUser = 1
                    };
                    //添加物料类别信息
                    Db.Insertable(category).ExecuteCommand();
                }
                var pack = new SysPackag()
                {
                    PackagNo = model.skuNo.ToString(),
                    PackagName = model.skuName,
                    L1Num = 1,
                    L1Name = model.unit,
                    L2Num = Convert.ToInt32(model.packageQty),
                    L2Name = model.packageName
                };
                //添加包装信息
                Db.Insertable(pack).ExecuteCommand();

                var addSku = new SysMaterials()
                {
                    SkuNo = model.skuNo.ToString(),
                    SkuName = model.skuName,
                    Standard = model.specification,
                    CategoryNo = category.CategoryNo,
                    AuditStatusNo = "9", //model.AuditStatusNo
                    Type = "0",
                    IsControlled = "0",//是否请验，0：是 1：否
                    IsInspect = model.consume.ToString() == "0" ? "1" : "0",
                    IsPasteCode = "1",
                    Origin = "SAP",
                    UnitNo = model.unit,
                    PackagNo = pack.PackagNo,
                    Environment = null,
                    Weight = null,
                    Warranty = Convert.ToInt32(model.shelfLife.Trim()),
                    UnpackWarranty = null,
                    Price = null,
                    AdventTime = Convert.ToInt32(model.remainingDays)
                };
                await Db.Insertable(addSku).ExecuteCommandAsync();

                //提交事务
                Db.CommitTran();

                return "0";
            }
            catch (Exception ex)
            {
                //回滚事务
                Db.RollbackTran();
                //抛出异常
                throw new Exception("新增erp数据异常", ex);
            }
        }
        #endregion
    }
}