TableService.cs

using Azure;
using Azure.Data.Tables;
using System.Collections.Concurrent;
using System.Globalization;

namespace SchoolHelpdesk;

public static class TableService
{
  private static TableClient ticketsClient;
  private static int latestTicketId = -1;

  public static void Configure(string connectionString)
  {
    ticketsClient = new TableServiceClient(connectionString).GetTableClient("tickets");
  }

  public static async Task WarmUpAsync()
  {
    var nonExistentKey = "warmup";
    await foreach (var _ in ticketsClient.QueryAsync<TableEntity>(o => o.PartitionKey == nonExistentKey)) { }
  }

  public static async Task<TicketEntity> GetTicketAsync(string assigneeEmail, int id)
  {
    ArgumentNullException.ThrowIfNull(assigneeEmail);
    var ticket = await ticketsClient.GetEntityAsync<TicketEntity>(assigneeEmail, id.ToRowKey());
    return ticket.Value;
  }

  public static async Task<TicketEntity> GetTicketAsync(int id)
  {
    return await ticketsClient.QueryAsync<TicketEntity>(o => o.RowKey == id.ToRowKey()).SingleOrDefaultAsync();
  }

  public static async Task<List<TicketEntity>> GetAllTicketsAsync(DateTime? after = null)
  {
    var tickets = after is null
      ? await ticketsClient.QueryAsync<TicketEntity>().ToListAsync()
      : await ticketsClient.QueryAsync<TicketEntity>(o => o.LastUpdated > after.Value || !o.IsClosed).ToListAsync();
    return tickets.OrderByDescending(t => t.LastUpdated).ToList();
  }

  public static async Task<List<TicketEntity>> GetTicketsByAssigneeAsync(string assigneeEmail, DateTime? after = null)
  {
    ArgumentNullException.ThrowIfNull(assigneeEmail);
    var tickets = after is null
      ? await ticketsClient.QueryAsync<TicketEntity>(o => o.PartitionKey == assigneeEmail).ToListAsync()
      : await ticketsClient.QueryAsync<TicketEntity>(o => o.PartitionKey == assigneeEmail && (o.LastUpdated > after.Value || !o.IsClosed)).ToListAsync();
    return tickets.OrderByDescending(t => t.LastUpdated).ToList();
  }

  public static async Task<bool> TicketExistsAsync(string assigneeEmail, int id)
  {
    ArgumentNullException.ThrowIfNull(assigneeEmail);
    if (LastUpdatedCache.TryGetValue(id, out var cacheItem) && cacheItem.AssigneeEmail == assigneeEmail)
    {
      return true;
    }
    var ticket = await ticketsClient.GetEntityIfExistsAsync<TicketEntity>(assigneeEmail, id.ToRowKey(), select: ["RowKey"]);
    return ticket.HasValue;
  }

  public static async Task<int> CreateTicketAsync(TicketEntity ticket)
  {
    ArgumentNullException.ThrowIfNull(ticket);
    if (latestTicketId < 0) throw new InvalidOperationException("Latest ticket ID not initialized.");

    var id = Interlocked.Increment(ref latestTicketId);
    ticket.Created = DateTime.UtcNow;
    ticket.LastUpdated = ticket.Created;
    ticket.WaitingSince = ticket.Created;
    ticket.RowKey = id.ToRowKey();
    var response = await ticketsClient.AddEntityAsync(ticket);
    ticket.ETag = response.Headers.ETag.Value;
    SetLastUpdatedCache(id, ticket.PartitionKey, ticket.LastUpdated);
    return id;
  }

