using Microsoft.Extensions.Configuration;
using Prism.Events;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Web;
using YY.Admin.Core;
using YY.Admin.Core.Entity;
using YY.Admin.Core.Events;
using YY.Admin.Core.Services;

namespace YY.Admin.Services.Service.Supplier;

public class SupplierService : ISupplierService, ISingletonDependency
{
    private readonly IHttpClientFactory _httpClientFactory;
    private readonly IConfiguration _configuration;
    private readonly INetworkMonitor _networkMonitor;
    private readonly IEventAggregator _eventAggregator;
    private readonly ILoggerService _logger;

    private readonly object _cacheLock = new();
    private readonly string _cacheFilePath;
    private readonly string _pendingFilePath;
    private List<MesXslSupplier> _localCache = new();

    private const int MaxPendingRetries = 5;

    // 断开期间被本地修改的条目（含版本锚点），重连后推送到后端
    private readonly HashSet<string> _pendingLocalModifiedIds = new(StringComparer.OrdinalIgnoreCase);
    // 断开期间被本地删除的条目
    private readonly HashSet<string> _pendingLocalDeletedIds = new(StringComparer.OrdinalIgnoreCase);
    // 版本锚点：最后一次从后端同步时该条目的 UpdateTime，用于冲突检测
    private readonly Dictionary<string, DateTime?> _anchors = new(StringComparer.OrdinalIgnoreCase);
    // 每条待推送记录的重试次数，超过上限后放弃
    private readonly Dictionary<string, int> _pendingRetryCount = new(StringComparer.OrdinalIgnoreCase);

    private static readonly JsonSerializerOptions _jsonOpts = new()
    {
        PropertyNameCaseInsensitive = true,
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        Converters = { new NullableDateTimeJsonConverter() }
    };

