Audit logging

public class UserActivity
{
    [Key]
    public int Id { get; set; }
    
    public int? UserId { get; set; }
    
    [Required]
    [MaxLength(100)]
    public string UserName { get; set; } = string.Empty;
    
    [Required]
    [MaxLength(200)]
    public string Action { get; set; } = string.Empty;
    
    public string? Details { get; set; }
    
    [MaxLength(45)]
    public string? IPAddress { get; set; }
    
    [Required]
    public DateTime Timestamp { get; set; }
    
    [MaxLength(50)]
    public string? EntityType { get; set; }
    
    public int? EntityId { get; set; }
    
    [MaxLength(20)]
    public string? ActionType { get; set; } // CREATE, UPDATE, DELETE, VIEW, LOGIN, etc.
    
    // Navigation properties
    [ForeignKey("UserId")]
    public virtual Employee? User { get; set; }
}

public async Task LogActivityAsync(int? userId, string userName, string action, string? details = null, 
    string? entityType = null, int? entityId = null, string? actionType = null, string? ipAddress = null)
{
    try
    {
        // Create a separate scope for activity logging to avoid threading conflicts
        using var scope = _serviceProvider.CreateScope();
        var context = scope.ServiceProvider.GetRequiredService<BmsPosDbContext>();
        
        var activity = new UserActivity
        {
            UserId = userId,
            UserName = userName,
            Action = action,
            Details = details,
            EntityType = entityType,
            EntityId = entityId,
            ActionType = actionType,
            IPAddress = ipAddress,
            Timestamp = DateTime.UtcNow
        };

        context.UserActivities.Add(activity);
        await context.SaveChangesAsync();
    }
    catch (Exception ex)
    {
        // Log the error but don't throw - we don't want activity logging to break business operations
        Console.WriteLine($"Failed to log user activity: {ex.Message}");
    }
}

public async Task<List<UserActivity>> GetActivitiesAsync(DateTime? startDate = null, DateTime? endDate = null, 
    int? userId = null, string? actionType = null, int limit = 1000)
{
    // Create a separate scope for read operations
    using var scope = _serviceProvider.CreateScope();
    var context = scope.ServiceProvider.GetRequiredService<BmsPosDbContext>();
    
    var query = context.UserActivities.Include(a => a.User).AsQueryable();

    if (startDate.HasValue)
    {
        query = query.Where(a => a.Timestamp >= startDate.Value);
    }

    if (endDate.HasValue)
    {
    }

    if (userId.HasValue)
    {
        query = query.Where(a => a.UserId == userId.Value);
    }

    if (!string.IsNullOrEmpty(actionType))
    {
        query = query.Where(a => a.ActionType == actionType);
    }

    return await query
        .OrderByDescending(a => a.Timestamp)
        .Take(limit)
        .ToListAsync();
}

// Log successful login
await _userActivityService.LogActivityAsync(
    employee.Id,
    employee.Name ?? employee.EmployeeId,
    $"User logged in successfully",
    $"Role: {employee.Role}, Manager: {employee.IsManager}",
    "Employee",
    employee.Id,
    "LOGIN",
    HttpContext.Connection?.RemoteIpAddress?.ToString()
);

private async Task LogFailedLoginAttempt(string employeeId, string reason, int? employeeDbId)
{
    try
    {
        await _userActivityService.LogActivityAsync(
            null, // No valid user ID for failed attempts
            employeeId,
            $"Failed login attempt for employee ID: {employeeId}",
            reason,
            "Employee",
            employeeDbId,
            "LOGIN_FAILED",
            HttpContext.Connection?.RemoteIpAddress?.ToString()
        );
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error logging failed login: {ex.Message}");
        // Don't throw - logging failure shouldn't break authentication
    }
}

[HttpGet]
public async Task<ActionResult<UserActivityResponse>> GetUserActivities(
    [FromQuery] DateTime? startDate = null,
    [FromQuery] DateTime? endDate = null,
    [FromQuery] int? userId = null,
    [FromQuery] string? actionType = null,
    [FromQuery] int limit = 1000)
{
    try
    {
        var activities = await _userActivityService.GetActivitiesAsync(
            startDate, endDate, userId, actionType, limit);

        var response = new UserActivityResponse
        {
            Activities = activities.Select(a => new UserActivityDto
            {
                Id = a.Id,
                UserId = a.UserId,
                UserName = a.UserName,
                Action = a.Action,
                Details = a.Details,
                EntityType = a.EntityType,
                EntityId = a.EntityId,
                ActionType = a.ActionType,
                IPAddress = a.IPAddress,
                Timestamp = DateTime.SpecifyKind(a.Timestamp, DateTimeKind.Utc)
            }).ToList(),
            TotalCount = activities.Count
        };

        return Ok(response);
    }
    catch (Exception ex)
    {
        return BadRequest($"Failed to retrieve user activities: {ex.Message}");
    }
}

[HttpGet("summary")]
public async Task<ActionResult<UserActivitySummaryResponse>> GetActivitySummary(
    [FromQuery] DateTime? startDate = null,
    [FromQuery] DateTime? endDate = null)
{
    try
    {
        var activities = await _userActivityService.GetActivitiesAsync(startDate, endDate);

        var summary = new UserActivitySummaryResponse
        {
            TotalActivities = activities.Count,
            UniqueUsers = activities.Where(a => a.UserId.HasValue)
                .Select(a => a.UserId).Distinct().Count(),
            ActivityTypes = activities
                .GroupBy(a => a.ActionType ?? "Unknown")
                .Select(g => new ActivityTypeSummary
                {
                    ActionType = g.Key,
                    Count = g.Count()
                })
                .OrderByDescending(a => a.Count)
                .ToList(),
            TopUsers = activities
                .Where(a => a.UserId.HasValue)
                .GroupBy(a => new { a.UserId, a.UserName })
                .Select(g => new UserActivityCount
                {
                    UserId = g.Key.UserId,
                    UserName = g.Key.UserName,
                    ActivityCount = g.Count()
                })
                .OrderByDescending(u => u.ActivityCount)
                .Take(10)
                .ToList()
        };

        return Ok(summary);
    }
    catch (Exception ex)
    {
        return BadRequest($"Failed to retrieve activity summary: {ex.Message}");
    }
}