using Microsoft.EntityFrameworkCore.Storage;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WMS.Web.Core.Dto.Login;
using WMS.Web.Core.Internal.Results;
using WMS.Web.Domain.Entitys;
using WMS.Web.Domain.Infrastructure;
using WMS.Web.Domain.IService;
using WMS.Web.Domain.IService.Public;
using WMS.Web.Domain.Values;
using WMS.Web.Domain.Values.Single;

namespace WMS.Web.Domain.Services
{
    /// <summary>
    /// 序列号服务
    /// </summary>
    public class SerialNumberService : ISerialNumberService
    {
        private readonly ISerialNumberOperateRepositories _serialNumberOperateRepositories;
        private readonly ISerialNumbersRepositories _serialNumbersRepositories;
        public readonly IBasicsRepositories _transactionRepositories;
        public readonly IBoxRepositories _boxRepositories;
        private readonly ISingleDataService _singleDataService;
        private readonly IErpService _erpService;
        public SerialNumberService(ISerialNumberOperateRepositories serialNumberOperateRepositories,
            ISerialNumbersRepositories serialNumbersRepositories, IBasicsRepositories transactionRepositories,
            IBoxRepositories boxRepositories, ISingleDataService singleDataService, IErpService erpService)
        {
            _serialNumberOperateRepositories = serialNumberOperateRepositories;
            _serialNumbersRepositories = serialNumbersRepositories;
            _transactionRepositories = transactionRepositories;
            _boxRepositories = boxRepositories;
            _singleDataService = singleDataService;
            _erpService = erpService;
        }
        /// <summary>
        /// 改箱
        /// </summary>
        /// <param name="changeBoxRecords"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> ChangeBox(List<ChangeBoxRecord> changeBoxRecords, LoginInDto loginInfo, bool isTransaction = true)
        {
            //获取序列号信息
            var serialNumbers = changeBoxRecords.SelectMany(s => s.SerialNumbers).ToList();
            var entityList = await _serialNumbersRepositories.GetEntityList(serialNumbers);
            var boxIds = changeBoxRecords.Select(s => s.DestBoxId).ToList();
            var boxList = await _boxRepositories.GetEntityList(boxIds);
            var userName = _singleDataService.GetSingleData(SingleAction.Staffs, loginInfo.UserInfo.CompanyId, loginInfo.UserInfo.StaffId);
            IDbContextTransaction _transaction = null;
            if (isTransaction)
                _transaction = _transactionRepositories.GetTransaction();
            bool isRollback = false;
            bool isSuccess = true;
            List<SerialNumberOperate> sList = new List<SerialNumberOperate>();
            foreach (var entity in entityList)
            {
                var destBox = changeBoxRecords.FirstOrDefault(f => f.SerialNumbers.Contains(entity.SerialNumber));
                var box = boxList.FirstOrDefault(f => f.Id == destBox.DestBoxId);
                //修改序列号和箱绑定关系
                entity.Bind(destBox.DestBoxId, box.CompleteCartonTime);


                //记录序列号操作日志
                SerialNumberOperate op = new SerialNumberOperate()
                {
                    MaterialId = entity.MaterialId,
                    SerialNumber = entity.SerialNumber,
                    OrgId = box.OrgId,
                    SupplierId = box.SupplierId,
                    OperateTime = DateTime.Now,
                    OperateType = SerialNumberOperateType.ChangeBox,
                    OperateUser = userName,
                    Remark = "单号:" + destBox.BillNo + "\r\n" + "箱号:" + box.BoxBillNo
                };
                //取目标箱子仓位 记录目标箱仓位号
                //if (moveBoxRecord.Type == MoveBoxType.Up)
                //{
                //var srcSubStock = _singleDataService.GetSingleData(SingleAction.SubStocks, loginInfo.UserInfo.CompanyId, moveBoxRecord.DestSubStockId);
                //op.Remark += "\r\n" + "仓位:" + srcSubStock;
                //}
                sList.Add(op);
            }
            isSuccess = await _serialNumbersRepositories.EditEntityList(entityList, false);
            //序列号操作记录
            var res = await this.SerialNumberOperate(sList, false);
            //提交事务
            if (isTransaction)
            {
                if (!isSuccess) isRollback = true;
                if (!res.Success) isRollback = true;
                isSuccess = _transactionRepositories.CommitTransaction(isRollback, _transaction);
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            if (!res.Success) return Result.ReFailure(ResultCodes.DateWriteError);

            return Result.ReSuccess();
        }
        /// <summary>
        /// 移箱
        /// </summary>
        /// <param name="moveBoxRecords"></param>
        /// <param name="loginInfo"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> MoveBox(List<MoveBoxRecord> moveBoxRecords, LoginInDto loginInfo, bool isTransaction = true)
        {
            //获取序列号信息
            var boxids = moveBoxRecords.Select(s => s.BoxId).ToList();
            var entityList = await _serialNumbersRepositories.GetEntityListByBoxIds(boxids);
            var boxList = await _boxRepositories.GetEntityList(boxids);
            var userName = _singleDataService.GetSingleData(SingleAction.Staffs, loginInfo.UserInfo.CompanyId, loginInfo.UserInfo.StaffId);

            IDbContextTransaction _transaction = null;
            if (isTransaction)
                _transaction = _transactionRepositories.GetTransaction();
            bool isRollback = false;
            bool isSuccess = true;
            List<SerialNumberOperate> sList = new List<SerialNumberOperate>();
            foreach (var entity in entityList)
            {
                var box = boxList.FirstOrDefault(f => f.Id == entity.BoxId);
                var moveBoxRecord = moveBoxRecords.FirstOrDefault(f => f.BoxId == entity.BoxId);
                //修改序列号和箱绑定关系
                //entity.Bind(moveBoxRecord.BoxId);

                //记录序列号操作日志
                SerialNumberOperate op = new SerialNumberOperate()
                {
                    MaterialId = entity.MaterialId,
                    SerialNumber = entity.SerialNumber,
                    OrgId = box.OrgId,
                    SupplierId = box.SupplierId,
                    OperateTime = DateTime.Now,
                    OperateType = moveBoxRecord.Type == MoveBoxType.Up ? SerialNumberOperateType.MoveBox_Up : SerialNumberOperateType.MoveBox_Down,
                    OperateUser = userName,
                    Remark = "单号:" + moveBoxRecord.BillNo + "\r\n" + "箱号:" + box.BoxBillNo
                };
                if (moveBoxRecord.Type == MoveBoxType.Up)
                {
                    var srcSubStock = _singleDataService.GetSingleData(SingleAction.SubStocks, loginInfo.UserInfo.CompanyId, moveBoxRecord.DestSubStockId);
                    op.Remark += "\r\n" + "仓位:" + srcSubStock;
                }
                sList.Add(op);
            }
            isSuccess = await _serialNumbersRepositories.EditEntityList(entityList, false);
            //序列号操作记录
            var res = await this.SerialNumberOperate(sList, false);
            //提交事务
            if (isTransaction)
            {
                if (!isSuccess) isRollback = true;
                if (!res.Success) isRollback = true;
                isSuccess = _transactionRepositories.CommitTransaction(isRollback, _transaction);
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            if (!res.Success) return Result.ReFailure(ResultCodes.DateWriteError);

            return Result.ReSuccess();
        }
        /// <summary>
        /// 出库
        /// </summary>
        /// <param name="outStock"></param>
        /// <param name="loginInfo"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> OutStock(OutStock outStock, LoginInDto loginInfo, bool isTransaction = true)
        {
            //获取序列号信息
            var serialNumbers = outStock.Details.SelectMany(s => s.SerialNumbers).ToList();
            var entityList = await _serialNumbersRepositories.GetEntityList(serialNumbers);
            var boxIds = entityList.Select(s => s.BoxId).ToList();
            var boxList = await _boxRepositories.GetEntityList(boxIds);
            var userName = _singleDataService.GetSingleData(SingleAction.Staffs, loginInfo.UserInfo.CompanyId, loginInfo.UserInfo.StaffId);

            IDbContextTransaction _transaction = null;
            if (isTransaction)
                _transaction = _transactionRepositories.GetTransaction();
            bool isRollback = false;
            bool isSuccess = true;
            List<SerialNumberOperate> sList = new List<SerialNumberOperate>();
            foreach (var entity in entityList)
            {
                var box = boxList.FirstOrDefault(f => f.Id == entity.BoxId);
                var outstockDetail = outStock.Details.FirstOrDefault(f => f.MaterialId == entity.MaterialId);
                if (outstockDetail == null) continue;
                //修改序列号和箱绑定关系
                entity.OutStock(outStock, entity.MaterialId);

                //记录序列号操作日志
                SerialNumberOperate op = new SerialNumberOperate()
                {
                    MaterialId = entity.MaterialId,
                    SerialNumber = entity.SerialNumber,
                    OrgId = box.OrgId,
                    SupplierId = box.SupplierId,
                    OperateTime = DateTime.Now,
                    OperateType = OutStockTypeConvert(outStock.Type),
                    OperateUser = userName,
                    Remark = "来源单号:" + string.Join(",", outstockDetail.ErpDetails.Select(s => s.SourceBillNo)) + "\r\n" + "出库单号:" + outStock.BillNo
                };
                if (outStock.Type == OutStockType.Sal)
                {
                    var detail = outStock.Details.FirstOrDefault(f => f.MaterialId == entity.MaterialId);
                    var res_c = await _erpService.BillQueryForCustomer();
                    var customer = res_c.Data.FirstOrDefault(f => f.Id == outStock.ReceiptCustomerId);
                    op.Remark += "\r\n" + "销售订单号:" + string.Join(",", detail.ErpDetails.Select(s => s.SaleBillNo));
                    op.Remark += "\r\n" + "客户:" + customer?.Name;
                }
                sList.Add(op);
            }
            isSuccess = await _serialNumbersRepositories.EditEntityList(entityList, false);
            //序列号操作记录
            var res = await this.SerialNumberOperate(sList, false);
            //提交事务
            if (isTransaction)
            {
                if (!isSuccess) isRollback = true;
                if (!res.Success) isRollback = true;
                isSuccess = _transactionRepositories.CommitTransaction(isRollback, _transaction);
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            if (!res.Success) return Result.ReFailure(ResultCodes.DateWriteError);

            return Result.ReSuccess();
        }
        /// <summary>
        /// 出库单类型转化序列号记录类型
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        private SerialNumberOperateType OutStockTypeConvert(OutStockType type)
        {
            switch (type)
            {
                case OutStockType.Sal:
                    return SerialNumberOperateType.Sal_Out;
                case OutStockType.Assembled:
                    return SerialNumberOperateType.Assembled_Out;
                case OutStockType.Miscellaneous:
                    return SerialNumberOperateType.Miscellaneous_Out;
                case OutStockType.Stkdirecttransfers:
                    return SerialNumberOperateType.Stkdirecttransfers_Out;
                case OutStockType.StktransferInst:
                    return SerialNumberOperateType.StktransferInst_Out;
                default:
                    return SerialNumberOperateType.StktransferInst_Out;
            }
        }
        /// <summary>
        /// 出库单类型转化序列号记录类型
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        private SerialNumberOperateType InStockTypeConvert(InstockType type)
        {
            switch (type)
            {
                case InstockType.Purchase:
                    return SerialNumberOperateType.Purchase_In;
                case InstockType.Assembled:
                    return SerialNumberOperateType.Assembled_In;
                case InstockType.Miscellaneous:
                    return SerialNumberOperateType.Miscellaneous_In;
                case InstockType.Stkdirecttransfers:
                    return SerialNumberOperateType.Stkdirecttransfers_In;
                case InstockType.StktransferInst:
                    return SerialNumberOperateType.StktransferInst_In;
                default:
                    return SerialNumberOperateType.StktransferInst_In;
            }
        }

        /// <summary>
        /// 序列号操作记录日志
        /// </summary>
        /// <param name="list"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SerialNumberOperate(List<SerialNumberOperate> list, bool isTransaction = true)
        {
            var isSuccess = await _serialNumberOperateRepositories.AddRange(list, isTransaction);
            if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            return Result.ReSuccess();
        }
        /// <summary>
        /// 入库
        /// </summary>
        /// <param name="inStock"></param>
        /// <param name="loginInfo"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> InStock(InStock inStock, LoginInDto loginInfo, bool isTransaction = true)
        {
            //获取序列号信息
            var serialNumbers = inStock.Details.SelectMany(s => s.SerialNumbers).ToList();
            var entityList = await _serialNumbersRepositories.GetEntityList(serialNumbers);
            var boxIds = entityList.Select(s => s.BoxId).ToList();
            var boxList = await _boxRepositories.GetEntityList(boxIds);
            var userName = _singleDataService.GetSingleData(SingleAction.Staffs, loginInfo.UserInfo.CompanyId, loginInfo.UserInfo.StaffId);

            IDbContextTransaction _transaction = null;
            if (isTransaction)
                _transaction = _transactionRepositories.GetTransaction();
            bool isRollback = false;
            bool isSuccess = true;
            List<SerialNumberOperate> sList = new List<SerialNumberOperate>();
            foreach (var entity in entityList)
            {
                var box = boxList.FirstOrDefault(f => f.Id == entity.BoxId);
                var instockDetail = inStock.Details.FirstOrDefault(f => f.MaterialId == entity.MaterialId);
                var subStock = _singleDataService.GetSingleData(SingleAction.SubStocks, loginInfo.UserInfo.CompanyId, inStock.SubStockId);
                //修改序列号和箱绑定关系
                entity.InStock(instockDetail.SourceBillNo, inStock.Type);

                //记录序列号操作日志
                SerialNumberOperate op = new SerialNumberOperate()
                {
                    MaterialId = entity.MaterialId,
                    SerialNumber = entity.SerialNumber,
                    OrgId = box.OrgId,
                    SupplierId = box.SupplierId,
                    OperateTime = DateTime.Now,
                    OperateType = InStockTypeConvert(inStock.Type),
                    OperateUser = userName,
                    Remark = "来源单号:" + inStock.Details.First().SourceBillNo
                    + "\r\n" + "入库单号:" + inStock.BillNo
                    + "\r\n" + "仓位号:" + subStock
                };
                sList.Add(op);
            }
            isSuccess = await _serialNumbersRepositories.EditEntityList(entityList, false);
            //序列号操作记录
            var res = await this.SerialNumberOperate(sList, false);
            //提交事务
            if (isTransaction)
            {
                if (!isSuccess) isRollback = true;
                if (!res.Success) isRollback = true;
                isSuccess = _transactionRepositories.CommitTransaction(isRollback, _transaction);
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            if (!res.Success) return Result.ReFailure(ResultCodes.DateWriteError);

            return Result.ReSuccess();
        }
        /// <summary>
        /// 出入库回退
        /// </summary>
        /// <param name="backRecord"></param>
        /// <param name="loginInfo"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> BackRecord(BackRecord backRecord, LoginInDto loginInfo, bool isTransaction = true)
        {
            //获取序列号信息
            var serialNumbers = backRecord.Details.SelectMany(s => s.SerialNumbers).ToList();
            var entityList = await _serialNumbersRepositories.GetEntityList(serialNumbers);
            var boxIds = entityList.Select(s => s.BoxId).ToList();
            var boxList = await _boxRepositories.GetEntityList(boxIds);
            var userName = _singleDataService.GetSingleData(SingleAction.Staffs, loginInfo.UserInfo.CompanyId, loginInfo.UserInfo.StaffId);

            IDbContextTransaction _transaction = null;
            if (isTransaction)
                _transaction = _transactionRepositories.GetTransaction();
            bool isRollback = false;
            bool isSuccess = true;
            List<SerialNumberOperate> sList = new List<SerialNumberOperate>();
            foreach (var entity in entityList)
            {
                var box = boxList.FirstOrDefault(f => f.Id == entity.BoxId);
                var detail = backRecord.Details.FirstOrDefault(w => w.SerialNumbers.Contains(entity.SerialNumber));

                //if (backRecord.Type == BackRecordType.InstockOff)
                //    entity.UnBind();
                if (backRecord.Type == BackRecordType.OutstockOn)
                    entity.Bind(detail.BoxId, box.CompleteCartonTime);


                //记录序列号操作日志
                SerialNumberOperate op = new SerialNumberOperate()
                {
                    MaterialId = entity.MaterialId,
                    SerialNumber = entity.SerialNumber,
                    OrgId = box.OrgId,
                    SupplierId = box.SupplierId,
                    OperateTime = DateTime.Now,
                    OperateType = backRecord.Type == BackRecordType.InstockOff ?
                    SerialNumberOperateType.BackRecord_Off : SerialNumberOperateType.BackRecord_On,
                    OperateUser = userName,
                    Remark = "单号:" + backRecord.BillNo
                    + "\r\n" + "箱号:" + box.BoxBillNo
                };
                if (backRecord.Type == BackRecordType.OutstockOn)
                {
                    var subStockId = backRecord?.SubStockId ?? 0;
                    var srcSubStock = _singleDataService.GetSingleData(SingleAction.SubStocks, loginInfo.UserInfo.CompanyId, subStockId);
                    op.Remark += "\r\n" + "仓位:" + srcSubStock;
                }
                sList.Add(op);
            }

            isSuccess = await _serialNumbersRepositories.EditEntityList(entityList, false);
            //序列号操作记录
            var res = await this.SerialNumberOperate(sList, false);
            //提交事务
            if (isTransaction)
            {
                if (!isSuccess) isRollback = true;
                if (!res.Success) isRollback = true;
                isSuccess = _transactionRepositories.CommitTransaction(isRollback, _transaction);
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            if (!res.Success) return Result.ReFailure(ResultCodes.DateWriteError);

            return Result.ReSuccess();
        }
        /// <summary>
        /// 盘点
        /// </summary>
        /// <param name="takeStocks"></param>
        /// <param name="loginInfo"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> TakeStock(List<TakeStock> takeStocks, LoginInDto loginInfo, bool isTransaction = true)
        {
            var serialNumbers = takeStocks.SelectMany(s => s.Details).SelectMany(s => s.SerialNumbers).ToList();
            var entityList = await _serialNumbersRepositories.GetEntityList(serialNumbers);
            var boxIds = entityList.Select(s => s.BoxId).ToList();
            var boxList = await _boxRepositories.GetEntityList(boxIds);

            List<Box> box_New_List = new List<Box>();
            List<SerialNumberOperate> soList = new List<SerialNumberOperate>();
            List<SerialNumbers> sList = new List<SerialNumbers>();
            foreach (var s in serialNumbers)
            {
                var takeStockDetail = takeStocks.SelectMany(s => s.Details).FirstOrDefault(w => w.SerialNumbers.Contains(s));
                if (takeStockDetail == null) continue;
                var box = boxList.FirstOrDefault(f => f.Id == takeStockDetail.BoxId);
                var s_entity = entityList.FirstOrDefault(f => f.SerialNumber.Equals(s));
                if (box != null && box.Details.FirstOrDefault(f => f.MaterialId == takeStockDetail.MaterialId) == null)
                {
                    //如果这个物料不存在箱箱信息 添加进去
                    box.TakeStock(takeStockDetail.MaterialId, takeStockDetail.AfterQty);
                    box_New_List.Add(box);
                }

                if (s_entity == null)
                {
                    //序列号
                    SerialNumbers s_new = new SerialNumbers(s, takeStockDetail.MaterialId, takeStockDetail.Id, 0, "", DateTime.Now, DateTime.Now);
                    sList.Add(s_new);
                }
                else
                {
                    s_entity.BoxId = takeStockDetail.BoxId;

                    var takeStock = takeStocks.FirstOrDefault(w => w.Details.FirstOrDefault(w => w.SerialNumbers.Contains(s)) != null);
                    //记录序列号操作日志
                    SerialNumberOperate op = new SerialNumberOperate()
                    {
                        MaterialId = takeStockDetail.MaterialId,
                        SerialNumber = s,
                        OrgId = box.OrgId,
                        SupplierId = box.SupplierId,
                        OperateTime = DateTime.Now,
                        OperateType = SerialNumberOperateType.TakeStock,
                        OperateUser = "",
                        Remark = "单号:" + takeStock.BillNo + "\r\n" + "箱号:" + box.BoxBillNo
                    };
                    soList.Add(op);
                }
            }

            IDbContextTransaction _transaction = null;
            if (isTransaction)
                _transaction = _transactionRepositories.GetTransaction();
            bool isRollback = false;
            bool isSuccess = true;
            isSuccess = await _serialNumbersRepositories.EditEntityList(entityList, false);
            if (isSuccess)
                isSuccess = await _serialNumbersRepositories.AddRange(sList, false);
            if (isSuccess)
                isSuccess = await _boxRepositories.EditEntityList(box_New_List,false);

            //序列号操作记录
            var res = await this.SerialNumberOperate(soList, false);
            //提交事务
            if (isTransaction)
            {
                if (!isSuccess) isRollback = true;
                if (!res.Success) isRollback = true;
                isSuccess = _transactionRepositories.CommitTransaction(isRollback, _transaction);
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            if (!res.Success) return Result.ReFailure(ResultCodes.DateWriteError);
            return Result.ReSuccess();
        }
    }
}