    public SupplierService(
        IHttpClientFactory httpClientFactory,
        IConfiguration configuration,
        INetworkMonitor networkMonitor,
        IEventAggregator eventAggregator,
        ILoggerService logger)
    {
        _httpClientFactory = httpClientFactory;
        _configuration = configuration;
        _networkMonitor = networkMonitor;
        _eventAggregator = eventAggregator;
        _logger = logger;
        var appDataDir = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
            "YY.Admin", "sync-cache");
        Directory.CreateDirectory(appDataDir);
        _cacheFilePath = Path.Combine(appDataDir, "mes-xsl-supplier-cache.json");
        _pendingFilePath = Path.Combine(appDataDir, "mes-xsl-supplier-pending.json");
        LoadCacheFromDisk();
        LoadPendingFromDisk();
    }

    // ── 配置 ──────────────────────────────────────────────────────────────────

    private string BaseUrl =>
        (_configuration.GetValue<string>("JeecgIntegration:BaseUrl") ?? "http://localhost:8080/jeecg-boot").TrimEnd('/');
    private int DefaultTenantId =>
        (int?)_configuration.GetValue<long?>("JeecgIntegration:DefaultTenantId") ?? 1002;
    private HttpClient CreateClient() => _httpClientFactory.CreateClient("JeecgApi");

    // ── 公开接口 ──────────────────────────────────────────────────────────────

    public async Task<SupplierPageResult> PageAsync(
        int pageNo, int pageSize,
        string? supplierCode = null, string? supplierName = null,
        string? supplierShortName = null, string? erpCode = null,
        string? status = null, CancellationToken ct = default)
    {
        List<MesXslSupplier> source;
        try
        {
            source = _networkMonitor.IsOnline
                ? await FetchRemoteListAsync(ct).ConfigureAwait(false)
                : GetCacheSnapshot();
            lock (_cacheLock)
            {
                MergeIntoCache(source);
                SaveCacheToDiskUnsafe();
            }
            source = GetCacheSnapshot();
        }
        catch
        {
            source = GetCacheSnapshot();
        }

        IEnumerable<MesXslSupplier> q = source;
        if (!string.IsNullOrWhiteSpace(supplierCode))
            q = q.Where(x => (x.SupplierCode ?? "").Contains(supplierCode, StringComparison.OrdinalIgnoreCase));
        if (!string.IsNullOrWhiteSpace(supplierName))
            q = q.Where(x => (x.SupplierName ?? "").Contains(supplierName, StringComparison.OrdinalIgnoreCase));
        if (!string.IsNullOrWhiteSpace(supplierShortName))
            q = q.Where(x => (x.SupplierShortName ?? "").Contains(supplierShortName, StringComparison.OrdinalIgnoreCase));
        if (!string.IsNullOrWhiteSpace(erpCode))
            q = q.Where(x => (x.ErpCode ?? "").Contains(erpCode, StringComparison.OrdinalIgnoreCase));
        if (!string.IsNullOrWhiteSpace(status))
            q = q.Where(x => string.Equals(x.Status, status, StringComparison.OrdinalIgnoreCase));

        var ordered = q.OrderByDescending(x => x.CreateTime ?? DateTime.MinValue).ToList();
        var total = ordered.Count;
        var records = ordered.Skip(Math.Max(0, (pageNo - 1) * pageSize)).Take(pageSize).ToList();
        return new SupplierPageResult(records, total, pageNo, pageSize);
    }

    public async Task<MesXslSupplier?> GetByIdAsync(string id, CancellationToken ct = default)
    {
        // 有本地待同步改动时优先返回本地版本，避免编辑弹窗被后端旧版本覆盖
        if (_networkMonitor.IsOnline && !_pendingLocalModifiedIds.Contains(id))
        {
            var url = $"{BaseUrl}/xslmes/mesXslSupplier/anon/queryById?id={Uri.EscapeDataString(id)}&tenantId={DefaultTenantId}";
            using var client = CreateClient();
            var resp = await client.GetAsync(url, ct).ConfigureAwait(false);
            if (resp.IsSuccessStatusCode)
            {
                var json = await resp.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
                using var doc = JsonDocument.Parse(json);
                if (doc.RootElement.TryGetProperty("result", out var resultEl))
                    return resultEl.Deserialize<MesXslSupplier>(_jsonOpts);
            }
        }
        return GetCacheSnapshot().FirstOrDefault(x => string.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase));
    }

    public Task<bool> AddAsync(MesXslSupplier supplier, CancellationToken ct = default) =>
        PostAndRefreshAsync(
            $"{BaseUrl}/xslmes/mesXslSupplier/anon/add?tenantId={DefaultTenantId}",
            supplier, "add", supplier.Id, ct);

    public Task<bool> EditAsync(MesXslSupplier supplier, CancellationToken ct = default) =>
        PostAndRefreshAsync(
            $"{BaseUrl}/xslmes/mesXslSupplier/anon/edit?tenantId={DefaultTenantId}",
            supplier, "edit", supplier.Id, ct);

    public async Task<bool> DeleteAsync(string id, CancellationToken ct = default)
    {
        using var client = CreateClient();
        var url = $"{BaseUrl}/xslmes/mesXslSupplier/anon/delete?id={Uri.EscapeDataString(id)}&tenantId={DefaultTenantId}";
        var resp = await client.DeleteAsync(url, ct).ConfigureAwait(false);

        if (IsDisconnectedResponse(resp))
        {
            var anchor = GetCacheSnapshot()
                .FirstOrDefault(x => string.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase))?.UpdateTime;
            RemoveFromLocalCache(id);
            MarkLocalDeleted(id, anchor);
            _eventAggregator.GetEvent<SupplierChangedEvent>()
                .Publish(new SupplierChangedPayload { Action = "delete", SupplierId = id });
            return true;
        }

        var ok = resp.IsSuccessStatusCode && await IsSuccessResultAsync(resp, ct).ConfigureAwait(false);
        if (ok)
        {
            RemoveFromLocalCache(id);
            ClearPending(id);
            _eventAggregator.GetEvent<SupplierChangedEvent>()
                .Publish(new SupplierChangedPayload { Action = "delete", SupplierId = id });
        }
        return ok;
    }

    public async Task<bool> UpdateStatusAsync(string id, string status, CancellationToken ct = default)
    {
        using var client = CreateClient();
        var url = $"{BaseUrl}/xslmes/mesXslSupplier/anon/updateStatus?id={Uri.EscapeDataString(id)}&status={Uri.EscapeDataString(status)}&tenantId={DefaultTenantId}";
        var resp = await client.PostAsync(url, null, ct).ConfigureAwait(false);

        if (IsDisconnectedResponse(resp))
        {
            var anchor = GetCacheSnapshot()
                .FirstOrDefault(x => string.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase))?.UpdateTime;
            UpdateLocalStatus(id, status);
            MarkLocalModified(id, anchor);
            _eventAggregator.GetEvent<SupplierChangedEvent>()
                .Publish(new SupplierChangedPayload { Action = "status", SupplierId = id });
            return true;
        }

        var ok = resp.IsSuccessStatusCode && await IsSuccessResultAsync(resp, ct).ConfigureAwait(false);
        if (ok)
        {
            UpdateLocalStatus(id, status);
            ClearPending(id);
            _eventAggregator.GetEvent<SupplierChangedEvent>()
                .Publish(new SupplierChangedPayload { Action = "status", SupplierId = id });
        }
        return ok;
    }

    /// <summary>
    /// 重连后将离线期间的本地改动推送到后端，并检测冲突。
    /// 调用方应在此方法完成后再触发 UI 刷新，确保页面看到的是推送结果。
    /// </summary>
    public async Task<PushPendingResult> PushPendingOnReconnectAsync(CancellationToken ct = default)
    {
        int pushed = 0, conflicts = 0, newPushed = 0;

        // ── 1. 推送离线期间修改的现有记录 ─────────────────────────────────────
        foreach (var id in new List<string>(_pendingLocalModifiedIds))
        {
            try
            {
                var local = GetCacheSnapshot()
                    .FirstOrDefault(x => string.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase));
                if (local == null) { ClearPending(id); continue; }

                var remote = await FetchRemoteSingleAsync(id, ct);

                if (remote != null && HasConflict(id, remote.UpdateTime))
                {
                    // 后端也改了 → 后端版本获胜（MES 多用户安全策略）
                    UpsertLocalCache(remote);
                    ClearPending(id);
                    conflicts++;
                    _logger.Warning($"[供应商同步] 冲突：{local.SupplierName}（{id}），后端版本获胜");
                }
                else
                {
                    // 仅本地改了 → 安全推送
                    var (ok, isVersionConflict) = await PushEditAsync(local, ct);
                    if (isVersionConflict)
                    {
                        var fresh = await FetchRemoteSingleAsync(id, ct);
                        if (fresh != null) UpsertLocalCache(fresh);
                        ClearPending(id);
                        conflicts++;
                        _logger.Warning($"[供应商同步] 服务端版本冲突：{local.SupplierName}（{id}），后端版本获胜");
                    }
                    else if (ok)
                    {
                        ClearPending(id);
                        pushed++;
                        _logger.Information($"[供应商同步] 推送成功：{local.SupplierName}（{id}）");
                    }
                    else
                    {
                        _pendingRetryCount.TryGetValue(id, out var retries);
                        retries++;
                        if (retries >= MaxPendingRetries)
                        {
                            _logger.Warning($"[供应商同步] 推送超过最大重试次数({MaxPendingRetries})，放弃：{id}");
                            ClearPending(id);
                        }
                        else
                        {
                            _pendingRetryCount[id] = retries;
                            _logger.Warning($"[供应商同步] 推送失败，下次重连重试({retries}/{MaxPendingRetries})：{id}");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.Warning($"[供应商同步] 处理修改记录 {id} 时异常：{ex.Message}");
            }
        }

        // ── 2. 推送离线期间删除的记录 ──────────────────────────────────────────
        foreach (var id in new List<string>(_pendingLocalDeletedIds))
        {
            try
            {
                var remote = await FetchRemoteSingleAsync(id, ct);
                if (remote == null) { ClearPending(id); continue; } // 后端已不存在，无需操作

                if (HasConflict(id, remote.UpdateTime))
                {
                    // 后端改动了但本地要删 → 保守策略：后端版本获胜，恢复到本地
                    UpsertLocalCache(remote);
                    ClearPending(id);
                    conflicts++;
                    _logger.Warning($"[供应商同步] 冲突：删除操作与后端改动冲突，已恢复记录 {id}");
                }
                else
                {
                    if (await PushDeleteAsync(id, ct))
                    {
                        ClearPending(id);
                        pushed++;
                    }
                    else
                    {
                        _logger.Warning($"[供应商同步] 删除推送失败，下次重连重试：{id}");
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.Warning($"[供应商同步] 处理删除记录 {id} 时异常：{ex.Message}");
            }
        }

        // ── 3. 推送离线期间新增的 local- 记录 ─────────────────────────────────
        var localOnlyRecords = GetCacheSnapshot()
            .Where(x => (x.Id ?? "").StartsWith("local-", StringComparison.OrdinalIgnoreCase))
            .ToList();

        foreach (var record in localOnlyRecords)
        {
            try
            {
                if (await PushAddAsync(record, ct))
                {
                    RemoveFromLocalCache(record.Id!);
                    newPushed++;
                    // 下次 FetchRemoteListAsync 时后端会返回真实 ID 版本
                }
                else
                {
                    _logger.Warning($"[供应商同步] 新增推送失败，下次重连重试：{record.SupplierName}");
                }
            }
            catch (Exception ex)
            {
                _logger.Warning($"[供应商同步] 推送新增 {record.SupplierName} 时异常：{ex.Message}");
            }
        }

        return new PushPendingResult(pushed, conflicts, newPushed);
    }

    // ── 私有：写操作核心 ──────────────────────────────────────────────────────

    private async Task<bool> PostAndRefreshAsync(
        string url, MesXslSupplier supplier, string action, string? supplierId, CancellationToken ct)
    {
        if (!supplier.TenantId.HasValue || supplier.TenantId <= 0) supplier.TenantId = DefaultTenantId;
        if (string.IsNullOrWhiteSpace(supplier.Status)) supplier.Status = "0";

        var content = new StringContent(JsonSerializer.Serialize(supplier, _jsonOpts), Encoding.UTF8, "application/json");
        using var client = CreateClient();
        var resp = await client.PostAsync(url, content, ct).ConfigureAwait(false);

        if (IsDisconnectedResponse(resp))
        {
            if (string.IsNullOrWhiteSpace(supplier.Id))
            {
                // 新增：分配 local- ID，不进 pendingModifiedIds（通过 local- 前缀识别）
                supplier.Id = $"local-{Guid.NewGuid():N}";
                supplier.UpdateTime = DateTime.Now;
                UpsertLocalCache(supplier);
            }
            else
            {
                // 编辑已有记录：捕获版本锚点（修改前的后端 UpdateTime）
                var anchor = GetCacheSnapshot()
                    .FirstOrDefault(x => string.Equals(x.Id, supplier.Id, StringComparison.OrdinalIgnoreCase))?.UpdateTime;
                supplier.UpdateTime = DateTime.Now;
                UpsertLocalCache(supplier);
                MarkLocalModified(supplier.Id, anchor);
            }
            _eventAggregator.GetEvent<SupplierChangedEvent>()
                .Publish(new SupplierChangedPayload { Action = action, SupplierId = supplierId ?? supplier.Id });
            return true;
        }

        var ok = resp.IsSuccessStatusCode && await IsSuccessResultAsync(resp, ct).ConfigureAwait(false);
        if (ok)
        {
            UpsertLocalCache(supplier);
            ClearPending(supplierId ?? supplier.Id ?? "");
            _eventAggregator.GetEvent<SupplierChangedEvent>()
                .Publish(new SupplierChangedPayload { Action = action, SupplierId = supplierId ?? supplier.Id });
        }
        return ok;
    }

    // ── 私有：重连推送方法 ────────────────────────────────────────────────────

    private async Task<(bool Ok, bool IsVersionConflict)> PushEditAsync(MesXslSupplier supplier, CancellationToken ct)
    {
        var content = new StringContent(
            JsonSerializer.Serialize(supplier, _jsonOpts), Encoding.UTF8, "application/json");
        using var client = CreateClient();
        var resp = await client.PostAsync(
            $"{BaseUrl}/xslmes/mesXslSupplier/anon/edit?tenantId={DefaultTenantId}", content, ct)
            .ConfigureAwait(false);
        if (!resp.IsSuccessStatusCode) return (false, false);
        try
        {
            var json = await resp.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
            using var doc = JsonDocument.Parse(json);
            int code = 200;
            if (doc.RootElement.TryGetProperty("code", out var codeEl)) code = codeEl.GetInt32();
            if (code == 200) return (true, false);
            if (doc.RootElement.TryGetProperty("message", out var msgEl))
            {
                var msg = msgEl.GetString() ?? "";
                if (msg.Contains("已被他人修改")) return (false, true);
            }
            return (false, false);
        }
        catch { return (true, false); }
    }

    private async Task<bool> PushDeleteAsync(string id, CancellationToken ct)
    {
        using var client = CreateClient();
        var url = $"{BaseUrl}/xslmes/mesXslSupplier/anon/delete?id={Uri.EscapeDataString(id)}&tenantId={DefaultTenantId}";
        var resp = await client.DeleteAsync(url, ct).ConfigureAwait(false);
        return resp.IsSuccessStatusCode && await IsSuccessResultAsync(resp, ct).ConfigureAwait(false);
    }

    private async Task<bool> PushAddAsync(MesXslSupplier supplier, CancellationToken ct)
    {
        var payload = Clone(supplier);
        payload.Id = null; // 让后端生成真实 ID
        var content = new StringContent(
            JsonSerializer.Serialize(payload, _jsonOpts), Encoding.UTF8, "application/json");
        using var client = CreateClient();
        var resp = await client.PostAsync(
            $"{BaseUrl}/xslmes/mesXslSupplier/anon/add?tenantId={DefaultTenantId}", content, ct)
            .ConfigureAwait(false);
        return resp.IsSuccessStatusCode && await IsSuccessResultAsync(resp, ct).ConfigureAwait(false);
    }

    private async Task<MesXslSupplier?> FetchRemoteSingleAsync(string id, CancellationToken ct)
    {
        try
        {
            var url = $"{BaseUrl}/xslmes/mesXslSupplier/anon/queryById?id={Uri.EscapeDataString(id)}&tenantId={DefaultTenantId}";
            using var client = CreateClient();
            var resp = await client.GetAsync(url, ct).ConfigureAwait(false);
            if (!resp.IsSuccessStatusCode) return null;
            var json = await resp.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
            using var doc = JsonDocument.Parse(json);
            if (doc.RootElement.TryGetProperty("result", out var resultEl))
                return resultEl.Deserialize<MesXslSupplier>(_jsonOpts);
            return null;
        }
        catch { return null; }
    }

    // ── 私有：冲突检测 ────────────────────────────────────────────────────────

    /// <summary>
    /// 判断后端是否在断开期间修改了该记录：
    /// 后端当前 UpdateTime 与本地锚点不同 → 两端都改了 → 冲突。
    /// </summary>
    private bool HasConflict(string id, DateTime? remoteUpdateTime)
    {
        if (!_anchors.TryGetValue(id, out var anchor)) return false;
        return remoteUpdateTime != anchor;
    }

    private static bool IsDisconnectedResponse(HttpResponseMessage resp) =>
        (int)resp.StatusCode == 499;

    // ── 私有：pending 状态管理 ────────────────────────────────────────────────

    private void MarkLocalModified(string id, DateTime? anchor)
    {
        lock (_cacheLock)
        {
            _pendingLocalDeletedIds.Remove(id);
            _pendingLocalModifiedIds.Add(id);
            if (!_anchors.ContainsKey(id)) _anchors[id] = anchor; // 只记第一次（保留原始锚点）
            SavePendingToDiskUnsafe();
        }
    }

    private void MarkLocalDeleted(string id, DateTime? anchor)
    {
        lock (_cacheLock)
        {
            _pendingLocalModifiedIds.Remove(id);
            _pendingLocalDeletedIds.Add(id);
            if (!_anchors.ContainsKey(id)) _anchors[id] = anchor;
            SavePendingToDiskUnsafe();
        }
    }

    private void ClearPending(string id)
    {
        lock (_cacheLock)
        {
            _pendingLocalModifiedIds.Remove(id);
            _pendingLocalDeletedIds.Remove(id);
            _anchors.Remove(id);
            _pendingRetryCount.Remove(id);
            SavePendingToDiskUnsafe();
        }
    }

    // ── 私有：缓存合并 ────────────────────────────────────────────────────────

    /// <summary>
    /// 后端全量数据与本地 pending 改动合并，保证本地未同步改动不被覆盖。
    /// </summary>
    private void MergeIntoCache(List<MesXslSupplier> backendList)
    {
        bool hasPending = _pendingLocalModifiedIds.Count > 0 || _pendingLocalDeletedIds.Count > 0;
        if (!hasPending)
        {
            _localCache = backendList.Select(Clone).ToList();
            return;
        }

        var localById = _localCache.ToDictionary(x => x.Id ?? "", StringComparer.OrdinalIgnoreCase);
        var merged = new List<MesXslSupplier>(backendList.Count + 8);

        foreach (var remote in backendList)
        {
            var id = remote.Id ?? "";
            if (_pendingLocalDeletedIds.Contains(id)) continue; // 保持本地删除状态
            if (_pendingLocalModifiedIds.Contains(id) && localById.TryGetValue(id, out var local))
                merged.Add(Clone(local)); // 本地版本优先（尚未推送成功）
            else
                merged.Add(Clone(remote));
        }

        // 保留本地新增（local- 前缀，尚未推送到后端）
        foreach (var local in _localCache)
        {
            if ((local.Id ?? "").StartsWith("local-", StringComparison.OrdinalIgnoreCase))
                merged.Add(Clone(local));
        }

        // 安全保留：pending-modified 中后端未返回的条目（后端异常情况）
        foreach (var modId in _pendingLocalModifiedIds)
        {
            if (!merged.Any(x => string.Equals(x.Id, modId, StringComparison.OrdinalIgnoreCase))
                && localById.TryGetValue(modId, out var orphan))
                merged.Add(Clone(orphan));
        }

        _localCache = merged;
    }

    // ── 私有：磁盘持久化 ──────────────────────────────────────────────────────

    private async Task<List<MesXslSupplier>> FetchRemoteListAsync(CancellationToken ct)
    {
        var query = HttpUtility.ParseQueryString(string.Empty);
        query["pageNo"] = "1";
        query["pageSize"] = "10000";
        query["tenantId"] = DefaultTenantId.ToString();
        var url = $"{BaseUrl}/xslmes/mesXslSupplier/anon/list?{query}";
        using var client = CreateClient();
        var resp = await client.GetAsync(url, ct).ConfigureAwait(false);
        resp.EnsureSuccessStatusCode();
        var json = await resp.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
        using var doc = JsonDocument.Parse(json);
        return doc.RootElement.GetProperty("result").GetProperty("records")
                   .Deserialize<List<MesXslSupplier>>(_jsonOpts) ?? new();
    }

    private List<MesXslSupplier> GetCacheSnapshot()
    {
        lock (_cacheLock) return _localCache.Select(Clone).ToList();
    }

    private void LoadCacheFromDisk()
    {
        try
        {
            if (!File.Exists(_cacheFilePath)) return;
            _localCache = JsonSerializer.Deserialize<List<MesXslSupplier>>(
                File.ReadAllText(_cacheFilePath), _jsonOpts) ?? new();
        }
        catch { _localCache = new(); }
    }

    private void SaveCacheToDiskUnsafe() =>
        File.WriteAllText(_cacheFilePath, JsonSerializer.Serialize(_localCache, _jsonOpts));

    private void LoadPendingFromDisk()
    {
        try
        {
            if (!File.Exists(_pendingFilePath)) return;
            var state = JsonSerializer.Deserialize<PendingState>(File.ReadAllText(_pendingFilePath)) ?? new();
            foreach (var id in state.Modified) _pendingLocalModifiedIds.Add(id);
            foreach (var id in state.Deleted) _pendingLocalDeletedIds.Add(id);
            foreach (var (id, timeStr) in state.Anchors)
                _anchors[id] = timeStr != null && DateTime.TryParse(timeStr, out var dt) ? dt : null;
        }
        catch { }
    }

    private void SavePendingToDiskUnsafe()
    {
        var state = new PendingState
        {
            Modified = _pendingLocalModifiedIds.ToList(),
            Deleted = _pendingLocalDeletedIds.ToList(),
            Anchors = _anchors.ToDictionary(
                kv => kv.Key,
                kv => kv.Value?.ToString("yyyy-MM-dd HH:mm:ss"))
        };
        File.WriteAllText(_pendingFilePath, JsonSerializer.Serialize(state));
    }

    private void UpsertLocalCache(MesXslSupplier supplier)
    {
        lock (_cacheLock)
        {
            if (string.IsNullOrWhiteSpace(supplier.Id))
            {
                _localCache.Insert(0, Clone(supplier));
            }
            else
            {
                var idx = _localCache.FindIndex(x =>
                    string.Equals(x.Id, supplier.Id, StringComparison.OrdinalIgnoreCase));
                if (idx >= 0) _localCache[idx] = Clone(supplier);
                else _localCache.Insert(0, Clone(supplier));
            }
            SaveCacheToDiskUnsafe();
        }
    }

    private void RemoveFromLocalCache(string id)
    {
        lock (_cacheLock)
        {
            _localCache.RemoveAll(x => string.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase));
            SaveCacheToDiskUnsafe();
        }
    }

    private void UpdateLocalStatus(string id, string status)
    {
        lock (_cacheLock)
        {
            var item = _localCache.FirstOrDefault(x =>
                string.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase));
            if (item != null) { item.Status = status; SaveCacheToDiskUnsafe(); }
        }
    }

    private static async Task<bool> IsSuccessResultAsync(HttpResponseMessage resp, CancellationToken ct)
    {
        try
        {
            var json = await resp.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
            using var doc = JsonDocument.Parse(json);
            if (doc.RootElement.TryGetProperty("code", out var code)) return code.GetInt32() == 200;
            if (doc.RootElement.TryGetProperty("success", out var success)) return success.GetBoolean();
        }
        catch { }
        return true;
    }

    private static MesXslSupplier Clone(MesXslSupplier x) => new()
    {
        Id = x.Id, SupplierCode = x.SupplierCode, SupplierName = x.SupplierName,
        SupplierShortName = x.SupplierShortName, ErpCode = x.ErpCode, Remark = x.Remark,
        Status = x.Status, TenantId = x.TenantId, CreateBy = x.CreateBy,
        CreateTime = x.CreateTime, UpdateBy = x.UpdateBy, UpdateTime = x.UpdateTime,
        SysOrgCode = x.SysOrgCode
    };

    private sealed class PendingState
    {
        public List<string> Modified { get; set; } = new();
        public List<string> Deleted { get; set; } = new();
        public Dictionary<string, string?> Anchors { get; set; } = new();
    }

    private sealed class NullableDateTimeJsonConverter : JsonConverter<DateTime?>
    {
        public override DateTime? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
            => reader.TokenType == JsonTokenType.String
                && DateTime.TryParse(reader.GetString(), out var dt) ? dt : null;
        public override void Write(Utf8JsonWriter writer, DateTime? value, JsonSerializerOptions options)
            => writer.WriteStringValue(value?.ToString("yyyy-MM-dd HH:mm:ss"));
    }
}