  public static async Task<TicketEntity> ReassignTicketAsync(string assigneeEmail, int id, string newAssigneeEmail, string newAssigneeName, int? newAssigneeId)
  {
    ArgumentNullException.ThrowIfNull(assigneeEmail);
    ArgumentNullException.ThrowIfNull(newAssigneeEmail);
    if (assigneeEmail == newAssigneeEmail) throw new ArgumentException("New assignee email must be different from current assignee email.");

    var rowKey = id.ToRowKey();
    var ticket = await ticketsClient.GetEntityAsync<TicketEntity>(assigneeEmail, rowKey);
    ticket.Value.PartitionKey = newAssigneeEmail;
    ticket.Value.AssigneeId = newAssigneeId;
    ticket.Value.AssigneeName = newAssigneeName;
    ticket.Value.LastUpdated = DateTime.UtcNow;
    ticket.Value.AverageAssigneeResponseTime = null;
    var response = await ticketsClient.AddEntityAsync(ticket.Value);
    ticket.Value.ETag = response.Headers.ETag.Value;
    await ticketsClient.DeleteEntityAsync(assigneeEmail, rowKey);
    SetLastUpdatedCache(id, newAssigneeEmail, ticket.Value.LastUpdated);
    return ticket.Value;
  }

  public static async Task RenameTicketAsync(string assigneeEmail, int id, string newTitle)
  {
    ArgumentNullException.ThrowIfNull(assigneeEmail);
    ArgumentNullException.ThrowIfNull(newTitle);
    var ticket = await ticketsClient.GetEntityAsync<TicketEntity>(assigneeEmail, id.ToRowKey());
    ticket.Value.Title = newTitle;
    await ticketsClient.UpdateEntityAsync(ticket.Value, ticket.Value.ETag, TableUpdateMode.Replace);
  }

  public static async Task<DateTime?> CloseTicketAsync(string assigneeEmail, int id, bool isClosed)
  {
    ArgumentNullException.ThrowIfNull(assigneeEmail);
    var ticket = await ticketsClient.GetEntityAsync<TicketEntity>(assigneeEmail, id.ToRowKey());
    if (ticket.Value.IsClosed == isClosed) return null;
    ticket.Value.IsClosed = isClosed;
    ticket.Value.LastUpdated = DateTime.UtcNow;
    await ticketsClient.UpdateEntityAsync(ticket.Value, ticket.Value.ETag, TableUpdateMode.Replace);
    SetLastUpdatedCache(id, assigneeEmail, ticket.Value.LastUpdated);
    return ticket.Value.LastUpdated;
  }

  public static async Task ChangeTicketStudentAsync(TicketEntity ticket, Student student)
  {
    ArgumentNullException.ThrowIfNull(ticket);
    if (student is not null && (ticket.StudentId is not null
      ? ticket.StudentId == student.Id
      : string.Equals(ticket.StudentFirstName, student.FirstName, StringComparison.OrdinalIgnoreCase) &&
        string.Equals(ticket.StudentLastName, student.LastName, StringComparison.OrdinalIgnoreCase) &&
        string.Equals(ticket.TutorGroup, student.TutorGroup, StringComparison.OrdinalIgnoreCase)))
      return;
    ticket.StudentId = student?.Id;
    ticket.StudentFirstName = student?.FirstName;
    ticket.StudentLastName = student?.LastName;
    ticket.TutorGroup = student?.TutorGroup;
    ticket.ParentRelationship = student?.ParentRelationship;
    var response = await ticketsClient.UpdateEntityAsync(ticket, ticket.ETag, TableUpdateMode.Replace);
    ticket.ETag = response.Headers.ETag.Value;
  }

  public static async Task ChangeTicketParentAsync(TicketEntity ticket, Parent parent, string relationship)
  {
    ArgumentNullException.ThrowIfNull(ticket);
    ArgumentNullException.ThrowIfNull(parent);
    ticket.ParentName = parent.Name;
    ticket.ParentEmail = parent.Email;
    ticket.ParentPhone = parent.Phone;
    ticket.ParentRelationship = relationship;
    var response = await ticketsClient.UpdateEntityAsync(ticket, ticket.ETag, TableUpdateMode.Replace);
    ticket.ETag = response.Headers.ETag.Value;
  }

