using System.Data;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Volo.Abp.BackgroundWorkers;
using Volo.Abp.Threading;
using Volo.Abp.Uow;
using Win_in.Sfs.Wms.DataExchange.Domain.Shared;
using Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent.Outgoing;

namespace Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent;

public class TyrpOutgoingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
{
    private readonly string Outgoing = "TYRP Outgoing";

    private readonly IOptions<TyrpOptions> _options;

    public TyrpOutgoingBackgroundWorker(
        AbpAsyncTimer timer
        , IOptions<TyrpOptions> options
        , IServiceScopeFactory serviceScopeFactory
    ) : base(timer, serviceScopeFactory)
    {
        _options = options;
        Timer.Period = options.Value.OutgoingOptions.PeriodSeconds * 1000; //default 10 minutes

    }

    [UnitOfWork(true,isolationLevel:IsolationLevel.ReadUncommitted, 50)]
    protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)
  {
        Logger.LogInformation($"Starting: Handling {Outgoing}");

        if (!_options.Value.OutgoingOptions.Active)
        {
            Logger.LogInformation($"{Outgoing} is not active!");
            return;
        }
        var scontrolWriter = workerContext.ServiceProvider.GetRequiredService<ScontrolWriter>();//scontrol中间表服务
        var wmsoutmWriter = workerContext.ServiceProvider.GetRequiredService<WmsoutmWriter>();//wmsoutm中间表的服务
        var countadjustWriter = workerContext.ServiceProvider.GetRequiredService<CountAdjustNoteWriter>();//mesout_asd中间表的服务
        int scontrol_count = 0;//scontrol插入条数
        int wmsoutm_count = 0; //wmsoutm插入条数
        int mesout_asd_count = 0; //mesout_asd插入条数

        #region  采购单 PurchaseOrder scontrol
        Logger.LogInformation($"Write PurchaseOrder");//采购单
        var purchaseOrderConvert = workerContext.ServiceProvider.GetRequiredService<PurchaseOrderConverter>();
        var purchaseOrderList = await purchaseOrderConvert.ConvertAsync().ConfigureAwait(false);
        await scontrolWriter.WriteAsync(purchaseOrderList).ConfigureAwait(false);
        if (purchaseOrderList.Count > 0)
        {
            Logger.LogInformation($"采购单-PurchaseOrder处理{purchaseOrderList.Count}条");
            scontrol_count += purchaseOrderList.Count;
        }
        #endregion

        #region  采购退货单 PurchaseReturn scontrol
        Logger.LogInformation($"Write PurchaseReturn");//采购退货单(汇总)
        var purchaseReturnConvert = workerContext.ServiceProvider.GetRequiredService<PurchaseReturnConverter>();
        var purchaseReturnList = await purchaseReturnConvert.ConvertAsync().ConfigureAwait(false);
        await scontrolWriter.WriteAsync(purchaseReturnList).ConfigureAwait(false);
        if (purchaseReturnList.Count > 0)
        {
            Logger.LogInformation($"采购退货单-PurchaseReturn处理{purchaseReturnList.Count}条");
            scontrol_count += purchaseReturnList.Count;
        }
        #endregion

        #region  验收单 Putaway scontrol
        Logger.LogInformation($"Write PutawayNote");//验收单(汇总)
        var putawayNoteConvert = workerContext.ServiceProvider.GetRequiredService<PutawayNoteConverter>();
        var putawayNoteList = await putawayNoteConvert.ConvertAsync().ConfigureAwait(false);
        await scontrolWriter.WriteAsync(putawayNoteList).ConfigureAwait(false);
        if (putawayNoteList.Count > 0)
        {
            Logger.LogInformation($"验收单-Putaway处理{putawayNoteList.Count}条");
            scontrol_count += putawayNoteList.Count;
        }
        #endregion

        #region  线边仓领料单 Issue scontrol
        Logger.LogInformation($"Write IssueNote");//线边仓领料单(汇总)
        var issueNoteConvert = workerContext.ServiceProvider.GetRequiredService<IssueNoteConverter>();
        var issueNoteList = await issueNoteConvert.ConvertAsync().ConfigureAwait(false);
        await scontrolWriter.WriteAsync(issueNoteList).ConfigureAwait(false);
        if (issueNoteList.Count > 0)
        {
            Logger.LogInformation($"线边仓领料单-Issue处理{issueNoteList.Count}条");
            scontrol_count += issueNoteList.Count;
        }
        #endregion

        #region  线边仓退料单 ProductionReturn scontrol
        Logger.LogInformation($"Write ProductionReturnNote");//线边仓退料单(汇总)
        var productionReturnNoteConvert = workerContext.ServiceProvider.GetRequiredService<ProductionReturnNoteConverter>();
        var productionReturnNoteList = await productionReturnNoteConvert.ConvertAsync().ConfigureAwait(false);
        await scontrolWriter.WriteAsync(productionReturnNoteList).ConfigureAwait(false);
        if (productionReturnNoteList.Count > 0)
        {
            Logger.LogInformation($"线边仓退料单-ProductionReturn处理{productionReturnNoteList.Count}条");
            scontrol_count += productionReturnNoteList.Count;
        }
        #endregion 

        #region  半成品上架 SemiPutaway scontrol
        Logger.LogInformation($"Write SemiPutawayNote");//半成品上架
        var semiPutawayNoteConvert = workerContext.ServiceProvider.GetRequiredService<SemiPutawayNoteConverter>();
        var semiPutawayNoteList = await semiPutawayNoteConvert.ConvertAsync().ConfigureAwait(false);
        await scontrolWriter.WriteAsync(semiPutawayNoteList).ConfigureAwait(false);
        if (semiPutawayNoteList.Count > 0)
        {
            Logger.LogInformation($"半成品上架-SemiPutaway处理{semiPutawayNoteList.Count}条");
            scontrol_count += semiPutawayNoteList.Count;
        }
        #endregion

        #region  储位、线边仓调拨单 和  客户储位调拨单 Transfer scontrol
        Logger.LogInformation($"Write TransferNote");//储位、线边仓调拨单 和  客户储位调拨单(汇总)
        var transferNoteConvert = workerContext.ServiceProvider.GetRequiredService<TransferNoteConverter>();
        var transferNoteList = await transferNoteConvert.ConvertAsync().ConfigureAwait(false);
        var transferNoteForErpList = transferNoteList.Where(r => r.DataType == EnumOutgoingDataType.TransferForErp.ToString()).ToList();//储位、线边仓调拨单
        var transferNoteForCustomList = transferNoteList.Where(r => r.DataType == EnumOutgoingDataType.TransferForCustom.ToString()).ToList();//客户储位调拨单
        await scontrolWriter.WriteAsync(transferNoteForErpList).ConfigureAwait(false);
        await wmsoutmWriter.WriteAsync(transferNoteForCustomList).ConfigureAwait(false);
        if (transferNoteForErpList.Count > 0)
        {
            Logger.LogInformation($"储位、线边仓调拨单-Transfer处理{transferNoteForErpList.Count}条");
            scontrol_count += transferNoteForErpList.Count;
        }
        if (transferNoteForCustomList.Count > 0)
        {
            Logger.LogInformation($"客户储位调拨单-Transfer处理{transferNoteForCustomList.Count}条");
            wmsoutm_count += transferNoteForCustomList.Count;
        }
        #endregion

        if (scontrol_count > 0)//如果scontrol中有插入数据下边接口不执行
        {
            Logger.LogInformation($"scontrol处理{scontrol_count}条");
            return;
        }

        #region  出货单 Deliver wmsoutm
        Logger.LogInformation($"Write DeliverNote");//出货单(汇总)
        var deliverNoteConvert = workerContext.ServiceProvider.GetRequiredService<DeliverNoteConverter>();
        var deliverNoteList = await deliverNoteConvert.ConvertAsync().ConfigureAwait(false);
        await wmsoutmWriter.WriteAsync(deliverNoteList).ConfigureAwait(false);
        if (deliverNoteList.Count > 0)
        {
            Logger.LogInformation($"出货单-Deliver处理{deliverNoteList.Count}条");
            wmsoutm_count += deliverNoteList.Count;
        }
        #endregion

        #region --接口以关闭-- 退货单 UnplannedReceipt wmsoutm
        //暂无此接口
        //Logger.LogInformation($"Write CustomerReturnNote");//退货单
        //var customerReturnNoteConvert = workerContext.ServiceProvider.GetRequiredService<CustomerReturnNoteConverter>();
        //var customerReturnNoteList = await customerReturnNoteConvert.ConvertAsync().ConfigureAwait(false);
        //await wmsoutmWriter.WriteAsync(customerReturnNoteList).ConfigureAwait(false);
        #endregion

        #region  非生产领料单 UnplannedIssue wmsoutm
        Logger.LogInformation($"Write UnplannedIssueNote");//非生产领料单(汇总)
        var unplannedIssueNoteConvert = workerContext.ServiceProvider.GetRequiredService<UnplannedIssueNoteConverter>();
        var unplannedIssueNoteNoteList = await unplannedIssueNoteConvert.ConvertAsync().ConfigureAwait(false);
        await wmsoutmWriter.WriteAsync(unplannedIssueNoteNoteList).ConfigureAwait(false);
        if (unplannedIssueNoteNoteList.Count > 0)
        {
            Logger.LogInformation($"非生产领料单-UnplannedIssue处理{unplannedIssueNoteNoteList.Count}条");
            wmsoutm_count += unplannedIssueNoteNoteList.Count;
        }
        #endregion

        #region  非生产退料 UnplannedReceipt wmsoutm
        Logger.LogInformation($"Write UnplannedReceiptNote");//非生产退料(汇总)
        var unplannedReceiptNoteConvert = workerContext.ServiceProvider.GetRequiredService<UnplannedReceiptNoteConverter>();
        var unplannedReceiptNoteList = await unplannedReceiptNoteConvert.ConvertAsync().ConfigureAwait(false);
        await wmsoutmWriter.WriteAsync(unplannedReceiptNoteList).ConfigureAwait(false);
        if (unplannedReceiptNoteList.Count > 0)
        {
            Logger.LogInformation($"非生产退料-UnplannedReceipt处理{unplannedReceiptNoteList.Count}条");
            wmsoutm_count += unplannedReceiptNoteList.Count;
        }
        #endregion

        #region  回收料入库单 RecycledMaterialReceipt wmsoutm
        Logger.LogInformation($"Write RecycledMaterialReceiptNote");//回收料入库单
        var recycledMaterialReceiptNoteConvert = workerContext.ServiceProvider.GetRequiredService<RecycledMaterialReceiptNoteConverter>();
        var recycledMaterialReceiptNoteList = await recycledMaterialReceiptNoteConvert.ConvertAsync().ConfigureAwait(false);
        await wmsoutmWriter.WriteAsync(recycledMaterialReceiptNoteList).ConfigureAwait(false);
        if (recycledMaterialReceiptNoteList.Count > 0)
        {
            Logger.LogInformation($"回收料入库单-RecycledMaterialReceipt处理{recycledMaterialReceiptNoteList.Count}条");
            wmsoutm_count += recycledMaterialReceiptNoteList.Count;
        }
        #endregion

        #region  退拆单 ProductRecycle wmsoutm
        Logger.LogInformation($"Write BackFlushNote");//退拆单
        var productRecycleNoteConvert = workerContext.ServiceProvider.GetRequiredService<ProductRecycleNoteConverter>();
        var productRecycleNoteList = await productRecycleNoteConvert.ConvertAsync().ConfigureAwait(false);
        await wmsoutmWriter.WriteAsync(productRecycleNoteList).ConfigureAwait(false);
        if (productRecycleNoteList.Count > 0)
        {
            Logger.LogInformation($"退拆单-ProductRecycle处理{productRecycleNoteList.Count}条");
            wmsoutm_count += productRecycleNoteList.Count;
        }
        #endregion

        if (wmsoutm_count > 0)//如果wmsoutm中有插入数据下边接口不执行
        {
            Logger.LogInformation($"wmsoutm处理{wmsoutm_count}条");
            return;
        }

        #region  --接口以关闭-- 盘点调整单 CountAdjust mesout_asd
        //东阳上海和安徽暂时关闭此接口
        //Logger.LogInformation($"Write CountAdjusNote");//盘点调整单
        //var countadjustNoteConvert = workerContext.ServiceProvider.GetRequiredService<CountAdjustNoteConverter>();
        //var countadjustNoteList = await countadjustNoteConvert.ConvertAsync().ConfigureAwait(false);
        //await countadjustWriter.WriteAsync(countadjustNoteList).ConfigureAwait(false);
        #endregion

        #region  线边仓调整单 WIPAdjust  mesout_asd
        Logger.LogInformation($"Write WIPAdjusNote");//线边仓调整单(汇总)
        var wipAdjustNoteConvert = workerContext.ServiceProvider.GetRequiredService<WIPAdjusNoteConverter>();
        var wipAdjustNoteList = await wipAdjustNoteConvert.ConvertAsync().ConfigureAwait(false);
        await countadjustWriter.WriteAsync(wipAdjustNoteList).ConfigureAwait(false);
        if (wipAdjustNoteList.Count > 0)
        {
            Logger.LogInformation($"线边仓调整单-WIPAdjust处理{wipAdjustNoteList.Count}条");
            mesout_asd_count += wipAdjustNoteList.Count;
        }
        #endregion

        #region  回收料调整单 Item_Transform mesout_asd
        Logger.LogInformation($"Write ItemTransformNote");//回收料调整单(汇总)
        var ItemTransformNoteConvert = workerContext.ServiceProvider.GetRequiredService<ItemTransformNoteConverter>();
        var ItemTransformNoteList = await ItemTransformNoteConvert.ConvertAsync().ConfigureAwait(false);
        await countadjustWriter.WriteAsync(ItemTransformNoteList).ConfigureAwait(false);
        if (ItemTransformNoteList.Count > 0)
        {
            Logger.LogInformation($"回收料调整单-Item_Transform处理{ItemTransformNoteList.Count}条");
            mesout_asd_count += ItemTransformNoteList.Count;
        }
        #endregion

        #region  报废单、线边仓报废单 Scrap mesout_asd
        Logger.LogInformation($"Write ScrapNote");//报废单、线边仓报废单
        var scrapNoteConvert = workerContext.ServiceProvider.GetRequiredService<ScrapNoteConverter>();
        var scrapNoteList = await scrapNoteConvert.ConvertAsync().ConfigureAwait(false);
        await countadjustWriter.WriteAsync(scrapNoteList).ConfigureAwait(false);
        if (scrapNoteList.Count > 0)
        {
            Logger.LogInformation($"报废单、线边仓报废单-Scrap处理{scrapNoteList.Count}条");
            mesout_asd_count += scrapNoteList.Count;
        }
        #endregion

        if (mesout_asd_count > 0)//如果mesout_asd中有插入数据下边接口不执行
        {
            Logger.LogInformation($"mesout_asd处理{mesout_asd_count}条");
            return;
        }

        #region  缴库单 ProductReceipt mesout
        Logger.LogInformation($"Write ProductReceiptNote");//缴库单
        var productReceiptNoteConvert = workerContext.ServiceProvider.GetRequiredService<ProductReceiptNoteConverter>();
        var productReceiptNoteList = await productReceiptNoteConvert.ConvertAsync().ConfigureAwait(false);
        var productReceiptNoteWriter = workerContext.ServiceProvider.GetRequiredService<ProductReceiptNoteWriter>();//mesout中间表的服务
        await productReceiptNoteWriter.WriteAsync(productReceiptNoteList).ConfigureAwait(false);
        if (productReceiptNoteList.Count > 0)
        {
            Logger.LogInformation($"缴库单-ProductReceipt处理{productReceiptNoteList.Count}条");
        }
        #endregion

        Logger.LogInformation($"Completed: Handling {Outgoing}");
    }

}