Refactor event occurrence parsing by introducing modular components for improved maintainability

This commit restructures the EventOccurrenceParser by breaking down its functionality into modular components, including EventDefinitionResolver, LineClassifier, LocationPatternMatcher, SectionHeaderMatcher, TimeLocationParser, and TimeParser. This refactoring enhances code readability and maintainability, allowing for easier updates and testing. Additionally, the TextUtil class has been updated to include input sanitization methods. Comprehensive unit tests have been added to ensure the correctness of the new parsing logic and to validate the handling of various event occurrence scenarios.

Core/Parsers/EventOccurrence/EventDefinitionResolver.cs

@@ -0,0 +1,45 @@
+using Core.Entities;
+
+namespace Core.Parsers.EventOccurrence;
+
+/// <summary>
+/// Resolves event definitions from occurrence name patterns or section context.
+/// </summary>
+public static class EventDefinitionResolver
+{
+    /// <summary>
+    /// Maps special event name patterns to their EventDefinition instances.
+    /// Patterns are checked in order, and the first match wins.
+    /// </summary>
+    private static readonly Dictionary<string, EventDefinition> SpecialEventPatterns = 
+        new(StringComparer.OrdinalIgnoreCase)
+    {
+        ["Meet the Candidates"] = EventDefinition.MeetTheCandidates,
+        ["Chapter Officer Meeting"] = EventDefinition.ChapterOfficerMeeting,
+        ["Voting Delegate Meeting"] = EventDefinition.VotingDelegateMeeting,
+    };
+
+    /// <summary>
+    /// Determines the EventDefinition for an occurrence based on its name pattern or current section context.
+    /// </summary>
+    /// <param name="occurrenceName">The name of the occurrence.</param>
+    /// <param name="currentEventDefinition">The current event definition from section header, if any.</param>
+    /// <returns>The resolved EventDefinition, or null if it cannot be determined.</returns>
+    public static EventDefinition? Resolve(string occurrenceName, EventDefinition? currentEventDefinition)
+    {
+        // Check for special event name patterns first (regardless of current section)
+        foreach (var (pattern, eventDef) in SpecialEventPatterns)
+        {
+            if (occurrenceName.Contains(pattern, StringComparison.OrdinalIgnoreCase))
+                return eventDef;
+        }
+
+        // If we're in a General Schedule/Session section and no pattern matched, use GeneralSchedule
+        if (currentEventDefinition == EventDefinition.GeneralSchedule)
+            return EventDefinition.GeneralSchedule;
+
+        // If we have a current event definition from section header (e.g., regular events), use it
+        return currentEventDefinition;
+    }
+}
+

Core/Parsers/EventOccurrence/LineClassifier.cs

