using Prism.Events;
using System.Text.Json;
using YY.Admin.Core;
using YY.Admin.Core.Events;
using YY.Admin.Core.Services;

namespace YY.Admin.Services.Service.Supplier;

public class SupplierSyncCoordinator : ISingletonDependency
{
    private readonly IEventAggregator _eventAggregator;
    private readonly ISupplierService _supplierService;
    private readonly ILoggerService _logger;

    public SupplierSyncCoordinator(
        IEventAggregator eventAggregator,
        ISupplierService supplierService,
        SyncPollManager pollManager,
        ILoggerService logger)
    {
        _eventAggregator = eventAggregator;
        _supplierService = supplierService;
        _logger = logger;
        _eventAggregator.GetEvent<RemoteCommandReceivedEvent>()
            .Subscribe(OnRemoteCommand, ThreadOption.BackgroundThread);
        _eventAggregator.GetEvent<NetworkStatusChangedEvent>()
            .Subscribe(OnNetworkStatusChanged, ThreadOption.BackgroundThread);

        pollManager.Register("供应商", () =>
        {
            _eventAggregator.GetEvent<SupplierChangedEvent>()
                .Publish(new SupplierChangedPayload { Action = "poll" });
            return Task.CompletedTask;
        });
    }

    private async void OnNetworkStatusChanged(NetworkStatusChangedPayload payload)
    {
        if (!payload.IsOnline) return;

        // 先推送本地 pending 改动到后端，再通知 UI 刷新列表
        PushPendingResult result;
        try
        {
            result = await _supplierService.PushPendingOnReconnectAsync();
        }
        catch (Exception ex)
        {
            _logger.Warning($"[供应商同步] 重连推送异常：{ex.Message}");
            result = new PushPendingResult(0, 0, 0);
        }

        // 通知列表刷新
        _eventAggregator.GetEvent<SupplierChangedEvent>()
            .Publish(new SupplierChangedPayload { Action = "reconnect" });

        // 若有推送结果，通知 UI 显示摘要
        bool hasActivity = result.PushedCount > 0
            || result.ConflictCount > 0
            || result.NewRecordsPushed > 0;
        if (hasActivity)
        {
            _eventAggregator.GetEvent<SyncConflictEvent>().Publish(new SyncConflictPayload
            {
                EntityName = "供应商",
                PushedCount = result.PushedCount,
                ConflictCount = result.ConflictCount,
                NewRecordsPushed = result.NewRecordsPushed
            });
        }
    }

    private void OnRemoteCommand(RemoteCommandPayload payload)
    {
        try
        {
            var json = payload.CommandJson ?? string.Empty;
            if (string.IsNullOrWhiteSpace(json)) return;
            using var doc = JsonDocument.Parse(json);
            if (!doc.RootElement.TryGetProperty("cmd", out var cmdEl)) return;
            if (!cmdEl.GetString().Equals("MES_SUPPLIER_CHANGED", StringComparison.OrdinalIgnoreCase)) return;
            doc.RootElement.TryGetProperty("action", out var actionEl);
            doc.RootElement.TryGetProperty("supplierId", out var idEl);
            _eventAggregator.GetEvent<SupplierChangedEvent>().Publish(new SupplierChangedPayload
            {
                Action = actionEl.GetString() ?? string.Empty,
                SupplierId = idEl.ValueKind == JsonValueKind.String ? idEl.GetString() : null
            });
        }
        catch (Exception ex)
        {
            _logger.Warning($"[供应商推送] 处理失败：{ex.Message}");
        }
    }
}