using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using Microsoft.Win32;

namespace FixedAssetPrintAgent;

internal sealed class PrintAgentRuntime : IDisposable
{
  private readonly AgentConfigurationStore _store;
  private readonly IPrintResultJournal _journal;
  private readonly PrintAgentApiClient _apiClient = new();
  private readonly LabelPrintService _labelPrintService = new();
  private readonly WindowsStartupManager _startupManager;
  private readonly string _appVersion;
  private readonly SemaphoreSlim _heartbeatSemaphore = new(1, 1);
  private readonly SemaphoreSlim _pollSemaphore = new(1, 1);
  private CancellationTokenSource? _runtimeCancellationTokenSource;
  private Task? _heartbeatLoopTask;
  private Task? _pollLoopTask;
  private bool _disposed;

  public event EventHandler<PrintAgentRuntimeState>? StateChanged;

  public PrintAgentRuntimeState CurrentState { get; } = new();

  public PrintAgentRuntime(string storageRoot, string appVersion, string executablePath)
  {
    _store = new AgentConfigurationStore(storageRoot);
    _journal = new PrintResultJournal(storageRoot);
    _startupManager = new WindowsStartupManager(executablePath);
    _appVersion = appVersion;
  }

  public async Task InitializeAsync()
  {
    CurrentState.Configuration = NormalizeConfiguration(await _store.LoadAsync());
    await _startupManager.ApplyAsync(CurrentState.Configuration.RunAtStartup);
    await RefreshPrintersAsync();
    await RefreshRemoteResourcesAsync();

    if (CurrentState.IsPaired)
    {
      AppendLog($"已读取终端配置，当前终端编号 {CurrentState.Configuration.TerminalId}。");
    }
    else
    {
      AppendLog("当前尚未完成配对，请先输入服务器地址、终端名称和配对码。");
    }

    EmitState();
    StartBackgroundLoops();

    if (CurrentState.IsPaired)
    {
      await HeartbeatNowAsync(true);
      await ClaimNowAsync(true);
    }
  }

  public async Task SaveSettingsAsync(
    string serverUrl,
    string terminalName,
    string selectedPrinterName,
    bool runAtStartup)
  {
    CurrentState.Configuration.ServerUrl = NormalizeServerUrl(serverUrl);
    CurrentState.Configuration.TerminalName = NormalizeTerminalName(terminalName);
    CurrentState.Configuration.SelectedPrinterName = selectedPrinterName.Trim();
    CurrentState.Configuration.RunAtStartup = runAtStartup;
    CurrentState.Configuration = NormalizeConfiguration(CurrentState.Configuration);

    await _store.SaveAsync(CurrentState.Configuration);
    await _startupManager.ApplyAsync(CurrentState.Configuration.RunAtStartup);
    StartBackgroundLoops();
    AppendLog("本地配置已保存。");
    EmitState();
  }

  public async Task PairAsync(string serverUrl, string terminalName, string pairCode)
  {
    var normalizedServerUrl = NormalizeServerUrl(serverUrl);
    var normalizedTerminalName = NormalizeTerminalName(terminalName);
    var normalizedPairCode = pairCode.Trim().ToUpperInvariant();

    if (string.IsNullOrWhiteSpace(normalizedPairCode))
    {
      throw new InvalidOperationException("请输入一次性配对码。");
    }

    var response = await _apiClient.PairAsync(
      normalizedServerUrl,
      normalizedTerminalName,
      CurrentState.Configuration.MachineName,
      CurrentState.Configuration.Platform,
      normalizedPairCode);

    CurrentState.Configuration.ServerUrl = normalizedServerUrl;
    CurrentState.Configuration.TerminalName = normalizedTerminalName;
    CurrentState.Configuration.TerminalId = response.TerminalId;
    CurrentState.Configuration.DeviceToken = response.DeviceToken;
    CurrentState.Configuration.PairedAt = response.PairedAt ?? DateTimeOffset.Now.ToString("O");
    CurrentState.Configuration = NormalizeConfiguration(CurrentState.Configuration);

    await _store.SaveAsync(CurrentState.Configuration);
    StartBackgroundLoops();
    AppendLog(response.IsDefault
      ? "配对成功，这台电脑已成为默认打印终端。"
      : "配对成功，这台电脑已加入终端列表。");
    EmitState();

    await HeartbeatNowAsync(true);
    await RefreshRemoteResourcesAsync();
  }

