atomic-design-poc/backend/src/BigRegister.Api/Data/ApplicationStore.cs

using System.Text.Json;
using BigRegister.Domain.Submissions;

namespace BigRegister.Api.Data;

/// <summary>
/// An application (aanvraag) — the system of record the dashboard reads. A wizard
/// creates one as a Concept on its first step, syncs its draft snapshot per step,
/// then submits it into the Concept → In behandeling → Goedgekeurd/Afgewezen
/// lifecycle (ADR-0002). Status is COMPUTED ON READ (see Mappers.ToStatusDto) so
/// auto-approval is purely a function of stored timestamps — no timers, no jobs.
/// </summary>
public sealed class Aanvraag
{
  public required string Id { get; init; }
  public required string Type { get; init; }   // registratie | herregistratie | intake
  public required string Owner { get; init; }
  public JsonElement? Draft { get; set; }       // opaque wizard machine snapshot (Concept only)
  public int StepIndex { get; set; }
  public int StepCount { get; set; }
  public List<string> DocumentIds { get; set; } = new();
  public string? Referentie { get; set; }       // set on submit
  public bool AutoApprovable { get; set; }       // set on submit: duo (registratie) / other types
  public string? Reden { get; set; }             // set on submit when rejected → Afgewezen
  public bool Submitted { get; set; }
  public DateTimeOffset CreatedAt { get; init; }
  public DateTimeOffset UpdatedAt { get; set; }
  public DateTimeOffset? SubmittedAt { get; set; }
}

/// <summary>
/// EF Core/SQLite-backed application store (WP-22 — was a static Dictionary),
/// mirrors <see cref="DocumentStore"/>. ponytail: one global lock — SQLite
/// tolerates only one writer at a time anyway, and this was already a single
/// coarse gate before the DB existed.
/// </summary>
public static class ApplicationStore
{
  /// After this window an auto-approvable submission reports Goedgekeurd (computed on read).
  public static readonly TimeSpan ProcessingWindow = TimeSpan.FromSeconds(8);

  private static readonly object _gate = new();

  /// Create a Concept for <paramref name="owner"/> — UNLESS one of this
  /// <paramref name="type"/> already exists unsubmitted. WP-35: at most one Concept per
  /// type is a server-enforced invariant (the FE's draft-sync only guards it best-effort).
  /// Race-free: the existence check and the insert share the single write gate. Returns
  /// null when a duplicate would be created (the caller maps that to 409 Conflict).
  public static Aanvraag? CreateConcept(string type, string owner)
  {
    var now = DateTimeOffset.UtcNow;
    lock (_gate)
    {
      using var db = Db.Create();
      if (db.Applications.Any(a => a.Owner == owner && a.Type == type && !a.Submitted))
        return null;
      var a = new Aanvraag { Id = Guid.NewGuid().ToString(), Type = type, Owner = owner, CreatedAt = now, UpdatedAt = now };
      db.Applications.Add(a);
      db.SaveChanges();
      return a;
    }
  }

  public static Aanvraag? Get(string id, string owner)
  {
    lock (_gate)
    {
      using var db = Db.Create();
      var a = db.Applications.Find(id);
      return a is not null && a.Owner == owner ? a : null;
    }
  }

  public static IReadOnlyList<Aanvraag> List(string owner)
  {
    lock (_gate)
    {
      using var db = Db.Create();
      return db.Applications.Where(a => a.Owner == owner).ToList();
    }
  }

  /// Admin: every case across all owners (WP-36). The per-owner List is the norm; this
  /// is the deliberate cross-owner read behind the admin-only /admin/cases endpoint.
  public static IReadOnlyList<Aanvraag> ListAll()
  {
    lock (_gate)
    {
      using var db = Db.Create();
      // Order client-side: SQLite can't ORDER BY a DateTimeOffset (same constraint the
      // rest of the store sidesteps by never sorting in the query).
      return db.Applications.ToList().OrderByDescending(a => a.UpdatedAt).ToList();
    }
  }

  /// Draft sync: idempotent upsert of the wizard snapshot. Only a Concept is mutable.
  public static bool SyncDraft(string id, string owner, JsonElement draft, int stepIndex, int stepCount, IReadOnlyList<string>? documentIds)
  {
    lock (_gate)
    {
      using var db = Db.Create();
      var a = db.Applications.Find(id);
      if (a is null || a.Owner != owner || a.Submitted) return false;
      a.Draft = draft.Clone();   // detach from the request's JsonDocument (disposed after the call)
      a.StepIndex = stepIndex;
      a.StepCount = stepCount;
      if (documentIds is not null) a.DocumentIds = documentIds.ToList();
      a.UpdatedAt = DateTimeOffset.UtcNow;
      db.SaveChanges();
      return true;
    }
  }

  /// Cancel a Concept: remove it and delete its (unlinked) documents. Linked docs
  /// (belonging to a submitted aanvraag) are left untouched by DocumentStore.
  public static bool Delete(string id, string owner)
  {
    List<string> docs;
    lock (_gate)
    {
      using var db = Db.Create();
      var a = db.Applications.Find(id);
      if (a is null || a.Owner != owner) return false;
      docs = a.DocumentIds.ToList();
      db.Applications.Remove(a);
      db.SaveChanges();
    }
    foreach (var d in docs) DocumentStore.DeleteOwned(d, owner);
    return true;
  }

  /// Admin: delete ANY case regardless of owner or submitted state (WP-36). The
  /// user-facing Delete refuses a submitted aanvraag and is owner-scoped; an admin
  /// managing the register may remove any case. Cascades to the case's documents
  /// using its own owner. Returns false only when the id doesn't exist.
  public static bool DeleteAny(string id)
  {
    string owner;
    List<string> docs;
    lock (_gate)
    {
      using var db = Db.Create();
      var a = db.Applications.Find(id);
      if (a is null) return false;
      owner = a.Owner;
      docs = a.DocumentIds.ToList();
      db.Applications.Remove(a);
      db.SaveChanges();
    }
    foreach (var d in docs) DocumentStore.DeleteOwned(d, owner);
    return true;
  }

  /// Submit transition. reject != null → Afgewezen; else accepted (In behandeling,
  /// auto-advancing to Goedgekeurd after the window when autoApprovable). Returns null
  /// if the aanvraag is gone or already submitted (idempotency guard).
  public static Aanvraag? Submit(string id, string owner, string? reject, bool autoApprovable, IReadOnlyList<string>? documentIds)
  {
    lock (_gate)
    {
      using var db = Db.Create();
      var a = db.Applications.Find(id);
      if (a is null || a.Owner != owner || a.Submitted) return null;
      a.Submitted = true;
      a.SubmittedAt = DateTimeOffset.UtcNow;
      a.UpdatedAt = a.SubmittedAt.Value;
      a.Referentie = SubmissionRules.NewReference();
      a.AutoApprovable = autoApprovable;
      a.Reden = reject;
      if (documentIds is not null) a.DocumentIds = documentIds.ToList();
      db.SaveChanges();
      return a;
    }
  }
}