using System.Text;
using System.Text.RegularExpressions;
using JNPF.Common.Contracts;
using JNPF.Common.Core.Manager;
using JNPF.Common.Dtos.VisualDev;
using JNPF.Common.Enums;
using JNPF.Common.Extension;
using JNPF.Common.Security;
using JNPF.FriendlyException;
using JNPF.Logging;
using JNPF.Systems.Interfaces.System;
using JNPF.VisualDev;
using JNPF.VisualDev.Interfaces;
using Mapster;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Npgsql;
using SqlSugar;
using Tnb.BasicData.Entities;
using Tnb.Common.Utils;
using Tnb.WarehouseMgr.Entities;
using Tnb.WarehouseMgr.Entities.Consts;
using Tnb.WarehouseMgr.Entities.Dto;
using Tnb.WarehouseMgr.Entities.Dto.Inputs;
using Tnb.WarehouseMgr.Entities.Dto.Outputs;
using Tnb.WarehouseMgr.Entities.Entity;
using Tnb.WarehouseMgr.Entities.Enums;
using Tnb.WarehouseMgr.Interfaces;

namespace Tnb.WarehouseMgr
{
    [OverideVisualDev(ModuleConsts.MODULE_WMSOUTINSTOCKDETAIL_ID)]
    public class WmsOutinStockDetailService : BaseWareHouseService, IWmsOutinStockDetailService
    {
        private readonly ISqlSugarClient _db;
        private readonly IUserManager _userManager;
        private readonly IBillRullService _billRullService;
        private readonly IRunService _runService;
        private readonly IVisualDevService _visualDevService;
        public WmsOutinStockDetailService(
            ISqlSugarRepository<WmsCarryH> repository,
            IUserManager userManager,
            IBillRullService billRullService,
            IRunService runService,
            IVisualDevService visualDevService)
        {
            _db = repository.AsSugarClient();
            _userManager = userManager;
            _billRullService = billRullService;
            _runService = runService;
            _visualDevService = visualDevService;
        }

        /// <summary>
        /// 根据任务单获取出入库类型
        /// </summary>
        string GetOutinStockTypeByTask(string task_type, string biz_type)
        {
            //if (biz_type == WmsWareHouseConst.BIZTYPE_WMSINSTOCK_ID)
            //    return "";

            string type = "";

            switch (task_type)
            {
                case WmsWareHouseConst.WMS_PRETASK_INSTOCK_TYPE_ID:
                    {
                        type = "入库";
                        break;
                    }
                case WmsWareHouseConst.WMS_PRETASK_OUTSTOCK_TYPE_ID:
                    {
                        type = "出库";
                        break;
                    }
            }



            return type;
        }

        /// <summary>
        /// 根据任务单获取操作员
        /// </summary>
        string GetUserIdByTask()
        {
            string create_id = WmsWareHouseConst.AdministratorUserId;
            return create_id;
        }