  public Task RefreshPrintersAsync()
  {
    CurrentState.Printers = _labelPrintService.ListPrinters();
    EmitState();
    return Task.CompletedTask;
  }

  public async Task RefreshRemoteResourcesAsync()
  {
    try
    {
      var releases = await _apiClient.GetReleasesAsync(CurrentState.Configuration.ServerUrl);
      CurrentState.Releases = releases.Releases;

      var latestVersion = releases.LatestVersion ?? CurrentState.Releases.FirstOrDefault()?.Version ?? string.Empty;
      CurrentState.UpdateStatusMessage = string.IsNullOrWhiteSpace(latestVersion)
        ? "尚未读取到服务器版本"
        : latestVersion == _appVersion
          ? $"当前已是最新版本 {_appVersion}"
          : $"发现新版本 {latestVersion}，后台可下载安装";
    }
    catch (Exception ex)
    {
      CurrentState.UpdateStatusMessage = "版本检查失败，请稍后重试";
      CurrentState.LastError = ex.Message;
      AppendLog($"版本检查失败：{ex.Message}");
    }

    try
    {
      CurrentState.LatestDriver = await _apiClient.GetLatestDriverAsync(CurrentState.Configuration.ServerUrl);
      CurrentState.ArchivedDrivers = await _apiClient.GetArchivedDriversAsync(CurrentState.Configuration.ServerUrl);
    }
    catch (Exception ex)
    {
      CurrentState.LastError = ex.Message;
      AppendLog($"驱动资源读取失败：{ex.Message}");
    }

    EmitState();
  }

  public async Task HeartbeatNowAsync(bool suppressErrors = false)
  {
    if (!CurrentState.IsPaired)
    {
      if (!suppressErrors)
      {
        AppendLog("尚未完成配对，暂时不能发送心跳。");
      }
      return;
    }

    await _heartbeatSemaphore.WaitAsync();
    try
    {
      await RefreshPrintersAsync();

      await _apiClient.SendHeartbeatAsync(
        CurrentState.Configuration.ServerUrl,
        CurrentState.Configuration.DeviceToken,
        CurrentState.Configuration.TerminalId,
        CurrentState.Configuration.TerminalName,
        CurrentState.Configuration.MachineName,
        CurrentState.Configuration.Platform,
        CurrentState.Configuration.SelectedPrinterName,
        CurrentState.Printers,
        BuildLabelProfile());

      CurrentState.LastHeartbeatAt = DateTimeOffset.Now.ToString("yyyy-MM-dd HH:mm:ss");
      CurrentState.LastError = string.Empty;
      AppendLog("心跳已发送，服务器状态已刷新。");
      EmitState();
    }
    catch (Exception ex)
    {
      CurrentState.LastError = ex.Message;
      if (!suppressErrors)
      {
        AppendLog($"心跳失败：{ex.Message}");
        EmitState();
      }
    }
    finally
    {
      _heartbeatSemaphore.Release();
    }
  }

  public async Task ClaimNowAsync(bool suppressErrors = false)
  {
    if (!CurrentState.IsPaired)
    {
      if (!suppressErrors)
      {
        AppendLog("尚未完成配对，暂时不能领取任务。");
      }
      return;
    }

    if (!await _pollSemaphore.WaitAsync(0)) return;
    try
    {
      var pending = await _journal.LoadAsync();
      if (pending is not null)
      {
        var configuration = CurrentState.Configuration.Clone();
        if (pending.ServerUrl != configuration.ServerUrl || pending.TerminalId != configuration.TerminalId)
          throw new InvalidOperationException("上一任务属于其他服务器或终端，请恢复原配置并核实结果。");
        await PrintResultRecovery.AcknowledgeAsync(pending, _journal,
          (id, token, status, error) => _apiClient.ReportJobStatusAsync(configuration.ServerUrl,
            configuration.DeviceToken, id, status, error, false, token),
          id => _apiClient.GetJobStateAsync(configuration.ServerUrl, configuration.DeviceToken, id), AppendLog);
        EmitState();
        return;
      }
      var claimResult = await _apiClient.ClaimNextJobAsync(
        CurrentState.Configuration.ServerUrl,
        CurrentState.Configuration.DeviceToken,
        CurrentState.Configuration.TerminalId);

      CurrentState.LastClaimAt = DateTimeOffset.Now.ToString("yyyy-MM-dd HH:mm:ss");

      if (claimResult.Job is null)
      {
        if (!string.IsNullOrWhiteSpace(claimResult.Message) && !suppressErrors)
        {
          AppendLog(claimResult.Message);
          EmitState();
        }
        return;
      }

      await ProcessPrintJobAsync(claimResult.Job);
    }
    catch (Exception ex)
    {
      CurrentState.LastError = ex.Message;
      if (!suppressErrors)
      {
        AppendLog($"打印任务处理或结果回写失败：{ex.Message}");
        EmitState();
      }
    }
    finally
    {
      _pollSemaphore.Release();
    }
  }

