using System;
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.Basedata.Application.Contracts;
using Win_in.Sfs.Wms.DataExchange.Domain;
using Win_in.Sfs.Wms.DataExchange.Domain.Shared;


using Win_in.Sfs.Basedata.Application.Contracts;
using Win_in.Sfs.Shared.Domain;
using Win_in.Sfs.Wms.DataExchange.Application.Contracts;
using Win_in.Sfs.Wms.DataExchange.Domain.Shared;
using Win_in.Sfs.Wms.Store.Application.Contracts;
using System.Collections.Generic;
using System.Linq;


namespace Win_in.Sfs.Wms.DataExchange.MesAgent
{
    public class OutMesIncomingDataWorker : AsyncPeriodicBackgroundWorkerBase
    {
        private readonly IOptions<DataExchangeOptions> _options;


        //private readonly IMesProductL7PartsNoteAppService _mesProductL7PartsNoteAppService;
        //private readonly IProductL7PartsNoteAppService _productL7PartsNoteAppService;
        //private readonly IItemBasicAppService _itemBasicAppService;



        public OutMesIncomingDataWorker(
            AbpAsyncTimer timer,
            IOptions<DataExchangeOptions> options,
            //IProductL7PartsNoteAppService productL7PartsNoteAppService,
            //IMesProductL7PartsNoteAppService mesProductL7PartsNoteAppService,
            //IItemBasicAppService itemBasicAppService,

            IServiceScopeFactory serviceScopeFactory
        ) : base(timer, serviceScopeFactory)
        {
            _options = options;
            //_itemBasicAppService = itemBasicAppService;
            //_productL7PartsNoteAppService = productL7PartsNoteAppService;
            //_mesProductL7PartsNoteAppService = mesProductL7PartsNoteAppService;
            Timer.Period = options.Value.IncomingOptions.PeriodSeconds * 1000; //default 5 minutes
        }

        [UnitOfWork]
        protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)
        {
            Logger.LogInformation("Starting: Handling Incoming Exchange data...");
            if (!_options.Value.IncomingOptions.Active)
            {
                Logger.LogInformation("Incoming Exchange is not active!");
                return;
            }

            //Resolve dependencies
            var mesProductL7PartsNoteAppService = workerContext
                .ServiceProvider
                .GetRequiredService<IMesProductL7PartsNoteAppService>();

            //Resolve dependencies
            var incomingDataManager = workerContext
                .ServiceProvider
                .GetRequiredService<OutMesData.Domain.IOutMesIncomingDataManager>();

            int maxRowId = await mesProductL7PartsNoteAppService.GetMaxRowID();
             //maxRowId = 0;

            //Do the work
            var incomingDataList = await incomingDataManager.GetReadyListAsync(maxRowId);

            try
            {
                List<MesProductL7PartsNoteCreateInput> mesNotes = new List<MesProductL7PartsNoteCreateInput>();


                foreach (var mesIncomData in incomingDataList)
                {
                    MesProductL7PartsNoteCreateInput createInput = new MesProductL7PartsNoteCreateInput()
                    {
                        RowID = mesIncomData.Id,
                        State = mesIncomData.State,
                        ProductNo = mesIncomData.ProductNo,
                        Program = mesIncomData.Program,
                        Position = mesIncomData.Position,
                        FATA = mesIncomData.FATA,
                        Configuration = mesIncomData.Configuration,
                        L7Part = mesIncomData.L7Part,
                        Qty = mesIncomData.Qty,
                        CreateDate = mesIncomData.CreateDate,
                        Company = "Mes",
                        Number = "Mes",

                    };

                    mesNotes.Add(createInput);
                }


                //获取所有的L7零件信息，并获取零件是不是采购件、制造件

                var L7PartCodes = mesNotes.Select(p => p.L7Part).Distinct().ToList();

                  await mesProductL7PartsNoteAppService.AddManyAsync(mesNotes);



                string codesStr = System.Text.Json.JsonSerializer.Serialize(L7PartCodes);


                ItemBasicRequestInput itemInput = new ItemBasicRequestInput();
                itemInput.Condition.Filters.Add(new Sfs.Shared.Domain.Filter() { Action = EnumFilterAction.In.ToString(), Column = "Code", Logic = EnumFilterLogic.And.ToString(), Value = codesStr, });
                itemInput.MaxResultCount = 999;


                //Resolve dependencies
                var itemBasicAppService = workerContext
                    .ServiceProvider
                    .GetRequiredService<IItemBasicAppService>();

                //Do the work

                var itemBaseList = await itemBasicAppService.GetListAsync(itemInput, false);

                var sumEntityList = mesNotes.GroupBy(p => new { p.ProductNo, p.Program, p.FATA, p.Configuration, p.Position }).ToList();


                List<ProductL7PartsNoteCreateInput> noteList = new List<ProductL7PartsNoteCreateInput>();

                foreach (var sumEntity in sumEntityList)
                {
                    ProductL7PartsNoteCreateInput note = new ProductL7PartsNoteCreateInput()
                    {
                        ProductNo = sumEntity.Key.ProductNo,
                        Program = sumEntity.Key.Program,
                        FATA = sumEntity.Key.FATA,
                        Configuration = sumEntity.Key.Configuration,
                        Position = sumEntity.Key.Position,
                        Company = "MES",
                        Details = new List<ProductL7PartsNoteDetailInput>(), 
                    };


                    var detailList = mesNotes.Where(p => p.ProductNo == sumEntity.Key.ProductNo &&
                     p.Program == sumEntity.Key.Program &&
                     p.FATA == sumEntity.Key.FATA &&
                     p.Configuration == sumEntity.Key.Configuration &&
                     p.Position == sumEntity.Key.Position).ToList();



                    foreach (var detail in detailList)
                    {

                        ProductL7PartsNoteDetailInput noteDetail = new ProductL7PartsNoteDetailInput()

                        {
                            ProductNo = sumEntity.Key.ProductNo,
                            Program = sumEntity.Key.Program,
                            FATA = sumEntity.Key.FATA,
                            Configuration = sumEntity.Key.Configuration,
                            Position = sumEntity.Key.Position,
                            L7Part = detail.L7Part,
                            ItemCode = detail.L7Part,
                            State = detail.State,
                            CreateDate = detail.CreateDate,
                            Qty = detail.Qty,
                            RowID = detail.RowID,
                             

                        };

                        var itemBase = itemBaseList.Items.FirstOrDefault(p => p.Code == detail.L7Part);
                        if (itemBase == null)
                        {
                            //throw new Exception($"未找到零件{detail.L7PartCode}的零件基础信息，请确认基础信息是否齐全！");

                        }
                        else
                        {
                            noteDetail.CanMake = itemBase.CanMake;
                            noteDetail.CanBuy = itemBase.CanBuy;
                        }


                        note.Details.AddIfNotContains(noteDetail);
                    }

                    noteList.Add(note);
                }


                //Resolve dependencies
                var productL7PartsNoteAppService = workerContext
                    .ServiceProvider
                    .GetRequiredService<IProductL7PartsNoteAppService>();

                //保存相关L7零件信息
                await productL7PartsNoteAppService.CreateAsync(noteList);

            }
            catch (Exception e)
            {
                e = e.GetBaseException();
                //incomingData.SetError(EnumExchangeDataErrorCode.Exception, e.Message);

                throw e;
            }


            Logger.LogInformation("Completed: Handling Incoming Exchange data...");
        }

    }

}