using System.Collections.Immutable;
using JNPF;
using JNPF.Common.Core.Manager;
using JNPF.Common.Extension;
using JNPF.Common.Security;
using JNPF.Systems.Interfaces.System;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using Tnb.BasicData.Entities;
using Tnb.WarehouseMgr.Entities;
using Tnb.WarehouseMgr.Entities.Consts;
using Tnb.WarehouseMgr.Entities.Dto;
using Tnb.WarehouseMgr.Entities.Dto.Inputs;
using Tnb.WarehouseMgr.Entities.Enums;
using Tnb.WarehouseMgr.Entities.Exceptions;
using Tnb.WarehouseMgr.Interfaces;
//using JNPF.Extras.CollectiveOAuth.Utils;

namespace Tnb.WarehouseMgr
{
    public class PDATransferSignService : BaseWareHouseService, IWmsPDATransferSignService
    {
        private readonly ISqlSugarClient _db;
        private readonly IDictionaryDataService _dictionaryDataService;
        private static Dictionary<string, object> _dicBizType = new();
        private readonly IUserManager _userManager;
        private readonly IWmsOutStockService _outstockService;
        public PDATransferSignService(ISqlSugarRepository<WmsDistaskH> repository, IDictionaryDataService dictionaryDataService, IUserManager userManager, IWmsOutStockService outStockService)
        {
            _db = repository.AsSugarClient();
            _dictionaryDataService = dictionaryDataService;
            _userManager = userManager;
            _outstockService = outStockService;
        }

        /// <summary>
        /// 转运签收
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task SignForDelivery(SignForDeliveryInput input)
        {
            if (_dicBizType.Count < 1)
            {
                _dicBizType = await _dictionaryDataService.GetDictionaryByTypeId(WmsWareHouseConst.WMS_BIZTYPE_ID);
            }
            try
            {
                await _db.Ado.BeginTranAsync();
                WmsCarryH? carry = null;
                WmsCarryH? newCarry = null;
                carry = !input.carryId.IsNullOrWhiteSpace()
                    ? await _db.Queryable<WmsCarryH>().SingleAsync(it => it.id == input.carryId)
                    : await _db.Queryable<WmsCarryH>().SingleAsync(it => it.carry_code == input.carry_code);
                if (!input.new_carry_code.IsNullOrWhiteSpace())
                {
                    newCarry = await _db.Queryable<WmsCarryH>().SingleAsync(it => it.carry_code == input.new_carry_code);
                }

                if (carry != null && newCarry != null)
                {
                    if (carry?.location_id?.IsNotEmptyOrNull() ?? false)
                    {
                        BasLocation loc = await _db.Queryable<BasLocation>().SingleAsync(it => it.id == carry.location_id);
                        loc.is_use = ((int)EnumCarryStatus.空闲).ToString();
                        _ = await _db.Updateable(loc).UpdateColumns(it => it.is_use).ExecuteCommandAsync();
                    }
                    WmsDistaskH? disTask = null;
                    if (!input.disTaskId.IsNullOrEmpty())
                    {
                        disTask = await _db.Queryable<WmsDistaskH>().SingleAsync(it => it.id == input.disTaskId);
                    }
                    else if (!input.carryId.IsNullOrEmpty())
                    {
                        disTask = await _db.Queryable<WmsDistaskH>().FirstAsync(it => it.carry_id == input.carryId && it.is_sign == 0);
                    }
                    else if (!input.carry_code.IsNullOrEmpty())
                    {
                        disTask = await _db.Queryable<WmsDistaskH>().FirstAsync(it => it.carry_code == input.carry_code && it.is_sign == 0);
                    }
                    if (disTask != null)
                    {
                        List<WmsCarryCode> nCCode = await _db.Queryable<WmsCarryCode>().Where(it => it.carry_id == newCarry.id).ToListAsync();
                        Dictionary<string, object> dicMin = await _db.Queryable<BasMaterial>().Where(it => input.distaskCodes.Select(x => x.material_id).Contains(it.id)).ToDictionaryAsync(d => d.id, d => d.minpacking);
                        WmsCarryCode cCode = new();
                        List<WmsCarryCode> iCodes = new();
                        List<WmsCarryCode> uCodes = new();
                        foreach (WmsDistaskCode dCode in input.distaskCodes)
                        {
                            decimal codeQty = 0;
                            WmsCarryCode? sMCode = nCCode.Find(x => x.material_id == dCode.material_id && x.codeqty <= dicMin[dCode.material_id].ParseToDecimal());
                            cCode = dCode.Adapt<WmsCarryCode>();
                            cCode.carry_id = newCarry.id;
                            cCode.code_batch = $"{DateTime.Today.Year}{DateTime.Today.Month}{DateTime.Today.Day}";
                            if (sMCode != null)
                            {
                                codeQty = sMCode.codeqty;
                                cCode.codeqty += codeQty;
                                cCode.id = sMCode.id;
                                uCodes.Add(cCode);
                            }
                            else
                            {
                                cCode.id = SnowflakeIdHelper.NextId();
                                iCodes.Add(cCode);
                            }


                        }
                        _ = await _db.Insertable(iCodes).ExecuteCommandAsync();
                        _ = await _db.Updateable(uCodes).ExecuteCommandAsync();
                        if (_dicBizType.ContainsKey(disTask.biz_type))
                        {
                            WareHouseUpInput upInput = new()
                            {
                                loginType = "web",
                                bizTypeId = disTask.biz_type,
                                requireId = disTask!.require_id!,
                                carryIds = new List<string> { carry!.id },
                                distaskCodes = input.distaskCodes
                            };
                            await DoUpdate(upInput); //回更业务
                        }
                        disTask.is_sign = 1;
                        _ = await _db.Updateable(disTask).UpdateColumns(it => it.is_sign).ExecuteCommandAsync();
                    }
                }
                await _db.Ado.CommitTranAsync();
            }
            catch (Exception)
            {
                await _db.Ado.RollbackTranAsync();
                throw;
            }
        }