  public async Task TestPrintAsync()
  {
    if (string.IsNullOrWhiteSpace(CurrentState.Configuration.SelectedPrinterName))
    {
      throw new InvalidOperationException("请先选择标签打印机，再执行测试打印。");
    }

    await RefreshPrintersAsync();

    try
    {
      await _labelPrintService.PrintTestLabelAsync(CurrentState.Configuration.SelectedPrinterName);
      CurrentState.LastJobResult = $"测试标签已发送到 {CurrentState.Configuration.SelectedPrinterName}";
      AppendLog(CurrentState.LastJobResult);

      if (CurrentState.IsPaired)
      {
        await _apiClient.ReportTestPrintAsync(
          CurrentState.Configuration.ServerUrl,
          CurrentState.Configuration.DeviceToken,
          CurrentState.Configuration.SelectedPrinterName,
          CurrentState.Printers,
          BuildLabelProfile(),
          true,
          null);
      }
    }
    catch (Exception ex)
    {
      CurrentState.LastError = ex.Message;
      CurrentState.LastJobResult = ex.Message;
      AppendLog($"测试打印失败：{ex.Message}");

      if (CurrentState.IsPaired)
      {
        await _apiClient.ReportTestPrintAsync(
          CurrentState.Configuration.ServerUrl,
          CurrentState.Configuration.DeviceToken,
          CurrentState.Configuration.SelectedPrinterName,
          CurrentState.Printers,
          BuildLabelProfile(),
          false,
          ex.Message);
      }
    }

    EmitState();
  }

  private async Task ProcessPrintJobAsync(PrintJobDto job)
  {
    var configuration = CurrentState.Configuration.Clone();
    await PrintResultRecovery.ExecuteAsync(job, configuration, _journal,
      (id, token, status, error) => _apiClient.ReportJobStatusAsync(configuration.ServerUrl,
        configuration.DeviceToken, id, status, error, false, token),
      id => _apiClient.GetJobStateAsync(configuration.ServerUrl, configuration.DeviceToken, id),
      async () =>
      {
        var payload = ResolvePayload(job);
        if (payload?.Items.Count is not > 0 || payload.RenderedLabels.Count == 0)
          throw new InvalidOperationException("缺少可用成品标签图，已阻止实际出纸。");
        var count = await _labelPrintService.PrintRenderedLabelImagesAsync(
          configuration.SelectedPrinterName, payload.RenderedLabels);
        CurrentState.LastJobResult = $"任务 {job.Id} 已发送到 {configuration.SelectedPrinterName}，共 {count} 张。";
        CurrentState.LastError = string.Empty;
      }, AppendLog);
    EmitState();
  }

  private AssetLabelPayload? ResolvePayload(PrintJobDto job)
  {
    if (job.Payload?.Items?.Count > 0)
    {
      return job.Payload;
    }

    if (job.PayloadJson.ValueKind == JsonValueKind.Object)
    {
      return JsonSerializer.Deserialize<AssetLabelPayload>(
        job.PayloadJson.GetRawText(),
        PrintAgentApiClient.SerializerOptions);
    }

    if (job.PayloadJson.ValueKind == JsonValueKind.String)
    {
      var raw = job.PayloadJson.GetString();
      if (!string.IsNullOrWhiteSpace(raw))
      {
        return JsonSerializer.Deserialize<AssetLabelPayload>(
          raw,
          PrintAgentApiClient.SerializerOptions);
      }
    }

    return null;
  }