        /// <summary>
        /// 插入出入库明细记录
        /// </summary>
        /// <param name="input"></param>
        /// <param name="dbConn"></param>
        /// <returns></returns>
        /// <exception cref="AppFriendlyException"></exception>
        [NonAction]
        public async Task AddOutinStockDetail(AddOutinStockDetailInput input, ISqlSugarClient dbConn = null)
        {
            var db = _db;
            if (dbConn != null)
                db = dbConn;
            try
            {
                if (string.IsNullOrEmpty(input.disTask.carry_id))
                {
                    return;
                }

                await _s_taskExecuteSemaphore_AddOutinStockDetail.WaitAsync();

                string type = GetOutinStockTypeByTask(input.disTask.task_type, input.disTask.biz_type);
                if (string.IsNullOrEmpty(type))
                {
                    return;
                }
              
                List<WmsCarryCode> wmsCarryCodes = await db.Queryable<WmsCarryCode>().Where(r => r.carry_id == input.disTask.carry_id).ToListAsync();

                //await db.Ado.BeginTranAsync();
               
                WmsOutinStockDetail wmsOutinStockDetail = new WmsOutinStockDetail();
                if (type == "入库")
                    wmsOutinStockDetail.warehouse_id = input.end_warehouse_id;
                else if (type == "出库")
                    wmsOutinStockDetail.warehouse_id = input.start_warehouse_id;
                wmsOutinStockDetail.carry_id = input.disTask.carry_id;
                wmsOutinStockDetail.carry_code = input.disTask.carry_code;
                wmsOutinStockDetail.create_id = GetUserIdByTask();
                wmsOutinStockDetail.startlocation_id = input.disTask.startlocation_id;
                wmsOutinStockDetail.startlocation_code = input.disTask.startlocation_code;
                wmsOutinStockDetail.endlocation_id = input.disTask.endlocation_id;
                wmsOutinStockDetail.endlocation_code = input.disTask.endlocation_code;
                wmsOutinStockDetail.act_start_date = input.disTask.act_start_date;
                wmsOutinStockDetail.act_end_date = input.disTask.act_end_date;
                wmsOutinStockDetail.pretask_code = input.disTask.pretask_code;
                wmsOutinStockDetail.distask_code = input.disTask.bill_code;
                wmsOutinStockDetail.create_time = DateTime.Now;
                switch (input.disTask.biz_type)
                {
                    case WmsWareHouseConst.BIZTYPE_WMSINSTOCK_ID:
                        {
                            wmsOutinStockDetail.source_detail_id = input.disTask.source_id;
                            wmsOutinStockDetail.source_id = input.disTask.require_id;
                            wmsOutinStockDetail.source_code = input.disTask.require_code;
                            wmsOutinStockDetail.source_type = WmsWareHouseConst.BIZTYPE_WMSINSTOCK_ID;
                            break;
                        }
                }
                wmsOutinStockDetail.type = type;

                List<BasMaterial> mats = await db.Queryable<BasMaterial>().Where(r => wmsCarryCodes.Select(x => x.material_id).Distinct().Contains(r.id)).ToListAsync();

                List<WmsOutinStockCode> wmsOutinStockCodes = new List<WmsOutinStockCode>();


                foreach (var itGroup in wmsCarryCodes.GroupBy(g => new { g.warehouse_id, g.location_id, g.material_id, g.code_batch }))
                {
                    dynamic key = itGroup.Key;

                    List<WmsCarryCode> curCarryCodes = itGroup.ToList().FindAll(x => x.warehouse_id == itGroup.Key.warehouse_id && x.location_id == itGroup.Key.location_id
                    && x.material_id == itGroup.Key.material_id && x.code_batch == itGroup.Key.code_batch);

                    decimal start_qty = db.Queryable<WmsCarryCode>().Where(r => r.warehouse_id == itGroup.Key.warehouse_id
                    && r.code_batch == itGroup.Key.code_batch).Sum(r => r.codeqty);

                    curCarryCodes.ForEach(x =>
                    {
                        WmsOutinStockCode wmsOutinStockCode = new WmsOutinStockCode();
                        BasMaterial mat = mats.Where(r => r.id == x.material_id).First();
                        wmsOutinStockCode.bill_d_id = wmsOutinStockDetail.id;
                        wmsOutinStockCode.barcode = x.barcode;
                        wmsOutinStockCode.material_id = mat.id;
                        wmsOutinStockCode.material_code = mat.code;
                        wmsOutinStockCode.material_specification = mat.material_specification;
                        wmsOutinStockCode.code_batch = x.code_batch;
                        wmsOutinStockCode.codeqty = x.codeqty;
                        wmsOutinStockCode.start_qty = start_qty;
                        if (type == "入库")
                            wmsOutinStockCode.end_qty = start_qty + x.codeqty;
                        else if (type == "出库")
                            wmsOutinStockCode.end_qty = start_qty - x.codeqty;
                        wmsOutinStockCode.container_no = mat.container_no;
                        wmsOutinStockCode.unit_id = mat.unit_id;

                        wmsOutinStockCodes.Add(wmsOutinStockCode);
                    });

                }

                int rows = await db.Insertable(wmsOutinStockDetail).ExecuteCommandAsync();
                if (rows == 0)
                {
                    throw new Exception($"插入出入库明细失败！");
                }
                rows = await db.Insertable(wmsOutinStockCodes).ExecuteCommandAsync();
                if (rows == 0)
                {
                    if (wmsCarryCodes.Count == 0)
                    {
                        Logger.LogWarning("空载具无需插入出入库明细条码");
                    }
                    else
                    {
                        throw new Exception($"插入出入库明细条码失败！");
                    }
                }
                await db.Ado.CommitTranAsync();
            }
            catch (PostgresException ex)
            {
                ////await db.Ado.RollbackTranAsync();
                Logger.LogError(ex.Message);
                Logger.LogError(ex.StackTrace);
                //throw new AppFriendlyException($"插入出入库明细失败 {ex.Message}", 500);
            }
            catch (Exception ex)
            {
                //await db.Ado.RollbackTranAsync();
                Logger.LogError(ex.Message);
                Logger.LogError(ex.StackTrace);
                //throw new AppFriendlyException($"插入出入库明细失败 {ex.Message}", 500);
            }
            finally
            {
                _s_taskExecuteSemaphore_AddOutinStockDetail.Release();
            }
        }

    }
}