        /// <summary>
        /// 库存是否抵达最小库存
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task IsMinStorage(CancellationToken? cts = default)
        {
            //if (UserManager.AsscessToken.IsNullOrWhiteSpace()) return;
            //var curUser = await GetUserIdentity();
            SqlSugarClient curDb = _db.CopyNew();
            try
            {
                List<Dictionary<string, object>> dics = new();
                var sgs = await curDb.Queryable<WmsMinstrategyH>().LeftJoin<WmsMinstrategyD>((a, b) => a.id == b.bill_id)
                   .Select((a, b) => new
                   {
                       sendWh = a.sendwh_id,
                       receiveWh = a.receivewh_id,
                       b.material_id,
                       b.box_num,
                   })
                   .ToListAsync();
                var items = await curDb.Queryable<WmsCarryCode>()
                        .LeftJoin<BasMaterialSendWarehouse>((a, b) => a.material_id == b.id)
                        .LeftJoin<BasMaterial>((a, b, c) => b.material_id == c.id)
                        .Where(a => sgs.Select(x => x.receiveWh).Contains(a.warehouse_id))
                        .Select((a, b, c) => new { a.material_id, a.codeqty, b.min_stock, c.code, c.minpacking, a.warehouse_id })
                        .ToListAsync();
                foreach (var sg in sgs)
                {
                    var itGroups = items.FindAll(x => x.material_id == sg.material_id && x.warehouse_id == sg.receiveWh).GroupBy(g => g.material_id);
                    Dictionary<string, object> dic = new();
                    foreach (var itGroup in itGroups)
                    {
                        int? minStock = itGroup.First().min_stock;
                        if (itGroup.Select(x => x.codeqty).Sum() <= minStock)
                        {
                            dic.Add(nameof(WmsCarryCode.material_id), itGroup.Key);
                            dic.Add(nameof(WmsCarryCode.material_code), itGroup.First().code);
                            dic.Add(nameof(BasMaterial.minpacking), itGroup.First().minpacking!);
                        }
                        dics.Add(dic);
                    }
                    //查找符合条件的出库库位
                    //var locs = await curDb.Queryable<BasLocation>().Where(it => it.is_type == ((int)EnumLocationType.存储库位).ToString() && it.wh_id == "2" && it.is_lock == 0 && it.is_use == ((int)EnumCarryStatus.空闲).ToString()).ToListAsync();
                    MESCreateOutstockInput input = new()
                    {
                        outstock =
                        {
                            org_id = _userManager.User.OrganizeId,
                            bill_date = DateTime.Now,
                            bill_type = "28135837838101",//单据类型：自动补货单
                            warehouse_id = "1",
                            create_id= _userManager.UserId,
                        }
                    };
                    foreach (Dictionary<string, object> d in dics)
                    {
                        input.outstock.location_code = "YCL03-01-01";
                        MESWmsOutstockDInput outstockD = new()
                        {
                            material_id = d[nameof(WmsCarryCode.material_id)].ToString()!,
                            material_code = d[nameof(WmsCarryCode.material_code)].ToString()!,
                            pr_qty = d[nameof(BasMaterial.minpacking)].ParseToDecimal()
                        };
                        input.outstockDs.Add(outstockD);
                        await _outstockService.MESCreateOutstock(input);
                    }
                }
            }
            catch (Exception ex)
            {
                await curDb.Ado.RollbackTranAsync();
                if (_userManager?.ToKen.IsNullOrEmpty() ?? false)
                {
                    TimedTaskErrorInfo ei = new()
                    {
                        RequestURL = App.HttpContext?.Request?.Path,
                        RequestMethod = App.HttpContext?.Request?.Method,
                        userIdentity = await GetUserIdentity(_userManager.ToKen),
                    };
                    TimedTaskException timedTaskEx = ex.ToTimedTaskException(ei);
                    throw timedTaskEx;
                }
            }
        }
    }
}