  private void StartBackgroundLoops()
  {
    _runtimeCancellationTokenSource?.Cancel();
    _runtimeCancellationTokenSource?.Dispose();
    _runtimeCancellationTokenSource = new CancellationTokenSource();

    var cancellationToken = _runtimeCancellationTokenSource.Token;
    _heartbeatLoopTask = RunPeriodicLoopAsync(
      TimeSpan.FromSeconds(CurrentState.Configuration.HeartbeatIntervalSeconds),
      () => HeartbeatNowAsync(true),
      cancellationToken);
    _pollLoopTask = RunPeriodicLoopAsync(
      TimeSpan.FromSeconds(CurrentState.Configuration.PollIntervalSeconds),
      () => ClaimNowAsync(true),
      cancellationToken);
  }

  private async Task RunPeriodicLoopAsync(
    TimeSpan interval,
    Func<Task> action,
    CancellationToken cancellationToken)
  {
    if (interval <= TimeSpan.Zero)
    {
      return;
    }

    using var timer = new PeriodicTimer(interval);
    try
    {
      while (await timer.WaitForNextTickAsync(cancellationToken))
      {
        await action();
      }
    }
    catch (OperationCanceledException)
    {
    }
  }

  private static AgentConfiguration NormalizeConfiguration(AgentConfiguration configuration)
  {
    configuration.ServerUrl = NormalizeServerUrl(configuration.ServerUrl);
    configuration.TerminalName = NormalizeTerminalName(configuration.TerminalName);
    configuration.MachineName = string.IsNullOrWhiteSpace(configuration.MachineName)
      ? Environment.MachineName
      : configuration.MachineName.Trim();
    configuration.Platform = string.IsNullOrWhiteSpace(configuration.Platform)
      ? "windows"
      : configuration.Platform.Trim().ToLowerInvariant();
    configuration.HeartbeatIntervalSeconds = Math.Max(10, configuration.HeartbeatIntervalSeconds);
    configuration.PollIntervalSeconds = Math.Max(3, configuration.PollIntervalSeconds);
    return configuration;
  }

  private static string NormalizeServerUrl(string? serverUrl)
  {
    var value = string.IsNullOrWhiteSpace(serverUrl) ? "https://www.jsgdzc.cn" : serverUrl.Trim();
    return value.TrimEnd('/');
  }

  private static string NormalizeTerminalName(string? terminalName)
  {
    return string.IsNullOrWhiteSpace(terminalName) ? Environment.MachineName : terminalName.Trim();
  }

  private static PrintLabelProfile BuildLabelProfile()
  {
    return new PrintLabelProfile();
  }

  private void AppendLog(string message)
  {
    if (string.IsNullOrWhiteSpace(message))
    {
      return;
    }

    var line = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} {message}";
    CurrentState.LogLines.Insert(0, line);

    if (CurrentState.LogLines.Count > 80)
    {
      CurrentState.LogLines.RemoveRange(80, CurrentState.LogLines.Count - 80);
    }
  }

  private void EmitState()
  {
    StateChanged?.Invoke(this, CurrentState.Clone());
  }

  public void Dispose()
  {
    if (_disposed)
    {
      return;
    }

    _disposed = true;
    _runtimeCancellationTokenSource?.Cancel();
    _runtimeCancellationTokenSource?.Dispose();
    _heartbeatSemaphore.Dispose();
    _pollSemaphore.Dispose();
    _apiClient.Dispose();
  }
}

internal sealed class AgentConfigurationStore
{
  private readonly JsonSerializerOptions _serializerOptions = new(JsonSerializerDefaults.Web)
  {
    WriteIndented = true
  };

  private readonly string _configFilePath;

  public AgentConfigurationStore(string storageRoot)
  {
    Directory.CreateDirectory(storageRoot);
    _configFilePath = Path.Combine(storageRoot, "config.json");
  }

  public async Task<AgentConfiguration> LoadAsync()
  {
    if (!File.Exists(_configFilePath))
    {
      return new AgentConfiguration();
    }

    await using var stream = File.OpenRead(_configFilePath);
    return await JsonSerializer.DeserializeAsync<AgentConfiguration>(stream, _serializerOptions)
           ?? new AgentConfiguration();
  }