@@ -0,0 +1,59 @@
+namespace Core.Parsers.EventOccurrence;
+
+/// <summary>
+/// Classifies lines to determine if they should be skipped during parsing.
+/// </summary>
+public static class LineClassifier
+{
+    /// <summary>
+    /// Checks if a line is empty or contains only whitespace.
+    /// </summary>
+    public static bool IsEmptyLine(string line)
+    {
+        return string.IsNullOrWhiteSpace(line);
+    }
+
+    /// <summary>
+    /// Checks if a line is a comment (starts with "#").
+    /// </summary>
+    public static bool IsCommentLine(string line)
+    {
+        return EventOccurrenceGrammar.IsCommentLine(line);
+    }
+
+    /// <summary>
+    /// Determines if a line is a continuation/wrapped line that should be skipped.
+    /// These are typically lines that:
+    /// - Start with lowercase or special characters (not event names)
+    /// - Are parenthetical notes like "(Semifinalists only)"
+    /// - Are informational text like "Schedule Posted on..."
+    /// </summary>
+    public static bool IsContinuationLine(string line)
+    {
+        var trimmed = line.Trim();
+        
+        // Skip parenthetical notes
+        if (trimmed.StartsWith("(", StringComparison.Ordinal) && trimmed.EndsWith(")", StringComparison.Ordinal))
+            return true;
+        
+        // Skip lines that are clearly continuation text (start with lowercase, common continuation words)
+        if (trimmed.Length > 0 && char.IsLower(trimmed[0]))
+        {
+            // Check if it starts with common continuation words
+            var continuationPrefixes = new[] { "be ", "the ", "and ", "or ", "to ", "a ", "an ", "will ", "may ", "can " };
+            foreach (var prefix in continuationPrefixes)
+            {
+                if (trimmed.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+                    return true;
+            }
+        }
+        
+        // Skip informational lines that don't contain dates/times
+        if (trimmed.Contains("Schedule Posted", StringComparison.OrdinalIgnoreCase) ||
+            trimmed.Contains("Note:", StringComparison.OrdinalIgnoreCase))
+            return true;
+        
+        return false;
+    }
+}
+

Core/Parsers/EventOccurrence/LocationPatternMatcher.cs

@@ -0,0 +1,62 @@
+using System.Text.RegularExpressions;
+
+namespace Core.Parsers.EventOccurrence;
+
+/// <summary>
+/// Matches location strings against configurable patterns.
+/// Supports exact matches and wildcard patterns (e.g., "Room *", "Exhibit Hall *").
+/// </summary>
+public static class LocationPatternMatcher
+{
+    /// <summary>
+    /// Matches location text against configured patterns and returns the matched location.
+    /// </summary>
+    /// <param name="locationText">The location text to match.</param>
+    /// <param name="patterns">The list of patterns to match against.</param>
+    /// <returns>The matched location if a pattern matches, or empty string if no match is found.</returns>
+    public static string Match(string locationText, IReadOnlyList<string> patterns)
+    {
+        // Normalize location text for matching (trim and handle variations)
+        var normalizedLocation = locationText.Trim();
+        
+        // If location is empty after normalization, return empty
+        if (string.IsNullOrWhiteSpace(normalizedLocation))
+            return string.Empty;
+        
+        foreach (var pattern in patterns)
+        {
+            var normalizedPattern = pattern.Trim();
+            
+            // Skip empty patterns
+            if (string.IsNullOrWhiteSpace(normalizedPattern))
+                continue;
+            
+            // Handle exact matches (patterns without wildcards like "Online", "Virtual", "TBD")
+            if (!normalizedPattern.Contains('*'))
+            {
+                if (string.Equals(normalizedPattern, normalizedLocation, StringComparison.OrdinalIgnoreCase))
+                {
+                    return normalizedLocation;
+                }
+                continue;
+            }
+
+            // Convert pattern to regex: escape special chars, replace * with .*
+            // This handles patterns like "Exhibit Hall *", "Room *", "Mtg. Room *", etc.
+            var escapedPattern = Regex.Escape(normalizedPattern);
+            escapedPattern = escapedPattern.Replace(@"\*", ".*?");
+            
+            // Use case-insensitive matching
+            // Note: For dynamic patterns, we compile on demand. This is acceptable since patterns
+            // are configured and reused across parsing sessions.
+            var regex = new Regex($"^{escapedPattern}$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
+            if (regex.IsMatch(normalizedLocation))
+            {
+                return normalizedLocation; // Return the full matched location
+            }
+        }
+
+        return string.Empty;
+    }
+}
+

Core/Parsers/EventOccurrence/SectionHeaderMatcher.cs

@@ -0,0 +1,62 @@
+using Core.Entities;
+using FuzzySharp;
+
+namespace Core.Parsers.EventOccurrence;
+
+/// <summary>
+/// Matches section headers to event definitions using fuzzy matching.
+/// </summary>
+public static class SectionHeaderMatcher
+{
+    /// <summary>
+    /// Checks if a line is a general schedule header.
+    /// </summary>
+    public static bool IsGeneralSchedule(string line)
+    {
+        return EventOccurrenceGrammar.IsGeneralSchedule(line);
+    }
+
+    /// <summary>
+    /// Checks if a line contains school level markers (MS or HS).
+    /// </summary>
+    public static bool HasSchoolLevel(string line)
+    {
+        return line.Contains("MS", StringComparison.Ordinal) || 
+               line.Contains("HS", StringComparison.Ordinal);
+    }
+
+    /// <summary>
+    /// Matches a section header to the best matching event definition using fuzzy matching.
+    /// </summary>
+    /// <param name="sectionHeader">The section header text to match.</param>
+    /// <param name="events">The collection of available event definitions.</param>
+    /// <returns>The best matching EventDefinition, or null if no match is found (ratio > 50).</returns>
+    public static EventDefinition? MatchEventDefinition(string sectionHeader, ICollection<EventDefinition> events)
+    {
+        var evt =
+            (from e in events
+                let rat = Fuzz.Ratio(e.Name, sectionHeader)
+                where rat > 50
+                orderby rat descending
+                select e).FirstOrDefault();
+        
+        return evt;
+    }
+
+    /// <summary>
+    /// Gets the best match ratio for a section header against events.
+    /// Useful for error messages when no match is found.
+    /// </summary>
+    /// <param name="sectionHeader">The section header text.</param>
+    /// <param name="events">The collection of available event definitions.</param>
+    /// <returns>The best match ratio, or 0 if no events are available.</returns>
+    public static int GetBestMatchRatio(string sectionHeader, ICollection<EventDefinition> events)
+    {
+        if (events.Count == 0)
+            return 0;
+
+        var bestEvent = events.FirstOrDefault();
+        return bestEvent != null ? Fuzz.Ratio(sectionHeader, bestEvent.Name) : 0;
+    }
+}
+

Core/Parsers/EventOccurrence/TimeLocationParser.cs

@@ -0,0 +1,145 @@
+using System.Text.RegularExpressions;
+using Core.Models;
+
+namespace Core.Parsers.EventOccurrence;
+
+/// <summary>
+/// Parses time and location from combined strings.
+/// Handles time ranges, location extraction, and pattern matching.
+/// </summary>
+public static class TimeLocationParser
+{
+    // Shared time value pattern: matches either NOON or a time with AM/PM (e.g., "10:30 a.m.", "3 p.m.")
+    private static string TimeValuePattern => TimePatterns.TimeValue;
+
+    // Regex to match time ranges like "10:30 a.m. - 12:00 p.m." or "10:30 a.m. - NOON"
+    // Matches: time1 (optional dash time2/NOON), then location
+    // The time group captures the full time range (including " - NOON" if present)
+    // Note: Input is normalized via SanitizeInput, so only regular hyphens need to be handled
+    private static readonly Regex TimeLocationRegex = new(
+        $@"(?<Time>{TimeValuePattern}(?:\s*-\s*{TimeValuePattern})?)(?:\s+(?<Location>.+))?",
+        RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+    // Pattern for cleaning time components from location text
+    // Matches optional dash, whitespace, time pattern, optional whitespace at start
+    // Handles: "- 12:15 p.m. ", "12:15 p.m. ", "- NOON ", "NOON ", etc.
+    private static readonly Regex TimeInLocationPattern = new(
+        $@"^(?:-\s*)?{TimeValuePattern}(?:\s+|$)",
+        RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+    /// <summary>
+    /// Parses time and location from the timeAndLocation string using configurable location patterns.
+    /// </summary>
+    /// <param name="timeAndLocation">The combined time and location string.</param>
+    /// <param name="locationConfig">The location parsing configuration with patterns.</param>
+    /// <param name="time">Output parameter: the parsed time string.</param>
+    /// <param name="location">Output parameter: the parsed location string.</param>
+    /// <param name="locationParseSuccess">Output parameter: whether location parsing was successful.</param>
+    public static void Parse(
+        string timeAndLocation,
+        LocationParsingConfiguration? locationConfig,
+        out string time,
+        out string location,
+        out bool locationParseSuccess)
+    {
+        // Try to separate time from location using the time regex
+        var timeLocationMatch = TimeLocationRegex.Match(timeAndLocation);
+        
+        if (!timeLocationMatch.Success)
+        {
+            // If time regex doesn't match, use the whole string as time
+            time = timeAndLocation.Trim();
+            location = string.Empty;
+            locationParseSuccess = false;
+            return;
+        }
+
+        time = timeLocationMatch.Groups["Time"].Captures[0].Value.Trim();
+        var locationPart = timeLocationMatch.Groups["Location"].Success 
+            ? timeLocationMatch.Groups["Location"].Captures[0].Value.Trim() 
+            : string.Empty;
+
+        // No location part found, which is valid (some events might not have locations)
+        if (string.IsNullOrWhiteSpace(locationPart))
+        {
+            location = string.Empty;
+            locationParseSuccess = true; // Consider it a success since no location is needed
+            return;
+        }
+
+        // Clean up location part - remove any remaining time components
+        // (e.g., "– 12:15 p.m. Exhibit Hall C" -> "Exhibit Hall C")
+        locationPart = CleanLocationText(locationPart);
+
+        if (string.IsNullOrWhiteSpace(locationPart))
+        {
+            location = string.Empty;
+            locationParseSuccess = true; // No location after cleaning is also valid
+            return;
+        }
+
+        // Try to match location using configurable patterns
+        (location, locationParseSuccess) = TryMatchLocation(locationPart, locationConfig);
+        
+        // If no pattern matched but we have a location, use it anyway
+        // This allows parsing to continue while still tracking that the location didn't match a pattern
+        if (!locationParseSuccess)
+        {
+            location = locationPart;
+        }
+    }
+
+    /// <summary>
+    /// Attempts to match a location string against configured patterns.
+    /// </summary>
+    private static (string location, bool success) TryMatchLocation(
+        string locationPart,
+        LocationParsingConfiguration? locationConfig)
+    {
+        // No patterns configured - can't match
+        if (locationConfig == null || !locationConfig.LocationPatterns.Any())
+        {
+            return (string.Empty, false);
+        }
+
+        // Try initial match
+        var location = LocationPatternMatcher.Match(locationPart, locationConfig.LocationPatterns);
+        if (!string.IsNullOrEmpty(location))
+        {
+            return (location, true);
+        }
+
+        // Try matching against trimmed version (handles extra whitespace)
+        var cleanedForMatching = locationPart.Trim();
+        location = LocationPatternMatcher.Match(cleanedForMatching, locationConfig.LocationPatterns);
+        if (!string.IsNullOrEmpty(location))
+        {
+            return (cleanedForMatching, true);
+        }
+
+        return (string.Empty, false);
+    }
+
+    /// <summary>
+    /// Cleans location text by removing any remaining time components from the start.
+    /// Handles cases like "- 12:15 p.m. Exhibit Hall C" -> "Exhibit Hall C"
+    /// Note: Input is normalized, so only regular hyphens need to be handled.
+    /// </summary>
+    public static string CleanLocationText(string locationText)
+    {
+        if (string.IsNullOrWhiteSpace(locationText))
+            return string.Empty;
+        
+        // Remove time pattern from start, repeat until no more matches
+        string previous;
+        do
+        {
+            previous = locationText;
+            locationText = TimeInLocationPattern.Replace(locationText, "").Trim();
+        } while (locationText != previous && !string.IsNullOrWhiteSpace(locationText));
+        
+        // If result is empty or only whitespace, return empty
+        return string.IsNullOrWhiteSpace(locationText) ? string.Empty : locationText;
+    }
+}
+

Core/Parsers/EventOccurrence/TimeParser.cs

@@ -0,0 +1,96 @@
+using System.Text.RegularExpressions;
+
+namespace Core.Parsers.EventOccurrence;
+
+/// <summary>
+/// Parses time strings into TimeOnly objects.
+/// Handles various time formats including NOON, TBD, time ranges, and AM/PM formats.
+/// </summary>
+public static class TimeParser
+{
+    private static readonly Regex TimeRegex = new(
+        TimePatterns.TimeWithGroups,
+        RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+    /// <summary>
+    /// Extracts the start time from a time range string.
+    /// Example: "10:00 a.m. - 12:00 p.m." -> "10:00 a.m."
+    /// </summary>
+    public static string ExtractStartTime(string timeRange)
+    {
+        if (timeRange.Contains(" - ", StringComparison.Ordinal))
+        {
+            return timeRange[..timeRange.IndexOf(" - ", StringComparison.Ordinal)];
+        }
+        return timeRange;
+    }
+
+    /// <summary>
+    /// Parses a time string into a TimeOnly object.
+    /// Handles:
+    /// - NOON -> 12:00 PM
+    /// - TBD -> 00:00:00 (midnight as placeholder)
+    /// - Time ranges -> extracts start time (e.g., "10:00 a.m. - 12:00 p.m." -> parses "10:00 a.m.")
+    /// - Standard AM/PM formats (e.g., "3:00 p.m.", "10:30 am")
+    /// </summary>
+    /// <param name="time">The time string to parse.</param>
+    /// <returns>A TimeOnly object representing the parsed time.</returns>
+    /// <exception cref="FormatException">Thrown when the time format is not recognized.</exception>
+    public static TimeOnly Parse(string time)
+    {
+        int hour = 0;
+        int minute = 0;
+
+        // Handle TBD (To Be Determined) times gracefully
+        if (string.Equals(time.Trim(), "TBD", StringComparison.OrdinalIgnoreCase))
+        {
+            // Use a placeholder time (midnight) for TBD - the occurrence will still be created
+            // but with a time that indicates it's TBD
+            return new TimeOnly(0, 0, 0);
+        }
+
+        // Extract start time from range if present
+        var timeToParse = ExtractStartTime(time);
+
+        // Handle NOON
+        if (timeToParse == "NOON")
+        {
+            hour = 12;
+        }
+        else
+        {
+            // Parse time with regex
+            var timeMatch = TimeRegex.Match(timeToParse);
+            if (timeMatch.Success)
+            {
+                hour = int.Parse(timeMatch.Groups["Hour"].Captures[0].Value);
+                if (timeMatch.Groups["Minute"].Success)
+                {
+                    minute = int.Parse(timeMatch.Groups["Minute"].Captures[0].Value);
+                }
+
+                // Convert AM/PM times to 24-hour format
+                var apmValue = timeMatch.Groups["APM"].Captures[0].Value.ToLower();
+                if (apmValue is "p.m." or "pm")
+                {
+                    // PM: add 12 unless it's 12 PM (which stays 12)
+                    if (hour < 12)
+                        hour += 12;
+                }
+                else if (apmValue is "a.m." or "am")
+                {
+                    // AM: if it's 12 AM, convert to midnight (0)
+                    if (hour == 12)
+                        hour = 0;
+                }
+            }
+            else
+            {
+                throw new FormatException($"Time format not recognized: {time}");
+            }
+        }
+
+        return new TimeOnly(hour, minute, 0);
+    }
+}
+

Core/Parsers/EventOccurrence/TimePatterns.cs

@@ -0,0 +1,43 @@
+namespace Core.Parsers.EventOccurrence;
+
+/// <summary>
+/// Shared regex patterns for time parsing.
+/// </summary>
+internal static class TimePatterns
+{
+    /// <summary>
+    /// AM/PM pattern (case-insensitive via IgnoreCase flag).
+    /// Matches: "a.m.", "am", "A.M.", "AM", "p.m.", "pm", "P.M.", "PM"
+    /// </summary>
+    public const string AmPm = @"(?:a|p)\.?m\.?";
+
+    /// <summary>
+    /// Hour pattern: matches 1-2 digits (1-12 or 1-23).
+    /// </summary>
+    public const string Hour = @"\d{1,2}";
+
+    /// <summary>
+    /// Minute pattern with named group for parsing: matches exactly 2 digits if present.
+    /// Used when parsing to TimeOnly objects where minutes must be valid.
+    /// </summary>
+    public const string MinuteWithGroup = @"(?<Minute>\d{2})?";
+
+    /// <summary>
+    /// Minute pattern for matching: matches 0-2 digits.
+    /// Used when extracting time strings (more lenient for location parsing).
+    /// </summary>
+    public const string MinuteFlexible = @"\d{0,2}";
+
+    /// <summary>
+    /// Time value pattern: matches either NOON or a time with AM/PM.
+    /// Used for matching time strings in location parsing (more lenient minute format).
+    /// </summary>
+    public static string TimeValue => $@"(?:NOON|{Hour}:?{MinuteFlexible}\s*{AmPm})";
+
+    /// <summary>
+    /// Time pattern with named groups for parsing hour, minute, and AM/PM.
+    /// Used when parsing to TimeOnly objects (requires 2-digit minutes if present).
+    /// </summary>
+    public static string TimeWithGroups => $@"(?<Hour>{Hour}):?{MinuteWithGroup}\s?(?<APM>{AmPm})";
+}
+

Core/Parsers/EventOccurrenceParser.cs

@@ -1,7 +1,8 @@
 using System.Text.RegularExpressions;
 using Core.Entities;
 using Core.Models;
-using FuzzySharp;
+using EventOccurrenceParsers = Core.Parsers.EventOccurrence;
+using Core.Utility;
 
 namespace Core.Parsers;
 
@@ -10,7 +11,7 @@ namespace Core.Parsers;
 /// </summary>
 public class EventOccurrenceParserResult
 {
-    public IDictionary<EventDefinition, List<EventOccurrence>> Occurrences { get; set; } = new Dictionary<EventDefinition, List<EventOccurrence>>();
+    public IDictionary<EventDefinition, List<Entities.EventOccurrence>> Occurrences { get; set; } = new Dictionary<EventDefinition, List<Entities.EventOccurrence>>();
     public List<ParsingIssue> Issues { get; set; } = new();
 }
 
@@ -27,18 +28,6 @@ public class EventOccurrenceParser
 		_locationConfig = locationConfig;
 	}
 
-	private readonly Regex _timeRe = new(@"(?<Hour>\d{1,2}):?(?<Minute>\d{2})?\s?(?<APM>(?:a|p)\.?m\.?)");
-
-	// Regex to match time ranges like "10:30 a.m. - 12:00 p.m." or "10:30 a.m. - NOON"
-	// Matches: time1 (optional dash time2/NOON), then location
-	// The time group captures the full time range (including " - NOON" if present)
-	// Note: Input is normalized via SanitizeInput, so only regular hyphens need to be handled
-	// Pattern breakdown:
-	//   - First time: (?:NOON|\d{1,2}:?\d{0,2}\s*(?:[AaPp]\.?[Mm]\.?)) - matches NOON or time with AM/PM (more flexible whitespace)
-	//   - Optional range: (?:\s*-\s*(?:NOON|\d{1,2}:?\d{0,2}\s*(?:[AaPp]\.?[Mm]\.?))) - matches dash followed by NOON or time
-	//   - Location: (?:\s+(?<Location>.+))? - optional whitespace followed by location (capture group with explicit name)
-	private readonly Regex _timeLocationRegex = new(@"(?<Time>(?:NOON|\d{1,2}:?\d{0,2}\s*(?:[AaPp]\.?[Mm]\.?))(?:\s*-\s*(?:NOON|\d{1,2}:?\d{0,2}\s*(?:[AaPp]\.?[Mm]\.?)))?)(?:\s+(?<Location>.+))?");
-
 	public EventOccurrenceParserResult Parse()
     {
         var result = new EventOccurrenceParserResult();
@@ -51,14 +40,14 @@ public class EventOccurrenceParser
         {
             // Normalize input: trim and normalize hyphens (en-dash, em-dash -> regular hyphen)
             // This allows the grammar parser to assume normalized input
-            var normalizedLine = SanitizeInput(line.Trim());
+            var normalizedLine = TextUtil.SanitizeInput(line.Trim());
             
             // Skip empty lines
-            if (string.IsNullOrWhiteSpace(normalizedLine))
+            if (EventOccurrenceParsers.LineClassifier.IsEmptyLine(normalizedLine))
                 continue;
 
             // Skip comment lines (starting with "#") - use grammar parser
-            if (EventOccurrenceGrammar.IsCommentLine(normalizedLine))
+            if (EventOccurrenceParsers.LineClassifier.IsCommentLine(normalizedLine))
                 continue;
 
 			// Try to parse occurrence line using grammar parser
@@ -73,20 +62,16 @@ public class EventOccurrenceParser
 					var (eventNamePart, schoolLevel) = sectionHeader.Value;
 					
 					// Use fuzzy matching to find the best matching event definition
-					var evt =
-						(from e in _events
-							let rat = Fuzz.Ratio(e.Name, eventNamePart)
-							where rat > 50
-							orderby rat descending
-							select e).FirstOrDefault();
+					var evt = EventOccurrenceParsers.SectionHeaderMatcher.MatchEventDefinition(eventNamePart, _events);
 					if (evt == null)
 					{
+						var bestRatio = EventOccurrenceParsers.SectionHeaderMatcher.GetBestMatchRatio(eventNamePart, _events);
 						issues.Add(new ParsingIssue
 						{
 							LineNumber = index,
 							LineContent = normalizedLine,
 							IssueType = ParsingIssueType.UnmatchedLine,
-							Message = $"Section header '{eventNamePart} - {schoolLevel}' found but no matching event definition (best match ratio: {Fuzz.Ratio(eventNamePart, _events.FirstOrDefault()?.Name ?? "")})"
+							Message = $"Section header '{eventNamePart} - {schoolLevel}' found but no matching event definition (best match ratio: {bestRatio})"
 						});
 						continue;
 					}
@@ -95,29 +80,25 @@ public class EventOccurrenceParser
 				}
 				
 				// Check for General Schedule/Session using grammar parser
-				if (EventOccurrenceGrammar.IsGeneralSchedule(normalizedLine))
+				if (EventOccurrenceParsers.SectionHeaderMatcher.IsGeneralSchedule(normalizedLine))
 				{
 					currentEventDefinition = EventDefinition.GeneralSchedule;
 					continue;
 				}
 				
 				// Also check for simple "MS" or "HS" in line (backward compatibility)
-				if (normalizedLine.Contains("MS") || normalizedLine.Contains("HS"))
+				if (EventOccurrenceParsers.SectionHeaderMatcher.HasSchoolLevel(normalizedLine))
 				{
-					var evt =
-						(from e in _events
-							let rat = Fuzz.Ratio(e.Name, normalizedLine)
-							where rat > 50
-							orderby rat descending
-							select e).FirstOrDefault();
+					var evt = EventOccurrenceParsers.SectionHeaderMatcher.MatchEventDefinition(normalizedLine, _events);
 					if (evt == null)
 					{
+						var bestRatio = EventOccurrenceParsers.SectionHeaderMatcher.GetBestMatchRatio(normalizedLine, _events);
 						issues.Add(new ParsingIssue
 						{
 							LineNumber = index,
 							LineContent = normalizedLine,
 							IssueType = ParsingIssueType.UnmatchedLine,
-							Message = $"Section header with 'MS' or 'HS' found but no matching event definition (best match ratio: {Fuzz.Ratio(normalizedLine, _events.FirstOrDefault()?.Name ?? "")})"
+							Message = $"Section header with 'MS' or 'HS' found but no matching event definition (best match ratio: {bestRatio})"
 						});
 						continue;
 					}
@@ -126,11 +107,7 @@ public class EventOccurrenceParser
 				}
 
 				// Skip continuation lines (lines that look like they're continuing from previous line)
-				// These are typically lines that:
-				// - Start with lowercase or special characters (not event names)
-				// - Are parenthetical notes like "(Semifinalists only)"
-				// - Are informational text like "Schedule Posted on..."
-				if (IsContinuationLine(normalizedLine))
+				if (EventOccurrenceParsers.LineClassifier.IsContinuationLine(normalizedLine))
 				{
 					continue;
 				}
@@ -157,7 +134,7 @@ public class EventOccurrenceParser
 				@"(?<Weekday>Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday),\s?$", "").Trim();
 
 			// Determine event definition based on occurrence name pattern or current section
-			EventDefinition? eventDefinition = DetermineEventDefinition(occurrenceName, currentEventDefinition);
+			EventDefinition? eventDefinition = EventOccurrenceParsers.EventDefinitionResolver.Resolve(occurrenceName, currentEventDefinition);
 
 			// Track issue if we can't determine the event definition
 			if (eventDefinition == null)
@@ -175,13 +152,28 @@ public class EventOccurrenceParser
 			// timeAndLocation is already normalized (hyphens normalized) since normalizedLine was sanitized
 			
 			// Parse time and location using configurable patterns
-			var (time, location, locationParseSuccess) = ParseTimeAndLocation(timeAndLocation, index, normalizedLine, issues);
+			EventOccurrenceParsers.TimeLocationParser.Parse(timeAndLocation, _locationConfig, out string time, out string location, out bool locationParseSuccess);
+			
+			// Track location parsing failure if patterns are configured but none matched
+			if (!locationParseSuccess && !string.IsNullOrWhiteSpace(location))
+			{
+				if (_locationConfig != null && _locationConfig.LocationPatterns.Any())
+				{
+					issues.Add(new ParsingIssue
+					{
+						LineNumber = index,
+						LineContent = normalizedLine,
+						IssueType = ParsingIssueType.LocationParseFailure,
+						Message = $"Location '{location}' does not match any configured pattern"
+					});
+				}
+			}
 
 			// Parse date
 			DateOnly? startDate = null;
 			try
 			{
-				startDate = ParseDate(month, dayOfMonthStr.ToString(), DateTime.Now.Year);
+				startDate = TextUtil.ParseDate(month, dayOfMonthStr.ToString(), DateTime.Now.Year);
 			}
 			catch (Exception ex)
 			{
@@ -199,7 +191,7 @@ public class EventOccurrenceParser
 			TimeOnly? startTime = null;
 			try
 			{
-				startTime = ParseStartTime(time);
+				startTime = EventOccurrenceParsers.TimeParser.Parse(time);
 			}
 			catch (Exception ex)
 			{
@@ -218,7 +210,7 @@ public class EventOccurrenceParser
 
 			var t = new DateTime(startDate.Value, startTime.Value);
 
-			var eventOccurrence = new EventOccurrence
+			var eventOccurrence = new Core.Entities.EventOccurrence
 			{
 				Name = occurrenceName, 
 				StartTime = t, 
@@ -234,302 +226,4 @@ public class EventOccurrenceParser
 
         return result;
     }
-
-    /// <summary>
-    /// Determines the EventDefinition for an occurrence based on its name pattern or current section context.
-    /// </summary>
-    private EventDefinition? DetermineEventDefinition(string occurrenceName, EventDefinition? currentEventDefinition)
-    {
-        // Check for special event name patterns first (regardless of current section)
-        if (occurrenceName.Contains("Meet the Candidates Session", StringComparison.OrdinalIgnoreCase))
-            return EventDefinition.MeetTheCandidates;
-        
-        if (occurrenceName.Contains("Chapter Officer Meeting", StringComparison.OrdinalIgnoreCase))
-            return EventDefinition.ChapterOfficerMeeting;
-        
-        if (occurrenceName.Contains("Voting Delegate Meeting", StringComparison.OrdinalIgnoreCase))
-            return EventDefinition.VotingDelegateMeeting;
-
-        // If we're in a General Schedule/Session section and no pattern matched, use GeneralSchedule
-        if (currentEventDefinition == EventDefinition.GeneralSchedule)
-            return EventDefinition.GeneralSchedule;
-
-        // If we have a current event definition from section header (e.g., regular events), use it
-        if (currentEventDefinition != null)
-            return currentEventDefinition;
-
-        // Cannot determine event definition
-        return null;
-    }
-
-    /// <summary>
-    /// Determines if a line is a continuation/wrapped line that should be skipped.
-    /// </summary>
-    private bool IsContinuationLine(string line)
-    {
-        var trimmed = line.Trim();
-        
-        // Skip parenthetical notes
-        if (trimmed.StartsWith("(", StringComparison.Ordinal) && trimmed.EndsWith(")", StringComparison.Ordinal))
-            return true;
-        
-        // Skip lines that are clearly continuation text (start with lowercase, common continuation words)
-        if (trimmed.Length > 0 && char.IsLower(trimmed[0]))
-        {
-            // Check if it starts with common continuation words
-            var continuationPrefixes = new[] { "be ", "the ", "and ", "or ", "to ", "a ", "an ", "will ", "may ", "can " };
-            foreach (var prefix in continuationPrefixes)
-            {
-                if (trimmed.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
-                    return true;
-            }
-        }
-        
-        // Skip informational lines that don't contain dates/times
-        if (trimmed.Contains("Schedule Posted", StringComparison.OrdinalIgnoreCase) ||
-            trimmed.Contains("Note:", StringComparison.OrdinalIgnoreCase) ||
-            trimmed.Contains("*Note:", StringComparison.OrdinalIgnoreCase))
-            return true;
-        
-        return false;
-    }
-
-    private string SanitizeInput(string input)
-    {
-
-	    input = input.Replace("–", "-");
-	    input = input.Replace("—", "-");
-
-	    return input;
-    }
-
-    private DateOnly ParseDate(string month, string dayOfMonth, int year)
-    {
-        // Use normalized MonthNames array from grammar
-        var monthLower = month.ToLower();
-        var monthIndex = Array.FindIndex(EventOccurrenceGrammar.MonthNames, 
-            m => m.ToLower() == monthLower);
-        
-        if (monthIndex < 0)
-            throw new ArgumentException($"Invalid month: {month}", nameof(month));
-        
-        // Month index is 0-based, month number is 1-based
-        int monthNum = monthIndex + 1;
-        var day = int.Parse(dayOfMonth);
-		return new DateOnly(year, monthNum, day);
-    }
-
-    /// <summary>
-    /// Parses time and location from the timeAndLocation string using configurable location patterns.
-    /// </summary>
-    private (string time, string location, bool locationParseSuccess) ParseTimeAndLocation(
-        string timeAndLocation, 
-        int lineNumber, 
-        string lineContent, 
-        List<ParsingIssue> issues)
-    {
-        var time = timeAndLocation;
-        var location = string.Empty;
-        var locationParseSuccess = false;
-
-        // First, try to separate time from location using the time regex
-        var timeLocationMatch = _timeLocationRegex.Match(timeAndLocation);
-        
-        if (timeLocationMatch.Success)
-        {
-            time = timeLocationMatch.Groups["Time"].Captures[0].Value.Trim();
-            var locationPart = timeLocationMatch.Groups["Location"].Success 
-                ? timeLocationMatch.Groups["Location"].Captures[0].Value.Trim() 
-                : string.Empty;
-
-            if (!string.IsNullOrWhiteSpace(locationPart))
-            {
-                // Clean up location part - remove any remaining time components (e.g., "– 12:15 p.m. Exhibit Hall C" -> "Exhibit Hall C")
-                locationPart = CleanLocationText(locationPart);
-
-                if (!string.IsNullOrWhiteSpace(locationPart))
-                {
-                    // Try to match location using configurable patterns
-                    if (_locationConfig != null && _locationConfig.LocationPatterns.Any())
-                    {
-                        location = MatchLocationPattern(locationPart, _locationConfig.LocationPatterns);
-                        locationParseSuccess = !string.IsNullOrEmpty(location);
-                        
-                        // If pattern matching failed but location part looks valid, try matching against cleaned version
-                        if (!locationParseSuccess && !string.IsNullOrWhiteSpace(locationPart))
-                        {
-                            // Some locations might not match because of extra whitespace or formatting
-                            // Try matching the location even if initial match failed
-                            var cleanedForMatching = locationPart.Trim();
-                            location = MatchLocationPattern(cleanedForMatching, _locationConfig.LocationPatterns);
-                            locationParseSuccess = !string.IsNullOrEmpty(location);
-                            if (locationParseSuccess)
-                            {
-                                location = cleanedForMatching; // Use the cleaned version
-                            }
-                        }
-                    }
-                    
-                    // If no pattern matched but we have a location, use it anyway but mark as not matching pattern
-                    // This allows parsing to continue while still tracking that the location didn't match a pattern
-                    if (!locationParseSuccess && !string.IsNullOrWhiteSpace(locationPart))
-                    {
-                        location = locationPart;
-                        // Only add issue if we have patterns configured but none matched
-                        // This helps identify locations that might need new patterns added
-                        if (_locationConfig != null && _locationConfig.LocationPatterns.Any())
-                        {
-                            issues.Add(new ParsingIssue
-                            {
-                                LineNumber = lineNumber,
-                                LineContent = lineContent,
-                                IssueType = ParsingIssueType.LocationParseFailure,
-                                Message = $"Location '{locationPart}' does not match any configured pattern"
-                            });
-                        }
-                    }
-                }
-            }
-            else
-            {
-                // No location part found, which is valid (some events might not have locations)
-                locationParseSuccess = true; // Consider it a success since no location is needed
-            }
-        }
-        else
-        {
-            // If time regex doesn't match, use the whole string as time
-            time = timeAndLocation.Trim();
-        }
-
-        return (time, location, locationParseSuccess || string.IsNullOrWhiteSpace(location));
-    }
-
-    /// <summary>
-    /// Cleans location text by removing any remaining time components.
-    /// Handles cases like "– 12:15 p.m. Exhibit Hall C" -> "Exhibit Hall C"
-    /// </summary>
-    private string CleanLocationText(string locationText)
-    {
-        if (string.IsNullOrWhiteSpace(locationText))
-            return string.Empty;
-            
-        // Remove leading dashes and whitespace
-        // Note: Input is normalized, so only regular hyphens need to be handled
-        locationText = locationText.TrimStart('-', ' ', '\t');
-        
-        // Try to match and remove time patterns at the start
-        // Pattern 1: Dash, whitespace, time (e.g., "- 12:15 p.m. " or "- NOON ")
-        // Note: Input is normalized, so only regular hyphens need to be handled
-        var dashTimePattern = new Regex(@"^-\s+(?:NOON|\d{1,2}:?\d{0,2}\s*[AaPp]\.?[Mm]\.?)\s+", RegexOptions.IgnoreCase);
-        locationText = dashTimePattern.Replace(locationText, "").Trim();
-        
-        // Pattern 2: Time without dash at start (e.g., "12:15 p.m. " or "NOON ")
-        var timePatternAtStart = new Regex(@"^(?:NOON|\d{1,2}:?\d{0,2}\s*[AaPp]\.?[Mm]\.?)\s+", RegexOptions.IgnoreCase);
-        locationText = timePatternAtStart.Replace(locationText, "").Trim();
-        
-        // Pattern 3: Any remaining dash-time combinations (more flexible)
-        // Note: Input is normalized, so only regular hyphens need to be handled
-        var remainingDashTime = new Regex(@"^-\s*(?:NOON|\d{1,2}:?\d{0,2}\s*[AaPp]\.?[Mm]\.?)\s*", RegexOptions.IgnoreCase);
-        locationText = remainingDashTime.Replace(locationText, "").Trim();
-        
-        // Pattern 4: Remove any standalone time at the start (handles cases where dash was already removed)
-        var standaloneTime = new Regex(@"^(?:NOON|\d{1,2}:?\d{0,2}\s*[AaPp]\.?[Mm]\.?)$", RegexOptions.IgnoreCase);
-        if (standaloneTime.IsMatch(locationText))
-            return string.Empty; // If only time remains, there's no location
-        
-        return locationText.Trim();
-    }
-
-    /// <summary>
-    /// Matches location text against configured patterns and returns the matched location.
-    /// </summary>
-    private string MatchLocationPattern(string locationText, List<string> patterns)
-    {
-        // Normalize location text for matching (trim and handle variations)
-        var normalizedLocation = locationText.Trim();
-        
-        // If location is empty after normalization, return empty
-        if (string.IsNullOrWhiteSpace(normalizedLocation))
-            return string.Empty;
-        
-        foreach (var pattern in patterns)
-        {
-            var normalizedPattern = pattern.Trim();
-            
-            // Skip empty patterns
-            if (string.IsNullOrWhiteSpace(normalizedPattern))
-                continue;
-            
-            // Handle exact matches (patterns without wildcards like "Online", "Virtual", "TBD")
-            if (!normalizedPattern.Contains('*'))
-            {
-                if (string.Equals(normalizedPattern, normalizedLocation, StringComparison.OrdinalIgnoreCase))
-                {
-                    return normalizedLocation;
-                }
-                continue;
-            }
-
-            // Convert pattern to regex: escape special chars, replace * with .*
-            // This handles patterns like "Exhibit Hall *", "Room *", "Mtg. Room *", etc.
-            var escapedPattern = Regex.Escape(normalizedPattern);
-            escapedPattern = escapedPattern.Replace(@"\*", ".*?");
-            
-            // Use case-insensitive matching
-            var regex = new Regex($"^{escapedPattern}$", RegexOptions.IgnoreCase);
-            if (regex.IsMatch(normalizedLocation))
-            {
-                return normalizedLocation; // Return the full matched location
-            }
-        }
-
-        return string.Empty;
-    }
-
-    private TimeOnly ParseStartTime(string time)
-    {
-	    int hour = 0;
-	    int minute = 0;
-
-        // Handle TBD (To Be Determined) times gracefully
-        if (string.Equals(time.Trim(), "TBD", StringComparison.OrdinalIgnoreCase))
-        {
-            // Use a placeholder time (midnight) for TBD - the occurrence will still be created
-            // but with a time that indicates it's TBD
-            return new TimeOnly(0, 0, 0);
-        }
-
-		// get the part of the time before a timespan
-	    if (time.Contains(" - "))
-	    {
-		    time = time[..time.IndexOf(" - ", StringComparison.Ordinal)];
-
-	    }
-
-	    if (time == "NOON")
-		    hour = 12;
-	    else
-	    {
-		    // Regex is case-insensitive, so ToLower() is not needed
-		    var timeMatch = _timeRe.Match(time);
-		    if (timeMatch.Success)
-		    {
-			    hour = int.Parse(timeMatch.Groups["Hour"].Captures[0].Value);
-			    if (timeMatch.Groups["Minute"].Success)
-			    {
-				    minute = int.Parse(timeMatch.Groups["Minute"].Captures[0].Value);
-				}
-
-			    if (timeMatch.Groups["APM"].Captures[0].Value is "p.m." or "pm" && hour < 12)
-				    hour += 12;
-		    }
-		    else
-		    {
-			    throw new FormatException($"Time format not recognized: {time}");
-		    }
-	    }
-
-	    return new TimeOnly(hour, minute, 0);
-    }
 }

Core/Utility/TextUtil.cs

@@ -1,7 +1,48 @@
-namespace Core.Utility;
+using Core.Parsers;
+
+namespace Core.Utility;
 
 public static class TextUtil
 {
+	/// <summary>
+	/// Sanitizes input by normalizing hyphens (en-dash, em-dash -> regular hyphen).
+	/// This allows parsers to assume normalized input.
+	/// </summary>
+	/// <param name="input">The input string to sanitize.</param>
+	/// <returns>The sanitized string with normalized hyphens.</returns>
+	public static string SanitizeInput(string input)
+	{
+		input = input.Replace("–", "-"); // en-dash
+		input = input.Replace("—", "-"); // em-dash
+		return input;
+	}
+
+	/// <summary>
+	/// Parses a date from month name, day of month, and year.
+	/// </summary>
+	/// <param name="month">The month name (e.g., "January", "February"). Case-insensitive.</param>
+	/// <param name="dayOfMonth">The day of the month as a string (e.g., "15", "3").</param>
+	/// <param name="year">The year (e.g., 2025).</param>
+	/// <returns>A <see cref="DateOnly"/> representing the parsed date.</returns>
+	/// <exception cref="ArgumentException">Thrown when the month name is invalid.</exception>
+	/// <exception cref="FormatException">Thrown when the day of month cannot be parsed as an integer.</exception>
+	/// <exception cref="ArgumentOutOfRangeException">Thrown when the resulting date is invalid (e.g., February 30).</exception>
+	public static DateOnly ParseDate(string month, string dayOfMonth, int year)
+	{
+		// Use normalized MonthNames array from grammar
+		var monthLower = month.ToLower();
+		var monthIndex = Array.FindIndex(EventOccurrenceGrammar.MonthNames, 
+			m => m.ToLower() == monthLower);
+		
+		if (monthIndex < 0)
+			throw new ArgumentException($"Invalid month: {month}", nameof(month));
+		
+		// Month index is 0-based, month number is 1-based
+		int monthNum = monthIndex + 1;
+		var day = int.Parse(dayOfMonth);
+		return new DateOnly(year, monthNum, day);
+	}
+
 	/// <summary>
 	/// Get the ordinal value of positive integers.
 	/// </summary>