maraphon-app/src/Marathon.Infrastructure/Persistence/Repositories/AnomalyRepository.cs

using Marathon.Application.Abstractions;
using Marathon.Domain.Entities;
using Microsoft.EntityFrameworkCore;

namespace Marathon.Infrastructure.Persistence.Repositories;

internal sealed class AnomalyRepository : IAnomalyRepository
{
    private readonly MarathonDbContext _db;

    public AnomalyRepository(MarathonDbContext db) => _db = db;

    public async Task<Anomaly?> GetAsync(Guid key, CancellationToken ct = default)
    {
        var idStr = key.ToString();
        var entity = await _db.Anomalies.FirstOrDefaultAsync(a => a.Id == idStr, ct);
        return entity is null ? null : Mapping.ToDomain(entity);
    }

    public async Task<IReadOnlyList<Anomaly>> ListAsync(CancellationToken ct = default)
    {
        var entities = await _db.Anomalies.AsNoTracking().ToListAsync(ct);
        return entities.Select(Mapping.ToDomain).ToList().AsReadOnly();
    }

    public async Task<int> CountSinceAsync(DateTimeOffset since, CancellationToken ct = default)
    {
        // Server-side COUNT(*) — the unread-badge hot path must not materialise the
        // whole table (with EvidenceJson) just to count. DetectedAt is stored as the
        // O-format TEXT key (see SqliteDateText); ">" matches the prior in-memory
        // GetUnreadCountAsync semantics (strictly newer than the last-seen marker).
        var sinceStr = SqliteDateText.Key(since);
        return await _db.Anomalies.AsNoTracking()
            .Where(a => a.DetectedAt.CompareTo(sinceStr) > 0)
            .CountAsync(ct);
    }

    public async Task<IReadOnlyList<Anomaly>> ListByDateRangeAsync(
        DateTimeOffset? from,
        DateTimeOffset? to,
        CancellationToken ct = default)
    {
        var q = _db.Anomalies.AsNoTracking();

        if (from is { } f)
        {
            var fromStr = SqliteDateText.Key(f);
            q = q.Where(a => a.DetectedAt.CompareTo(fromStr) >= 0);
        }

        if (to is { } t)
        {
            var toStr = SqliteDateText.Key(t);
            q = q.Where(a => a.DetectedAt.CompareTo(toStr) <= 0);
        }

        var entities = await q
            .OrderByDescending(a => a.DetectedAt)
            .ToListAsync(ct);

        return entities.Select(Mapping.ToDomain).ToList().AsReadOnly();
    }

    public async Task AddAsync(Anomaly entity, CancellationToken ct = default)
    {
        var efEntity = Mapping.ToEntity(entity);
        await _db.Anomalies.AddAsync(efEntity, ct);
    }

    public Task UpdateAsync(Anomaly entity, CancellationToken ct = default)
    {
        var efEntity = Mapping.ToEntity(entity);
        _db.Anomalies.Update(efEntity);
        return Task.CompletedTask;
    }

    public async Task DeleteAsync(Guid key, CancellationToken ct = default)
    {
        var idStr = key.ToString();
        var entity = await _db.Anomalies.FirstOrDefaultAsync(a => a.Id == idStr, ct);
        if (entity is not null)
            _db.Anomalies.Remove(entity);
    }

    public async Task SaveChangesAsync(CancellationToken ct = default) =>
        await _db.SaveChangesAsync(ct);
}