  public async Task SaveAsync(AgentConfiguration configuration)
  {
    Directory.CreateDirectory(Path.GetDirectoryName(_configFilePath)!);
    await using var stream = File.Create(_configFilePath);
    await JsonSerializer.SerializeAsync(stream, configuration, _serializerOptions);
  }
}

internal sealed class WindowsStartupManager
{
  private const string RunKeyPath = @"Software\Microsoft\Windows\CurrentVersion\Run";
  private const string StartupValueName = "JsgdzcPrintAgent";
  private readonly string _executablePath;

  public WindowsStartupManager(string executablePath)
  {
    _executablePath = executablePath;
  }

  public Task ApplyAsync(bool enabled)
  {
    using var key = Registry.CurrentUser.CreateSubKey(RunKeyPath);
    if (enabled)
    {
      key?.SetValue(StartupValueName, $"\"{_executablePath}\"");
    }
    else
    {
      key?.DeleteValue(StartupValueName, false);
    }

    return Task.CompletedTask;
  }
}

internal sealed class PrintAgentApiClient : IDisposable
{
  private readonly HttpClient _httpClient = new() { Timeout = TimeSpan.FromSeconds(15) };
  internal static JsonSerializerOptions SerializerOptions { get; } = new(JsonSerializerDefaults.Web)
  {
    PropertyNameCaseInsensitive = true
  };

  public Task<PairResponse> PairAsync(
    string serverUrl,
    string terminalName,
    string machineName,
    string platform,
    string pairCode)
  {
    return SendAsync<PairResponse>(
      serverUrl,
      "/api/print-agent/pair",
      HttpMethod.Post,
      new
      {
        code = pairCode,
        terminal_name = terminalName,
        machine_name = machineName,
        platform
      },
      null,
      false);
  }

  public Task SendHeartbeatAsync(
    string serverUrl,
    string deviceToken,
    int terminalId,
    string terminalName,
    string machineName,
    string platform,
    string selectedPrinterName,
    List<PrinterInfo> printerSnapshot,
    PrintLabelProfile labelProfile)
  {
    return SendAsync<object>(
      serverUrl,
      "/api/print-agent/heartbeat",
      HttpMethod.Post,
      new
      {
        terminal_id = terminalId,
        terminal_name = terminalName,
        machine_name = machineName,
        platform,
        selected_printer_name = selectedPrinterName,
        printer_snapshot = printerSnapshot,
        label_profile = labelProfile,
        protocol_version = 2
      },
      deviceToken,
      true);
  }

  public Task<PrintJobClaimData> ClaimNextJobAsync(string serverUrl, string deviceToken, int terminalId)
  {
    return SendAsync<PrintJobClaimData>(
      serverUrl,
      "/api/print-agent/jobs/claim",
      HttpMethod.Post,
      new
      {
        terminal_id = terminalId,
        protocol_version = 2
      },
      deviceToken,
      true);
  }

  public async Task ReportJobStatusAsync(
    string serverUrl,
    string deviceToken,
    int jobId,
    string status,
    string? errorMessage,
    bool retryable,
    string claimToken)
  {
    var result = await SendAsync<PrintJobState>(
      serverUrl,
      $"/api/print-agent/jobs/{jobId}/status",
      HttpMethod.Post,
      new
      {
        status,
        claim_token = claimToken,
        error_message = errorMessage,
        retryable
      },
      deviceToken,
      true);
    if (!result.HasValidState() || result.Id != jobId || result.ClaimToken != claimToken ||
      !(result.Status == status || (status == "failed" && result.Status == "result_unknown")))
      throw new InvalidOperationException("服务器未返回明确任务结果，保留本地恢复记录。");
  }

  public Task<PrintJobState> GetJobStateAsync(string serverUrl, string deviceToken, int jobId)
  {
    return SendAsync<PrintJobState>(serverUrl, $"/api/print-agent/jobs/{jobId}/state",
      HttpMethod.Get, null, deviceToken, true);
  }

