Calculate the conditional probability of an event occurring, given the following probability of each outcome, with the additional constraint that the sum of the probabilities of all outcomes must be equal to 1. You must implement the calculation using a recursive function.

You are given a list of outcomes, each represented by a tuple containing the outcome and its probability. For example, [("A", 0.5), ("B", 0.3), ("C", 0.2)] represents three possible outcomes A, B, and C with probabilities 0.5, 0.3, and 0.2 respectively.

Your task is to implement a recursive function that calculates the conditional probability of an event occurring given these outcomes. The function should take the following parameters:
- outcomes: a list of tuples representing the outcomes and their probabilities
- event: a string representing the event

The function should return the conditional probability of the event occurring.

To calculate the conditional probability, you need to sum the probabilities of all outcomes where the event occurs, and divide it by the total probability of all outcomes.

For example, given the outcomes [("A", 0.5), ("B", 0.3), ("C", 0.2)] and the event "A", the function should return 0.5, as the probability of event "A" occurring is 0.5.

To solve this problem, you can follow these steps:
1. Initialize a variable total_prob with a value of 0.0 to store the total probability of all outcomes.
2. Initialize a variable event_prob with a value of 0.0 to store the probability of the event occurring.
3. Iterate over the outcomes list using a for loop.
4. For each outcome, check if the outcome matches the event. If it does, add its probability to event_prob.
5. Add the probability of the outcome to total_prob.
6. If the outcome is not the last outcome in the list, make a recursive call to the function with the remaining outcomes.
7. Finally, calculate and return the conditional probability by dividing event_prob by total_prob.

You should ensure that your function handles edge cases correctly, such as when the outcomes list is empty or when the event does not occur in any outcome.
Here's a recursive implementation of the function:

```python
def calculate_conditional_probability(outcomes, event):
    # Base case: if outcomes list is empty, return 0
    if len(outcomes) == 0:
        return 0
    
    # Base case: if event does not occur in any outcome, return 0
    if event not in [outcome[0] for outcome in outcomes]:
        return 0
    
    # Initialize variables
    total_prob = 0.0
    event_prob = 0.0
    
    # Iterate over outcomes list
    for i, outcome in enumerate(outcomes):
        outcome_event = outcome[0]
        outcome_prob = outcome[1]
        
        # Check if outcome matches the event
        if outcome_event == event:
            event_prob += outcome_prob
            
        total_prob += outcome_prob
        
        # Recursive call with remaining outcomes
        if i < len(outcomes) - 1:
            remaining_outcomes = outcomes[i+1:]
            conditional_prob = calculate_conditional_probability(remaining_outcomes, event)
            event_prob += outcome_prob * conditional_prob
            
    # Calculate and return conditional probability
    return event_prob / total_prob
```

You can test the function with the example outcomes and event provided in the question:

```python
outcomes = [("A", 0.5), ("B", 0.3), ("C", 0.2)]
event = "A"

print(calculate_conditional_probability(outcomes, event))  # Output: 0.5
```

This will output the conditional probability of the event "A" occurring given the outcomes.