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.SysDto;
using SqlSugar;
using Utility;
using WMS.DAL;
using WMS.Entity.Context;
using WMS.Entity.SysEntity;
using WMS.IBLL.ISysServer;
using WMS.IDAL.ISysInterface;

namespace WMS.BLL.SysServer
{
    public class MaterialsServer : DbHelper<SysMaterialCategory>, 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 Task<List<MaterialsDto>> GetMateList(string skuNo, string skuName, string auditStatusNo, string type, string isControlled, string isInspect, string environment, string categoryNo)
        {
            var DA =  Db.Queryable<SysMaterials>()
                     .LeftJoin<SysUserInfor>((a, b) => a.CreateUser == b.Id)
                     .LeftJoin<SysPackag>((a, b,c) => a.PackagNo == c.PackagNo)
                     //.LeftJoin<SysUnit> ((a,b,c,d)=>a.UnitNo == d.UnitNo)
                     .LeftJoin<SysMaterialCategory>((a,b,c,d)=>a.CategoryNo == d.CategoryNo)
                     .Where((a,b,c,d) => a.IsDel == "0" && d.IsDel == "0" )
                     .WhereIF(!string.IsNullOrEmpty(skuNo), a => a.SkuNo.Contains(skuNo))
                     .WhereIF(!string.IsNullOrEmpty(skuName), a => a.SkuName.Contains(skuName))
                     .WhereIF(!string.IsNullOrEmpty(auditStatusNo), a => a.AuditStatusNo == auditStatusNo)
                     .WhereIF(!string.IsNullOrEmpty(type), a => a.Type == type)
                     .WhereIF(!string.IsNullOrEmpty(isControlled), a => a.IsControlled == isControlled)
                     .WhereIF(!string.IsNullOrEmpty(isInspect), a => a.IsInspect == isInspect)
                     .WhereIF(!string.IsNullOrEmpty(environment), a => a.Environment == environment)
                     .WhereIF(!string.IsNullOrEmpty(categoryNo), a => a.CategoryNo == categoryNo)
                     .Select<MaterialsDto>((a, b, c,d) => new MaterialsDto() { CreateUserName = b.RealName,PackagName = c.PackagName }, true)
                     .ToListAsync();
            return DA;
        }

        /// <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()
        {
            return await Db.Queryable<SysPackag>().Where(s => s.IsDel == "0").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
    }
}