using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Win_in.Sfs.Wms.DataExchange.Domain;
using Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg;
using Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes;
using Win_in.Sfs.Wms.DataExchange.Domain.Shared;
using Win_in.Sfs.Wms.DataExchange.WMS.PCK;

namespace Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent.Incoming;

public class IssueReader : IReader
{

    private readonly IIssueNoteManager _IssueManager;
    private readonly IIncomingFromExternalManager _incomingFromExternalManager;
    private readonly ILogger<IssueReader> _logger;

    public IssueReader(
        IIssueNoteManager IssueManager
        , IIncomingFromExternalManager incomingFromExternalManager
        , ILogger<IssueReader> logger
        )
    {
        _IssueManager = IssueManager;
        _incomingFromExternalManager = incomingFromExternalManager;
        _logger = logger;
    }

    public virtual async Task<List<IncomingFromExternal>> ReadAsync()
    {
        //从MES读取待处理issue
        var toBeProcessedIssue = await _IssueManager.GetToBeProcessedListAsync().ConfigureAwait(false);
        if (!toBeProcessedIssue.Any())
        {
            _logger.LogInformation("no issues");
            return new List<IncomingFromExternal>();
        }
        //issue逐一转换为issuesNote
        var incomingDataList = BuildIncomingFromExternalFromScrapAsync(toBeProcessedIssue);
        await _incomingFromExternalManager.CreateManyAsync(incomingDataList).ConfigureAwait(false);
        //更新MES数据状态
        await _IssueManager.UpdateProcessedListAsync(toBeProcessedIssue).ConfigureAwait(false);
        return incomingDataList;
    }

    private List<IncomingFromExternal> BuildIncomingFromExternalFromScrapAsync(List<IssueNote> toBeProcessedIssue)
    {
        var incomingDataList = new List<IncomingFromExternal>();
        foreach (var issue in toBeProcessedIssue)
        {
            var incomingData = BuildIncomingFromExternal(issue);

            incomingData.SetEffectiveDate(DateTime.Now);

            try
            {
                var isue = BuildScrapNoteOrderExchangeMes(issue);
                incomingData.DestinationDataContent = JsonSerializer.Serialize(isue);
            }
            catch (Exception ex)
            {
                incomingData.SetError(EnumExchangeDataErrorCode.Exception, ex.Message, ex.ToString());
            }

            incomingDataList.Add(incomingData);

        }
        return incomingDataList;
    }

    private IncomingFromExternal BuildIncomingFromExternal(IssueNote issue)
    {
        var incomingData = new IncomingFromExternal()
        {
            DataType = EnumIncomingDataType.IssueConfirm.ToString(),
            DataAction = EnumExchangeDataAction.Add,
            SourceSystem = EnumSystemType.MES.ToString(),
            SourceDataId = issue.Plant.ToString(),
            SourceDataGroupCode = issue.DeliverNumber,
            SourceDataDetailCode = issue.ItemCode,
            SourceDataContent = JsonSerializer.Serialize(issue),
            WriteTime = DateTime.Now,
            Writer = nameof(MesIncomingBackgroundWorker),
            DestinationSystem = EnumSystemType.MES.ToString(),
        };
        return incomingData;
    }

    private static IssueNoteExchangeDto BuildScrapNoteOrderExchangeMes(IssueNote issue)
    {
        var isue = new IssueNoteExchangeDto()
        {
            Number = issue.DeliverNumber

        };
        var pkDetail = new IssueNoteDetailExchangeDto()
        {

            ItemCode = issue.ItemCode,
            ToLocationErpCode = issue.Plant,
            Qty = issue.Qty_Qty,

        };
        isue.Detail = pkDetail;
        return isue;
    }

}