  public static async Task SetLastUpdatedAsync(TicketEntity ticket, DateTime lastUpdated, bool cancelWaiting, int? firstTime, int? averageTime)
  {
    ArgumentNullException.ThrowIfNull(ticket);
    ticket.LastUpdated = lastUpdated;
    ticket.TimeToFirstResponse = firstTime;
    ticket.AverageAssigneeResponseTime = averageTime;
    if (cancelWaiting) ticket.WaitingSince = null;
    var response = await ticketsClient.UpdateEntityAsync(ticket, ticket.ETag, TableUpdateMode.Replace);
    ticket.ETag = response.Headers.ETag.Value;
    SetLastUpdatedCache(int.Parse(ticket.RowKey, CultureInfo.InvariantCulture), ticket.PartitionKey, lastUpdated);
  }

  public static async Task UpdateForNewParentMessageAsync(TicketEntity ticket, DateTime lastUpdated)
  {
    ArgumentNullException.ThrowIfNull(ticket);
    ticket.LastUpdated = lastUpdated;
    ticket.WaitingSince ??= lastUpdated;
    ticket.IsClosed = false;
    var response = await ticketsClient.UpdateEntityAsync(ticket, ticket.ETag, TableUpdateMode.Replace);
    ticket.ETag = response.Headers.ETag.Value;
    SetLastUpdatedCache(int.Parse(ticket.RowKey, CultureInfo.InvariantCulture), ticket.PartitionKey, lastUpdated);
  }

  public static string ToRowKey(this int id)
  {
    return id.ToString("D6", CultureInfo.InvariantCulture);
  }

  private static readonly ConcurrentDictionary<int, TicketCacheItem> LastUpdatedCache = [];

  public static async Task<DateTime?> GetTicketCacheItemAsync(int ticketId, string user)
  {
    if (!LastUpdatedCache.TryGetValue(ticketId, out var cacheItem))
    {
      var ticket = await ticketsClient.QueryAsync<TicketEntity>(o => o.RowKey == ticketId.ToRowKey(), select: ["PartitionKey", "LastUpdated"]).SingleOrDefaultAsync();
      if (ticket is null) return null;
      cacheItem = new(ticket.PartitionKey, ticket.LastUpdated);
      LastUpdatedCache[ticketId] = cacheItem;
    }
    return user is null || user == cacheItem.AssigneeEmail ? cacheItem.LastUpdated : null;
  }

  public static void SetLastUpdatedCache(int ticketId, string assignee, DateTime lastUpdated)
  {
    LastUpdatedCache[ticketId] = new(assignee, lastUpdated);
  }

  public static async Task HydrateCacheAsync()
  {
    LastUpdatedCache.Clear();
    var maxId = 0;
    await foreach (var ticket in ticketsClient.QueryAsync<TicketEntity>(select: ["RowKey", "PartitionKey", "LastUpdated"]))
    {
      var id = int.Parse(ticket.RowKey, CultureInfo.InvariantCulture);
      LastUpdatedCache[id] = new(ticket.PartitionKey, ticket.LastUpdated);
      if (id > maxId) maxId = id;
    }
    latestTicketId = maxId;
  }
}

public static class QueryExtensions
{
  public static async Task<List<T>> ToListAsync<T>(this AsyncPageable<T> query)
  {
    ArgumentNullException.ThrowIfNull(query);
    var list = new List<T>();
    await foreach (var item in query)
    {
      list.Add(item);
    }
    return list;
  }

  public static async Task<T> SingleOrDefaultAsync<T>(this AsyncPageable<T> query)
  {
    ArgumentNullException.ThrowIfNull(query);
    await using var enumerator = query.GetAsyncEnumerator();
    if (!await enumerator.MoveNextAsync()) return default;
    var item = enumerator.Current;
    return await enumerator.MoveNextAsync() ? default : item;
  }
}