Refactor-Method-Complexity-Reduce

# Refactor Method to Reduce Cognitive Complexity

Objective

Refactor the method `${input:methodName}`, to reduce its cognitive complexity to `${input:complexityThreshold}` or below, by extracting logic into focused helper methods.

Instructions

1. **Analyze the current method** to identify sources of cognitive complexity:

- Nested conditional statements

- Multiple if-else or switch chains

- Repeated code blocks

- Multiple loops with conditions

- Complex boolean expressions

2. **Identify extraction opportunities**:

- Validation logic that can be extracted into a separate method

- Type-specific or case-specific processing that repeats

- Complex transformations or calculations

- Common patterns that appear multiple times

3. **Extract focused helper methods**:

- Each helper should have a single, clear responsibility

- Extract validation into separate `Validate*` methods

- Extract type-specific logic into handler methods

- Create utility methods for common operations

- Use appropriate access levels (static, private, async)

4. **Simplify the main method**:

- Reduce nesting depth

- Replace massive if-else chains with smaller orchestrated calls

- Use switch statements where appropriate for cleaner dispatch

- Ensure the main method reads as a high-level flow

5. **Preserve functionality**:

- Maintain the same input/output behavior

- Keep all validation and error handling

- Preserve exception types and error messages

- Ensure all parameters are properly passed to helpers

6. **Best practices**:

- Make helper methods static when they don't need instance state

- Use null checks and guard clauses early

- Avoid creating unnecessary local variables

- Consider using tuples for multiple return values

- Group related helper methods together

Implementation Approach

- Extract helper methods before refactoring the main flow

- Test incrementally to ensure no regressions

- Use meaningful names that describe the extracted responsibility

- Keep extracted methods close to where they're used

- Consider making repeated code patterns into generic methods

Result

The refactored method should:

- Have cognitive complexity reduced to the target threshold of `${input:complexityThreshold}` or below

- Be more readable and maintainable

- Have clear separation of concerns

- Be easier to test and debug

- Retain all original functionality

Testing and Validation

**CRITICAL: After completing the refactoring, you MUST:**

1. **Run all existing tests** related to the refactored method and its surrounding functionality

2. **MANDATORY: Explicitly verify test results show "failed=0"**

- **NEVER assume tests passed** - always examine the actual test output

- Search for the summary line containing pass/fail counts (e.g., "passed=X failed=Y")

- **If the summary shows any number other than "failed=0", tests have FAILED**

- If test output is in a file, read the entire file to locate and verify the failure count

- Running tests is NOT the same as verifying tests passed

- **Do not proceed** until you have explicitly confirmed zero failures

3. **If any tests fail (failed > 0):**

- State clearly how many tests failed

- Analyze each failure to understand what functionality was broken

- Common causes: null handling, empty collection checks, condition logic errors

- Identify the root cause in the refactored code

- Correct the refactored code to restore the original behavior

- Re-run tests and verify "failed=0" in the output

- Repeat until all tests pass (failed=0)

4. **Verify compilation** - Ensure there are no compilation errors

5. **Check cognitive complexity** - Confirm the metric is at or below the target threshold of `${input:complexityThreshold}`

Confirmation Checklist

- [ ] Code compiles without errors

- [ ] **Test results explicitly state "failed=0"** (verified by reading the output)

- [ ] All test failures analyzed and corrected (