CUB-33: integrate Moonraker filament usage polling

backend/Infrastructure/Services/FilamentUsageService.cs

@@ -0,0 +1,79 @@
+using Extrudex.Domain.Entities;
+using Extrudex.Domain.Interfaces;
+using Extrudex.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace Extrudex.Infrastructure.Services;
+
+/// <summary>
+/// EF Core–backed implementation of the filament usage service.
+/// Persists usage records to the database and provides query methods
+/// for retrieving usage by print job or spool.
+/// </summary>
+public class FilamentUsageService : IFilamentUsageService
+{
+    private readonly ExtrudexDbContext _dbContext;
+    private readonly ILogger<FilamentUsageService> _logger;
+
+    public FilamentUsageService(
+        ExtrudexDbContext dbContext,
+        ILogger<FilamentUsageService> logger)
+    {
+        _dbContext = dbContext;
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public async Task<FilamentUsage> RecordUsageAsync(
+        Guid printJobId,
+        Guid spoolId,
+        Guid printerId,
+        decimal gramsUsed,
+        decimal mmExtruded,
+        string? notes = null,
+        CancellationToken cancellationToken = default)
+    {
+        var usage = new FilamentUsage
+        {
+            PrintJobId = printJobId,
+            SpoolId = spoolId,
+            PrinterId = printerId,
+            GramsUsed = gramsUsed,
+            MmExtruded = mmExtruded,
+            RecordedAt = DateTime.UtcNow,
+            Notes = notes
+        };
+
+        _dbContext.FilamentUsages.Add(usage);
+        await _dbContext.SaveChangesAsync(cancellationToken);
+
+        _logger.LogInformation(
+            "Recorded filament usage: {Grams}g / {Mm}mm for print job {JobId} on spool {SpoolId}",
+            gramsUsed, mmExtruded, printJobId, spoolId);
+
+        return usage;
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<FilamentUsage>> GetByPrintJobAsync(
+        Guid printJobId,
+        CancellationToken cancellationToken = default)
+    {
+        return await _dbContext.FilamentUsages
+            .Where(u => u.PrintJobId == printJobId)
+            .OrderByDescending(u => u.RecordedAt)
+            .ToListAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<FilamentUsage>> GetBySpoolAsync(
+        Guid spoolId,
+        CancellationToken cancellationToken = default)
+    {
+        return await _dbContext.FilamentUsages
+            .Where(u => u.SpoolId == spoolId)
+            .OrderByDescending(u => u.RecordedAt)
+            .ToListAsync(cancellationToken);
+    }
+}

backend/Infrastructure/Services/MoonrakerClient.cs

@@ -0,0 +1,303 @@
+using System.Globalization;
+using System.Net.Http.Headers;
+using System.Text.Json;
+using Extrudex.Domain.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace Extrudex.Infrastructure.Services;
+
+/// <summary>
+/// HTTP client for communicating with the Moonraker REST API on
+/// Klipper-based printers (e.g., Elegoo Centauri Carbon).
+///
+/// Moonraker endpoints used:
+/// - GET /api/objects?print_stats — current print stats including filament used
+/// - GET /api/objects?history — job history with filament usage per job
+///
+/// Authentication: optional X-Api-Key header when API key is configured.
+/// </summary>
+public class MoonrakerClient : IMoonrakerClient
+{
+    private readonly HttpClient _httpClient;
+    private readonly ILogger<MoonrakerClient> _logger;
+
+    /// <summary>
+    /// Creates a new MoonrakerClient with the specified HTTP client and logger.
+    /// </summary>
+    /// <param name="httpClient">The HTTP client used for API calls.</param>
+    /// <param name="logger">Logger for diagnostic output.</param>
+    public MoonrakerClient(HttpClient httpClient, ILogger<MoonrakerClient> logger)
+    {
+        _httpClient = httpClient;
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public async Task<string> GetPrinterStatusAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey = null,
+        CancellationToken cancellationToken = default)
+    {
+        var baseUrl = BuildBaseUrl(hostnameOrIp, port);
+        var requestUrl = $"{baseUrl}/api/objects?print_stats";
+
+        using var request = new HttpRequestMessage(HttpMethod.Get, requestUrl);
+        ApplyApiKey(request, apiKey);
+
+        try
+        {
+            using var response = await _httpClient.SendAsync(request, cancellationToken);
+            response.EnsureSuccessStatusCode();
+
+            var json = await response.Content.ReadAsStringAsync(cancellationToken);
+            using var doc = JsonDocument.Parse(json);
+
+            // Moonraker returns: { "result": { "print_stats": { "state": "idle", ... } } }
+            var state = doc.RootElement
+                .GetProperty("result")
+                .GetProperty("print_stats")
+                .GetProperty("state")
+                .GetString();
+
+            return state ?? "unknown";
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogWarning(ex,
+                "Moonraker printer status request failed for {Host}:{Port}",
+                hostnameOrIp, port);
+            return "offline";
+        }
+        catch (JsonException ex)
+        {
+            _logger.LogWarning(ex,
+                "Malformed Moonraker response from {Host}:{Port}",
+                hostnameOrIp, port);
+            return "error";
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<MoonrakerFilamentUsage?> GetFilamentUsageAsync(
+        string hostnameOrIp,
+        int port,
+        string? apiKey = null,
+        CancellationToken cancellationToken = default)
+    {
+        var baseUrl = BuildBaseUrl(hostnameOrIp, port);
+
+        // Fetch current print_stats (has live filament_used for active/recent job)
+        PrintStatsResult? printStats = null;
+        try
+        {
+            printStats = await FetchPrintStatsAsync(baseUrl, apiKey, cancellationToken);
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogWarning(ex,
+                "Moonraker print_stats request failed for {Host}:{Port}",
+                hostnameOrIp, port);
+            return null;
+        }
+        catch (JsonException ex)
+        {
+            _logger.LogWarning(ex,
+                "Malformed Moonraker print_stats response from {Host}:{Port}",
+                hostnameOrIp, port);
+            return null;
+        }
+
+        if (printStats is null)
+            return null;
+
+        // Attempt to enrich with history data for timing info
+        HistoryResult? history = null;
+        try
+        {
+            history = await FetchHistoryAsync(baseUrl, apiKey, cancellationToken);
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogWarning(ex,
+                "Moonraker history request failed for {Host}:{Port}",
+                hostnameOrIp, port);
+        }
+        catch (JsonException ex)
+        {
+            _logger.LogWarning(ex,
+                "Malformed Moonraker history response from {Host}:{Port}",
+                hostnameOrIp, port);
+        }
+
+        DateTime? startedAt = null;
+        DateTime? completedAt = null;
+        double? printDurationSeconds = null;
+
+        if (history is not null)
+        {
+            startedAt = history.StartTime;
+            completedAt = history.EndTime;
+            printDurationSeconds = history.PrintDuration;
+        }
+
+        return new MoonrakerFilamentUsage
+        {
+            MmExtruded = printStats.FilamentUsedMm ?? 0m,
+            GcodeFileName = printStats.FileName,
+            PrintState = printStats.State ?? "unknown",
+            PrintDurationSeconds = printDurationSeconds,
+            StartedAt = startedAt,
+            CompletedAt = completedAt
+        };
+    }
+
+    /// <summary>
+    /// Fetches and parses print_stats from the Moonraker API.
+    /// </summary>
+    private async Task<PrintStatsResult?> FetchPrintStatsAsync(
+        string baseUrl,
+        string? apiKey,
+        CancellationToken cancellationToken)
+    {
+        var requestUrl = $"{baseUrl}/api/objects?print_stats";
+
+        using var request = new HttpRequestMessage(HttpMethod.Get, requestUrl);
+        ApplyApiKey(request, apiKey);
+
+        using var response = await _httpClient.SendAsync(request, cancellationToken);
+        response.EnsureSuccessStatusCode();
+
+        var json = await response.Content.ReadAsStringAsync(cancellationToken);
+        using var doc = JsonDocument.Parse(json);
+
+        if (!doc.RootElement.TryGetProperty("result", out var result) ||
+            !result.TryGetProperty("print_stats", out var stats))
+        {
+            _logger.LogWarning("Moonraker response missing 'print_stats' object");
+            return null;
+        }
+
+        return new PrintStatsResult
+        {
+            State = stats.TryGetProperty("state", out var stateEl) ? stateEl.GetString() : null,
+            FilamentUsedMm = stats.TryGetProperty("filament_used", out var filamentEl) &&
+                              filamentEl.ValueKind == JsonValueKind.Number
+                ? filamentEl.GetDecimal() : (decimal?)null,
+            FileName = stats.TryGetProperty("filename", out var fileEl) ? fileEl.GetString() : null
+        };
+    }
+
+    /// <summary>
+    /// Fetches and parses history (last job) from the Moonraker API.
+    /// </summary>
+    private async Task<HistoryResult?> FetchHistoryAsync(
+        string baseUrl,
+        string? apiKey,
+        CancellationToken cancellationToken)
+    {
+        var requestUrl = $"{baseUrl}/api/objects?history";
+
+        using var request = new HttpRequestMessage(HttpMethod.Get, requestUrl);
+        ApplyApiKey(request, apiKey);
+
+        using var response = await _httpClient.SendAsync(request, cancellationToken);
+        response.EnsureSuccessStatusCode();
+
+        var json = await response.Content.ReadAsStringAsync(cancellationToken);
+        using var doc = JsonDocument.Parse(json);
+
+        if (!doc.RootElement.TryGetProperty("result", out var result) ||
+            !result.TryGetProperty("history", out var history))
+        {
+            _logger.LogWarning("Moonraker response missing 'history' object");
+            return null;
+        }
+
+        // Try last_job first, then job
+        JsonElement jobEl;
+        if (!history.TryGetProperty("last_job", out jobEl) &&
+            !history.TryGetProperty("job", out jobEl))
+        {
+            _logger.LogDebug("Moonraker history has no 'last_job' or 'job' entry");
+            return null;
+        }
+
+        return new HistoryResult
+        {
+            StartTime = ParseDateTimeProperty(jobEl, "start_time"),
+            EndTime = ParseDateTimeProperty(jobEl, "end_time"),
+            PrintDuration = jobEl.TryGetProperty("print_duration", out var durEl) &&
+                            durEl.ValueKind == JsonValueKind.Number
+                ? durEl.GetDouble() : (double?)null
+        };
+    }
+
+    /// <summary>
+    /// Parses a Moonraker timestamp property (Unix epoch seconds or ISO 8601 string).
+    /// </summary>
+    private static DateTime? ParseDateTimeProperty(JsonElement element, string propertyName)
+    {
+        if (!element.TryGetProperty(propertyName, out var prop))
+            return null;
+
+        // Moonraker returns Unix epoch seconds as a number
+        if (prop.ValueKind == JsonValueKind.Number)
+        {
+            var epochSeconds = prop.GetDouble();
+            return DateTime.UnixEpoch.AddSeconds(epochSeconds);
+        }
+
+        // Fallback: try parsing as ISO 8601 string
+        if (prop.ValueKind == JsonValueKind.String)
+        {
+            var str = prop.GetString();
+            if (str is not null &&
+                DateTime.TryParse(str, CultureInfo.InvariantCulture,
+                    DateTimeStyles.AssumeUniversal, out var dt))
+            {
+                return dt.ToUniversalTime();
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Builds the base URL for Moonraker API calls.
+    /// </summary>
+    private static string BuildBaseUrl(string hostnameOrIp, int port) =>
+        $"http://{hostnameOrIp}:{port}";
+
+    /// <summary>
+    /// Applies the Moonraker API key to the request header if provided.
+    /// </summary>
+    private static void ApplyApiKey(HttpRequestMessage request, string? apiKey)
+    {
+        if (!string.IsNullOrWhiteSpace(apiKey))
+        {
+            request.Headers.Add("X-Api-Key", apiKey);
+        }
+    }
+
+    /// <summary>
+    /// Parsed result from Moonraker's print_stats object.
+    /// Extracted immediately from the JSON response to avoid JsonDocument disposal issues.
+    /// </summary>
+    private sealed class PrintStatsResult
+    {
+        public string? State { get; set; }
+        public decimal? FilamentUsedMm { get; set; }
+        public string? FileName { get; set; }
+    }
+
+    /// <summary>
+    /// Parsed result from Moonraker's history/last_job object.
+    /// </summary>
+    private sealed class HistoryResult
+    {
+        public DateTime? StartTime { get; set; }
+        public DateTime? EndTime { get; set; }
+        public double? PrintDuration { get; set; }
+    }
+}

backend/Infrastructure/Services/MoonrakerUsagePoller.cs

@@ -0,0 +1,431 @@
+using Extrudex.Domain.Entities;
+using Extrudex.Domain.Enums;
+using Extrudex.Domain.Interfaces;
+using Extrudex.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace Extrudex.Infrastructure.Services;
+
+/// <summary>
+/// Configuration options for the Moonraker usage polling service.
+/// </summary>
+public class MoonrakerPollerOptions
+{
+    /// <summary>
+    /// How often to poll each Moonraker printer for filament usage data.
+    /// Default: 30 seconds.
+    /// </summary>
+    public TimeSpan PollInterval { get; set; } = TimeSpan.FromSeconds(30);
+
+    /// <summary>
+    /// Timeout for individual Moonraker HTTP requests.
+    /// Default: 10 seconds.
+    /// </summary>
+    public TimeSpan RequestTimeout { get; set; } = TimeSpan.FromSeconds(10);
+
+    /// <summary>
+    /// Whether the polling service is enabled. Default: true.
+    /// Set to false to disable polling (e.g., in development or testing).
+    /// </summary>
+    public bool Enabled { get; set; } = true;
+}
+
+/// <summary>
+/// Background service that periodically polls Moonraker-connected printers
+/// for filament usage data. When a print job is detected as complete,
+/// the usage data is persisted to the FilamentUsage table via
+/// <see cref="IFilamentUsageService"/>.
+///
+/// <para>Polling logic:</para>
+/// <list type="number">
+///   <item>Query the database for all active printers with ConnectionType == Moonraker.</item>
+///   <item>For each printer, call <see cref="IMoonrakerClient.GetFilamentUsageAsync"/>.</item>
+///   <item>If usage data is available and the print state is "complete",
+///         create or update a FilamentUsage record.</item>
+///   <item>If the printer is unreachable or returns malformed data, log a warning
+///         and continue to the next printer (no crash).</item>
+/// </list>
+///
+/// <para>Error handling:</para>
+/// <list type="bullet">
+///   <item>API unreachable: logged as warning, poller continues for other printers.</item>
+///   <item>Malformed response: logged as warning, poller continues.</item>
+///   <item>Database errors: logged as error, poller continues.</item>
+/// </list>
+/// </summary>
+public class MoonrakerUsagePoller : BackgroundService
+{
+    private readonly IServiceScopeFactory _scopeFactory;
+    private readonly ILogger<MoonrakerUsagePoller> _logger;
+    private readonly MoonrakerPollerOptions _options;
+
+    /// <summary>
+    /// Tracks which Moonraker print jobs have already been recorded,
+    /// keyed by "printerId:gcodeFileName" to avoid duplicate recording.
+    /// </summary>
+    private readonly HashSet<string> _recordedJobs = new();
+
+    public MoonrakerUsagePoller(
+        IServiceScopeFactory scopeFactory,
+        ILogger<MoonrakerUsagePoller> logger,
+        IOptions<MoonrakerPollerOptions> options)
+    {
+        _scopeFactory = scopeFactory;
+        _logger = logger;
+        _options = options.Value;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        if (!_options.Enabled)
+        {
+            _logger.LogInformation("Moonraker usage poller is disabled via configuration.");
+            return;
+        }
+
+        _logger.LogInformation(
+            "Moonraker usage poller starting. Poll interval: {Interval}",
+            _options.PollInterval);
+
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            try
+            {
+                await PollAllPrintersAsync(stoppingToken);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex,
+                    "Unexpected error in Moonraker usage poller cycle. Continuing.");
+            }
+
+            await Task.Delay(_options.PollInterval, stoppingToken);
+        }
+
+        _logger.LogInformation("Moonraker usage poller stopping.");
+    }
+
+    /// <summary>
+    /// Polls all active Moonraker printers for filament usage data
+    /// and persists any completed print usage records.
+    /// </summary>
+    private async Task PollAllPrintersAsync(CancellationToken cancellationToken)
+    {
+        using var scope = _scopeFactory.CreateScope();
+        var dbContext = scope.ServiceProvider.GetRequiredService<ExtrudexDbContext>();
+        var moonrakerClient = scope.ServiceProvider.GetRequiredService<IMoonrakerClient>();
+        var usageService = scope.ServiceProvider.GetRequiredService<IFilamentUsageService>();
+
+        // Get all active Moonraker printers
+        var printers = await dbContext.Printers
+            .Where(p => p.IsActive && p.ConnectionType == ConnectionType.Moonraker)
+            .ToListAsync(cancellationToken);
+
+        if (printers.Count == 0)
+        {
+            _logger.LogDebug("No active Moonraker printers found.");
+            return;
+        }
+
+        _logger.LogDebug("Polling {Count} Moonraker printer(s).", printers.Count);
+
+        foreach (var printer in printers)
+        {
+            await PollPrinterAsync(
+                printer, moonrakerClient, usageService, dbContext, cancellationToken);
+        }
+    }
+
+    /// <summary>
+    /// Polls a single Moonraker printer for filament usage data.
+    /// If a completed print job is detected with usage data, it is persisted.
+    /// </summary>
+    private async Task PollPrinterAsync(
+        Printer printer,
+        IMoonrakerClient moonrakerClient,
+        IFilamentUsageService usageService,
+        ExtrudexDbContext dbContext,
+        CancellationToken cancellationToken)
+    {
+        _logger.LogDebug(
+            "Polling Moonraker printer {PrinterName} ({Host}:{Port})",
+            printer.Name, printer.HostnameOrIp, printer.Port);
+
+        try
+        {
+            // Update last-seen timestamp regardless of usage data
+            var usageData = await moonrakerClient.GetFilamentUsageAsync(
+                printer.HostnameOrIp,
+                printer.Port,
+                printer.ApiKey,
+                cancellationToken);
+
+            if (usageData is null)
+            {
+                _logger.LogDebug(
+                    "No filament usage data from printer {PrinterName}.",
+                    printer.Name);
+                return;
+            }
+
+            // Update printer last-seen timestamp
+            printer.LastSeenAt = DateTime.UtcNow;
+            await dbContext.SaveChangesAsync(cancellationToken);
+
+            _logger.LogDebug(
+                "Printer {PrinterName}: state={State}, mm={Mm}, file={File}",
+                printer.Name, usageData.PrintState, usageData.MmExtruded,
+                usageData.GcodeFileName);
+
+            // Only record usage for completed prints
+            if (usageData.MmExtruded <= 0)
+            {
+                _logger.LogDebug(
+                    "Printer {PrinterName} has no filament usage to record.",
+                    printer.Name);
+                return;
+            }
+
+            if (!IsCompleteState(usageData.PrintState))
+            {
+                _logger.LogDebug(
+                    "Printer {PrinterName} print state '{State}' is not complete; skipping.",
+                    printer.Name, usageData.PrintState);
+                return;
+            }
+
+            // Deduplicate: avoid recording the same completed job twice
+            var deduplicationKey = $"{printer.Id}:{usageData.GcodeFileName}";
+            if (_recordedJobs.Contains(deduplicationKey))
+            {
+                _logger.LogDebug(
+                    "Printer {PrinterName} job '{File}' already recorded; skipping.",
+                    printer.Name, usageData.GcodeFileName);
+                return;
+            }
+
+            // Find or create a PrintJob for this usage
+            var printJob = await FindOrCreatePrintJobAsync(
+                dbContext, printer, usageData, cancellationToken);
+
+            if (printJob is null)
+            {
+                _logger.LogWarning(
+                    "Could not find or create print job for printer {PrinterName}. " +
+                    "No active spool found.",
+                    printer.Name);
+                return;
+            }
+
+            // Calculate grams from mm extruded using spool properties
+            var spool = await dbContext.Spools.FindAsync(
+                new object[] { printJob.SpoolId }, cancellationToken);
+
+            var gramsUsed = CalculateGramsUsed(usageData.MmExtruded, spool);
+
+            await usageService.RecordUsageAsync(
+                printJobId: printJob.Id,
+                spoolId: printJob.SpoolId,
+                printerId: printer.Id,
+                gramsUsed: gramsUsed,
+                mmExtruded: usageData.MmExtruded,
+                notes: $"Moonraker auto-recorded: {usageData.GcodeFileName}",
+                cancellationToken: cancellationToken);
+
+            // Mark job as recorded to prevent duplicates
+            _recordedJobs.Add(deduplicationKey);
+
+            _logger.LogInformation(
+                "Recorded Moonraker usage for printer {PrinterName}: " +
+                "{Mm}mm / {Grams}g, job '{File}'",
+                printer.Name, usageData.MmExtruded, gramsUsed,
+                usageData.GcodeFileName);
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogWarning(ex,
+                "Moonraker API unreachable for printer {PrinterName} ({Host}:{Port}). " +
+                "Will retry next cycle.",
+                printer.Name, printer.HostnameOrIp, printer.Port);
+        }
+        catch (TaskCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            // Shutdown requested — rethrow to exit the poll loop
+            throw;
+        }
+        catch (TaskCanceledException ex)
+        {
+            _logger.LogWarning(ex,
+                "Moonraker request timed out for printer {PrinterName} ({Host}:{Port}).",
+                printer.Name, printer.HostnameOrIp, printer.Port);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex,
+                "Unexpected error polling Moonraker printer {PrinterName}. " +
+                "Continuing to next printer.",
+                printer.Name);
+        }
+    }
+
+    /// <summary>
+    /// Determines if a Moonraker print state indicates a completed job
+    /// that should have its usage recorded.
+    /// </summary>
+    private static bool IsCompleteState(string state) =>
+        state.Equals("complete", StringComparison.OrdinalIgnoreCase) ||
+        state.Equals("completed", StringComparison.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// Finds an existing PrintJob for the current g-code file on this printer,
+    /// or creates a new one. Returns null if no spool is available.
+    /// </summary>
+    private async Task<PrintJob?> FindOrCreatePrintJobAsync(
+        ExtrudexDbContext dbContext,
+        Printer printer,
+        MoonrakerFilamentUsage usageData,
+        CancellationToken cancellationToken)
+    {
+        // Try to find an existing print job for this g-code file on this printer
+        if (!string.IsNullOrEmpty(usageData.GcodeFileName))
+        {
+            var existingJob = await dbContext.PrintJobs
+                .Where(j => j.PrinterId == printer.Id &&
+                            j.GcodeFilePath == usageData.GcodeFileName &&
+                            j.DataSource == DataSource.Moonraker &&
+                            j.Status != JobStatus.Cancelled)
+                .OrderByDescending(j => j.CreatedAt)
+                .FirstOrDefaultAsync(cancellationToken);
+
+            if (existingJob is not null)
+            {
+                // Update the existing job with completion data
+                existingJob.MmExtruded = usageData.MmExtruded;
+                existingJob.GramsDerived = CalculateGramsUsed(
+                    usageData.MmExtruded,
+                    await dbContext.Spools.FindAsync(
+                        new object[] { existingJob.SpoolId }, cancellationToken));
+                existingJob.Status = JobStatus.Completed;
+                existingJob.CompletedAt = usageData.CompletedAt ?? DateTime.UtcNow;
+                existingJob.StartedAt ??= usageData.StartedAt;
+
+                await dbContext.SaveChangesAsync(cancellationToken);
+                return existingJob;
+            }
+        }
+
+        // No existing job — find the first active spool for this printer
+        // via AMS slots, or fall back to any active spool
+        var spool = await FindActiveSpoolForPrinterAsync(dbContext, printer, cancellationToken);
+
+        if (spool is null)
+        {
+            return null;
+        }
+
+        var gramsDerived = CalculateGramsUsed(usageData.MmExtruded, spool);
+
+        var newJob = new PrintJob
+        {
+            PrinterId = printer.Id,
+            SpoolId = spool.Id,
+            PrintName = usageData.GcodeFileName ?? "Moonraker Print",
+            GcodeFilePath = usageData.GcodeFileName,
+            MmExtruded = usageData.MmExtruded,
+            GramsDerived = gramsDerived,
+            FilamentDiameterAtPrintMm = spool.FilamentDiameterMm,
+            MaterialDensityAtPrint = GetMaterialDensity(spool),
+            DataSource = DataSource.Moonraker,
+            Status = JobStatus.Completed,
+            StartedAt = usageData.StartedAt ?? DateTime.UtcNow,
+            CompletedAt = usageData.CompletedAt ?? DateTime.UtcNow,
+            Notes = "Auto-created by Moonraker usage poller"
+        };
+
+        dbContext.PrintJobs.Add(newJob);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        return newJob;
+    }
+
+    /// <summary>
+    /// Finds an active spool associated with the printer via AMS slots,
+    /// or falls back to any active spool in the system.
+    /// </summary>
+    private static async Task<Spool?> FindActiveSpoolForPrinterAsync(
+        ExtrudexDbContext dbContext,
+        Printer printer,
+        CancellationToken cancellationToken)
+    {
+        // Try to find a spool loaded in the printer's AMS
+        var amsSpool = await dbContext.AmsSlots
+            .Include(s => s.Spool)
+            .ThenInclude(s => s!.MaterialBase)
+            .Include(s => s.AmsUnit)
+            .Where(s => s.AmsUnit.PrinterId == printer.Id && s.Spool != null && s.Spool.IsActive)
+            .Select(s => s.Spool)
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (amsSpool is not null)
+            return amsSpool;
+
+        // Fallback: any active spool (for non-AMS printers)
+        return await dbContext.Spools
+            .Include(s => s.MaterialBase)
+            .Where(s => s.IsActive)
+            .OrderByDescending(s => s.WeightRemainingGrams)
+            .FirstOrDefaultAsync(cancellationToken);
+    }
+
+    /// <summary>
+    /// Calculates grams used from mm extruded using the spool's filament
+    /// diameter and the material density.
+    /// Formula: grams = mm × π × (diameter/2)² × density
+    /// Where density is in g/cm³, diameter in mm, giving grams.
+    /// </summary>
+    private static decimal CalculateGramsUsed(decimal mmExtruded, Spool? spool)
+    {
+        if (spool is null)
+            return 0m;
+
+        var diameterMm = spool.FilamentDiameterMm;
+        var densityGcm3 = GetMaterialDensity(spool);
+
+        // Cross-section area (mm²) = π × (diameter/2)²
+        var radiusMm = diameterMm / 2m;
+        var crossSectionArea = Math.PI * (double)radiusMm * (double)radiusMm;
+
+        // Volume (mm³) = mm_extruded × cross_section_area
+        // Convert mm³ to cm³: 1 cm³ = 1000 mm³
+        // Weight (g) = volume_cm³ × density (g/cm³)
+        var volumeMm3 = (double)mmExtruded * crossSectionArea;
+        var volumeCm3 = volumeMm3 / 1000.0;
+        var grams = volumeCm3 * (double)densityGcm3;
+
+        return Math.Round((decimal)grams, 2);
+    }
+
+    /// <summary>
+    /// Returns the material density for the spool's material base.
+    /// Falls back to 1.24 g/cm³ (typical PLA density) if not available.
+    /// </summary>
+    private static decimal GetMaterialDensity(Spool? spool)
+    {
+        // Standard material densities (g/cm³)
+        // These would ideally come from the MaterialBase entity,
+        // but we use sensible defaults for the initial integration.
+        return spool?.MaterialBase?.Name?.ToUpperInvariant() switch
+        {
+            "PLA" => 1.24m,
+            "PETG" => 1.27m,
+            "ABS" => 1.04m,
+            "ASA" => 1.07m,
+            "TPU" => 1.21m,
+            "NYLON" or "PA" => 1.13m,
+            "PC" => 1.20m,
+            _ => 1.24m // Default to PLA density
+        };
+    }
+}