  public Task ReportTestPrintAsync(
    string serverUrl,
    string deviceToken,
    string selectedPrinterName,
    List<PrinterInfo> printerSnapshot,
    PrintLabelProfile labelProfile,
    bool success,
    string? errorMessage)
  {
    return SendAsync<object>(
      serverUrl,
      "/api/print-agent/test-print",
      HttpMethod.Post,
      new
      {
        selected_printer_name = selectedPrinterName,
        printer_snapshot = printerSnapshot,
        label_profile = labelProfile,
        success,
        error_message = errorMessage
      },
      deviceToken,
      true);
  }

  public Task<PrintAgentReleaseCollection> GetReleasesAsync(string serverUrl)
  {
    return SendAsync<PrintAgentReleaseCollection>(
      serverUrl,
      "/downloads/print-agent/releases",
      HttpMethod.Get,
      null,
      null,
      false);
  }

  public Task<DriverLatestInfo> GetLatestDriverAsync(string serverUrl)
  {
    return SendAsync<DriverLatestInfo>(
      serverUrl,
      "/downloads/printer-driver/xprinter/latest",
      HttpMethod.Get,
      null,
      null,
      false);
  }

  public Task<List<DriverArchiveRelease>> GetArchivedDriversAsync(string serverUrl)
  {
    return SendAsync<List<DriverArchiveRelease>>(
      serverUrl,
      "/downloads/printer-driver/xprinter/archive",
      HttpMethod.Get,
      null,
      null,
      false);
  }

  private async Task<T> SendAsync<T>(
    string serverUrl,
    string endpoint,
    HttpMethod method,
    object? body,
    string? deviceToken,
    bool authorized)
  {
    using var request = new HttpRequestMessage(method, BuildUrl(serverUrl, endpoint));
    request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

    if (authorized)
    {
      if (string.IsNullOrWhiteSpace(deviceToken))
      {
        throw new InvalidOperationException("打印终端尚未完成认证。");
      }

      request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", deviceToken);
    }

    if (body is not null)
    {
      request.Content = new StringContent(
        JsonSerializer.Serialize(body, SerializerOptions),
        Encoding.UTF8,
        "application/json");
    }

    using var response = await _httpClient.SendAsync(request);
    var raw = await response.Content.ReadAsStringAsync();

    if (!response.IsSuccessStatusCode)
    {
      throw new PrintAgentRequestException((int)response.StatusCode,
        GetMessage(raw) ?? $"请求失败（{(int)response.StatusCode}）");
    }

    if (string.IsNullOrWhiteSpace(raw))
    {
      return Activator.CreateInstance<T>();
    }

    using var document = JsonDocument.Parse(raw);
    var root = document.RootElement;
    var dataElement = root;

    if (root.ValueKind == JsonValueKind.Object &&
        root.TryGetProperty("code", out _) &&
        root.TryGetProperty("data", out var wrapped))
    {
      dataElement = wrapped;
    }

    var result = JsonSerializer.Deserialize<T>(dataElement.GetRawText(), SerializerOptions);
    if (result is null)
    {
      throw new InvalidOperationException("服务器返回了空数据。");
    }

    return result;
  }

  private static string BuildUrl(string serverUrl, string endpoint)
  {
    var baseUrl = serverUrl.Trim().TrimEnd('/');
    if (baseUrl.EndsWith("/api", StringComparison.OrdinalIgnoreCase))
    {
      baseUrl = baseUrl[..^4];
    }

    return $"{baseUrl}{endpoint}";
  }

  private static string? GetMessage(string raw)
  {
    if (string.IsNullOrWhiteSpace(raw))
    {
      return null;
    }

    try
    {
      using var document = JsonDocument.Parse(raw);
      var root = document.RootElement;
      if (root.ValueKind != JsonValueKind.Object)
      {
        return null;
      }

      if (root.TryGetProperty("message", out var messageElement) &&
          messageElement.ValueKind == JsonValueKind.String)
      {
        return messageElement.GetString();
      }

      if (root.TryGetProperty("data", out var dataElement) &&
          dataElement.ValueKind == JsonValueKind.Object &&
          dataElement.TryGetProperty("message", out var nestedMessage) &&
          nestedMessage.ValueKind == JsonValueKind.String)
      {
        return nestedMessage.GetString();
      }
    }
    catch
    {
    }

    return null;
  }

  public void Dispose()
  {
    _httpClient.Dispose();
  }
}