Add support for existing room assignments in calculations

Enhanced room assignment logic to consider existing assignments
and prevent double-booking. Introduced an overloaded
`CalculateAsync` method in `CalculateProposal.cs` to handle
existing assignments. Updated `Calculations.cs` to separate
rows needing assignments from those with existing assignments
and pass them to the new method.

Improved logging throughout the codebase to track the handling
of existing assignments, calculation results, and potential
errors. Added logic to return room options even when no
calculations are needed, with error handling for loading
capacity data.

Refactored and cleaned up code for better readability and
maintainability, including adding comments and reorganizing
logic for handling requests and assignments.

Author: ADefWebserver

RFPResponsePOC/RFPResponsePOC.Client/Services/CalculateProposal.cs

@@ -64,13 +64,27 @@ public CalculateProposal(string basePath = "/RFPResponseAPP", LogService logServ
         /// <param name="rfpText">JSON string containing an array of room requests</param>
         /// <returns>List of room assignments with original requests and assigned room names</returns>
         public async Task<List<RoomAssignment>> CalculateAsync(string rfpText)
+        {
+            return await CalculateAsync(rfpText, null);
+        }
+
+        /// <summary>
+        /// Main calculation method that processes RFP text and assigns rooms to requests.
+        /// This overload considers existing room assignments to prevent double-booking during recalculation.
+        /// Implements a first-fit algorithm where rooms are assigned to requests in order.
+        /// Rooms are sorted by capacity (lowest to highest) to optimize space usage.
+        /// </summary>
+        /// <param name="rfpText">JSON string containing an array of room requests</param>
+        /// <param name="existingAssignments">Optional list of existing room assignments to consider during scheduling</param>
+        /// <returns>List of room assignments with original requests and assigned room names</returns>
+        public async Task<List<RoomAssignment>> CalculateAsync(string rfpText, List<RoomAssignment> existingAssignments)
         {
             // Initialize the result list to ensure we always return a valid collection
             var assignments = new List<RoomAssignment>();
 
             try
             {
-                await _logService.WriteToLogAsync($"[{DateTime.Now}] CalculateProposale.CalculateAsync started");
+                await _logService.WriteToLogAsync($"[{DateTime.Now}] CalculateProposale.CalculateAsync started with {existingAssignments?.Count ?? 0} existing assignments");
 
                 // Validate input - early return if RFP text is empty or null
                 if (string.IsNullOrWhiteSpace(rfpText))
@@ -184,6 +198,42 @@ public async Task<List<RoomAssignment>> CalculateAsync(string rfpText)
                 // Value: List of time intervals when the room is booked
                 var schedule = new Dictionary<string, List<(DateTime start, DateTime end)>>();
 
+                // Pre-populate schedule with existing assignments if provided
+                if (existingAssignments?.Any() == true)
+                {
+                    await _logService.WriteToLogAsync($"[{DateTime.Now}] Pre-populating schedule with {existingAssignments.Count} existing assignments");
+                    
+                    foreach (var existingAssignment in existingAssignments)
+                    {
+                        if (existingAssignment?.Request != null && !string.IsNullOrWhiteSpace(existingAssignment.AssignedRoom))
+                        {
+                            try
+                            {
+                                // Calculate actual start and end times for existing assignment
+                                var existingStart = existingAssignment.Request.StartDate.Date.Add(existingAssignment.Request.StartTime);
+                                var existingEnd = existingAssignment.Request.EndDate.Date.Add(existingAssignment.Request.EndTime);
+                                
+                                // Find the room object for this assignment
+                                var existingRoom = capacity.Rooms.FirstOrDefault(r => r.Name == existingAssignment.AssignedRoom);
+                                if (existingRoom != null)
+                                {
+                                    // Block the room in the schedule
+                                    BlockRoom(existingRoom, existingStart, existingEnd, schedule, capacity.Rooms);
+                                    await _logService.WriteToLogAsync($"[{DateTime.Now}] Pre-blocked room '{existingAssignment.AssignedRoom}' for existing assignment '{existingAssignment.Request.Name}' from {existingStart} to {existingEnd}");
+                                }
+                                else
+                                {
+                                    await _logService.WriteToLogAsync($"[{DateTime.Now}] WARNING: Could not find room '{existingAssignment.AssignedRoom}' in capacity data for existing assignment '{existingAssignment.Request.Name}'");
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                await _logService.WriteToLogAsync($"[{DateTime.Now}] ERROR: Failed to pre-block existing assignment for room '{existingAssignment.AssignedRoom}' - {ex.Message}");
+                            }
+                        }
+                    }
+                }
+
                 // Put requests in order based on start date and time
                 requests = requests.OrderBy(req => req.StartDate.Date.Add(req.StartTime)).ToList();
 

RFPResponsePOC/RFPResponsePOC.Client/Services/Calculations.cs

@@ -272,9 +272,13 @@ public static async Task<List<string>> CalculateRoomsForExistingRows(List<Propos
                     return new List<string>();
                 }
 
+                // Find rows that need room assignments (no manual room and no selected room)
                 var rowsNeedingRooms = proposalRows.Where(row => string.IsNullOrWhiteSpace(row.ManualRoom) && string.IsNullOrWhiteSpace(row.SelectedRoom)).ToList();
 
-                await logService.WriteToLogAsync($"[{DateTime.Now}] Found {rowsNeedingRooms.Count} rows needing room assignments");
+                // Find rows that already have room assignments (either manual or selected)
+                var rowsWithAssignments = proposalRows.Where(row => !string.IsNullOrWhiteSpace(row.ManualRoom) || !string.IsNullOrWhiteSpace(row.SelectedRoom)).ToList();
+
+                await logService.WriteToLogAsync($"[{DateTime.Now}] Found {rowsNeedingRooms.Count} rows needing room assignments and {rowsWithAssignments.Count} rows with existing assignments");
 
                 if (!rowsNeedingRooms.Any())
                 {
@@ -286,9 +290,22 @@ public static async Task<List<string>> CalculateRoomsForExistingRows(List<Propos
                         Detail = "All rows already have room assignments or manual room overrides.",
                         Duration = 4000
                     });
-                    return new List<string>();
+                    
+                    // Still return room options even if no calculations are needed
+                    try
+                    {
+                        var capacityJson = await File.ReadAllTextAsync("/RFPResponseAPP/Capacity.json");
+                        var capacity = JsonConvert.DeserializeObject<CapacityRoot>(capacityJson);
+                        return capacity?.Rooms?.Select(r => r.Name).OrderBy(n => n).ToList() ?? new List<string>();
+                    }
+                    catch (Exception ex)
+                    {
+                        await logService.WriteToLogAsync($"[{DateTime.Now}] WARNING: Unable to load Capacity.json - {ex.Message}");
+                        return new List<string>();
+                    }
                 }
 
+                // Convert rows needing rooms to RoomRequest objects
                 var requests = rowsNeedingRooms.Select(row => new RoomsRequest
                 {
                     Name = row.Name ?? "Unknown",
@@ -301,11 +318,31 @@ public static async Task<List<string>> CalculateRoomsForExistingRows(List<Propos
                     Notes = row.Notes ?? ""
                 }).ToList();
 
+                // Convert rows with existing assignments to RoomAssignment objects
+                var existingAssignments = rowsWithAssignments.Select(row => new RoomAssignment
+                {
+                    Request = new RoomsRequest
+                    {
+                        Name = row.Name ?? "Unknown",
+                        StartDate = row.StartDate,
+                        StartTime = row.StartTime,
+                        EndDate = row.EndDate,
+                        EndTime = row.EndTime,
+                        RoomType = row.RoomType ?? "",
+                        Attendance = row.Attendance,
+                        Notes = row.Notes ?? ""
+                    },
+                    AssignedRoom = !string.IsNullOrWhiteSpace(row.ManualRoom) ? row.ManualRoom : row.SelectedRoom
+                }).ToList();
+
                 var requestsJson = JsonConvert.SerializeObject(requests);
                 await logService.WriteToLogAsync($"[{DateTime.Now}] Created requests JSON for calculation: {requestsJson.Substring(0, Math.Min(500, requestsJson.Length))}");
+                await logService.WriteToLogAsync($"[{DateTime.Now}] Existing assignments to consider: {string.Join(", ", existingAssignments.Select(ea => $"{ea.Request?.Name}:{ea.AssignedRoom}"))}");
 
                 var calculator = new CalculateProposal("/RFPResponseAPP", logService);
-                var assignments = await calculator.CalculateAsync(requestsJson);
+                
+                // Use the new overloaded method that considers existing assignments
+                var assignments = await calculator.CalculateAsync(requestsJson, existingAssignments);
                 await logService.WriteToLogAsync($"[{DateTime.Now}] Calculator returned {assignments?.Count ?? 0} assignments");
 
                 var assignmentDict = assignments.ToDictionary(a => a.Request?.Name ?? "", a => a.AssignedRoom);