def save(self, incident: HasImpactProtocol) -> None:
    """Save the impact choices to the incident."""
    if self.is_valid():
        impacts: dict[str, ImpactLevel] = self.cleaned_data

        # Prepare a list of impact type slugs by removing the 'set_impact_type_' prefix
        impact_type_slugs: list[str] = [
            slug.replace("set_impact_type_", "") for slug in impacts
        ]

        # Fetch all relevant ImpactType instances in a single query
        impact_types: dict[str, ImpactType] = ImpactType.objects.in_bulk(
            impact_type_slugs, field_name="value"
        )

        impact_objects: list[Impact] = []

        for impact_type_slug, impact_level in impacts.items():
            impact_type_slug = impact_type_slug.replace(  # noqa: PLW2901
                "set_impact_type_", ""
            )
            impact_type = impact_types.get(impact_type_slug)
            if impact_type is None:
                logger.warning(
                    f"Could not find impact type {impact_type_slug} in incident {incident.id}"
                )
                continue

            impact = Impact(impact_type=impact_type, impact_level=impact_level)
            impact_objects.append(impact)

        # Create and save all Impact instances in one database call
        Impact.objects.bulk_create(impact_objects)
        impacts_related_manager: ManyRelatedManager[Impact] = cast(
            "ManyRelatedManager[Impact]",
            incident.impacts,
        )
        impacts_related_manager.add(*impact_objects)

    else:
        raise forms.ValidationError("Form is not valid")

def suggest_priority_from_impact(self) -> int:
    """Suggest a priority from 1 (highest) to 5 (lowest) based on the impact choices."""
    if self.is_valid():
        impact: dict[str, ImpactLevel] = self.cleaned_data

        impact_values = [impact_type.value for impact_type in impact.values()]
        priorities = [level.priority for level in LevelChoices if level in impact_values]
        return min(priorities) if priorities else LevelChoices.NONE.priority
    return LevelChoices.NONE.priority

def save(self) -> None:
    """Save each changed field in place."""
    for field_name in self.changed_data:
        key = field_name.removeprefix(self.field_prefix)
        value = self.cleaned_data[field_name]
        if key.startswith("milestone_"):
            self._save_milestone(key.removeprefix("milestone_"), value)
        elif key.startswith("status_"):
            self._save_status(key.removeprefix("status_"), value)

def save(self) -> None:
    """Save each changed field in place."""
    for field_name in self.changed_data:
        key = field_name.removeprefix(self.field_prefix)
        value = self.cleaned_data[field_name]
        if key.startswith("milestone_"):
            self._save_milestone(key.removeprefix("milestone_"), value)
        elif key.startswith("status_"):
            self._save_status(key.removeprefix("status_"), value)

def clean(self) -> dict[str, Any]:
    """Custom validation based on response type and impacts."""
    cleaned_data = super().clean()
    if cleaned_data is None:
        cleaned_data = {}

    # Get response_type from initial data if available
    initial = self.initial or {}
    response_type = initial.get("response_type", "critical")

    # Validate suggested_team_routing is required for normal incidents
    if response_type == "normal" and not cleaned_data.get("suggested_team_routing"):
        self.add_error(
            "suggested_team_routing",
            "Feature Team is required for P4/P5 incidents",
        )

    return cleaned_data

def get_visible_fields_for_impacts(
    self, impacts_data: dict[str, ImpactLevel | str], response_type: str
) -> list[str]:
    """Determine which fields should be visible based on impacts and response type.

    Args:
        impacts_data: Dictionary of impact type → impact level (ImpactLevel object or UUID string)
        response_type: "critical" or "normal"

    Returns:
        List of field names that should be visible
    """
    visible_fields = [
        "title",
        "description",
        "incident_category",
        "environment",
        "platform",
        "priority",
    ]

    # Add suggested_team_routing for normal incidents (P4-P5)
    if response_type == "normal":
        visible_fields.append("suggested_team_routing")

    # Check impact selections
    customer_impact = None
    seller_impact = None

    for field_name, impact_level in impacts_data.items():
        if "customers_impact" in field_name:
            customer_impact = impact_level
        elif "sellers_impact" in field_name:
            seller_impact = impact_level

    # Helper to check if impact is not NONE
    def has_impact(impact: ImpactLevel | str | None) -> bool:
        if impact is None:
            return False

        # If it's a UUID string, fetch the ImpactLevel from database
        if isinstance(impact, str):
            try:
                impact_obj = ImpactLevel.objects.get(id=impact)
            except ImpactLevel.DoesNotExist:
                return False
            else:
                return impact_obj.value != LevelChoices.NONE.value

        # Otherwise it's an ImpactLevel object
        return impact.value != LevelChoices.NONE.value

    # Add customer-specific fields
    if has_impact(customer_impact):
        visible_fields.append("zendesk_ticket_id")

    # Add seller-specific fields
    if has_impact(seller_impact):
        visible_fields.extend([
            "seller_contract_id",
            "is_key_account",
            "is_seller_in_golden_list",
            "zoho_desk_ticket_id",
        ])

    return visible_fields

def trigger_incident_workflow(
    self,
    creator: User,
    impacts_data: dict[str, ImpactLevel],
    response_type: str = "critical",
    *args: Any,
    **kwargs: Any,
) -> Incident:
    """Trigger unified incident workflow for all priorities.

    This unified workflow:
    1. Always creates an Incident in the database (P1-P5)
    2. Conditionally creates a Slack channel (P1-P3 only)
    3. Always creates a Jira ticket linked to the Incident (P1-P5)

    Args:
        creator: User creating the incident
        impacts_data: Dictionary of impact data
        response_type: "critical" (P1-P3) or "normal" (P4-P5)
        *args: Additional positional arguments (unused)
        **kwargs: Additional keyword arguments (unused)

    Returns:
        The created Incident object
    """
    # Step 1: Always create Incident in database (ALL priorities)
    incident = self._create_incident(creator)

    # Save impacts
    impacts_form = SelectImpactForm(impacts_data)
    impacts_form.save(incident=incident)

    # Step 2: Conditionally create Slack channel (P1-P3 only)
    if self._should_create_slack_channel(response_type):
        self._create_slack_channel(incident, impacts_data)

    # Step 3: Always create Jira ticket (ALL priorities) - UNIFIED
    self._create_jira_ticket(incident, creator, impacts_data)

    return incident

def get_milestones_with_data(
    self,
    milestones_definitions: Iterable[MilestoneType],
) -> list[MilestoneTypeData]:
    """Get each [firefighter.incidents.models.milestone_type.MilestoneType][] with its `event_ts` from the IncidentUpdate."""
    milestones_objects = self.incident.latest_updates_by_type
    ass = []
    for milestone_def in milestones_definitions:
        event = milestones_objects.get(milestone_def.event_type)
        event_ts = event.event_ts if event and event.event_ts else None
        association = MilestoneTypeData(
            milestone_type=milestone_def, data=MilestoneData(event_ts)
        )
        ass.append(association)
    return ass

def save(self) -> None:
    """Custom save method to save each changed key event."""
    self.fields: dict[str, Field]
    for field_name in self.fields:
        if field_name not in self.changed_data or self.fields[field_name].disabled:
            logger.debug("skipping %s", field_name)
            continue
        if not field_name.startswith("key_event_"):
            continue

        key_event_type = field_name.replace("key_event_", "")

        logger.debug(f"save {field_name} {self.cleaned_data[field_name]}")
        self._save_key_event(key_event_type, self.cleaned_data[field_name])

def save(self) -> None:
    """Custom save method to save the updated roles."""
    self.fields: dict[str, Field]
    roles_to_update: dict[str, User | None] = {}
    for field_name in self.fields:
        if field_name not in self.changed_data or self.fields[field_name].disabled:
            logger.debug("skipping %s", field_name)
            continue
        if not field_name.startswith("role_"):
            continue

        role_type_slug = field_name.replace("role_", "")

        roles_to_update[role_type_slug] = self.cleaned_data[field_name]
    if self.user is None:
        raise RuntimeError("User is required, was the form validated?")
    self.incident.update_roles(self.user, roles_to_update)

def clean_message(self) -> str:
    """Validate message field, ensuring reopening from MITIGATED has sufficient justification."""
    message = self.cleaned_data.get("message", "").strip()

    # Get the incident and status from form data/initialization
    incident = getattr(self, "incident", None)
    status_value = self.data.get("status")  # Use raw form data as cleaned_data may not be ready yet

    if incident and status_value:
        current_status = incident.status

        # Convert status value to enum if it's a string/number
        try:
            if isinstance(status_value, str):
                status = IncidentStatus(int(status_value))
            else:
                status = IncidentStatus(status_value)
        except (ValueError, TypeError):
            # Invalid status value, let other validation handle it
            return message

        # If reopening from MITIGATED to earlier phases, require substantial justification
        if (current_status == IncidentStatus.MITIGATED and
            status in {IncidentStatus.INVESTIGATING, IncidentStatus.MITIGATING} and
            len(message) < 10):
            raise forms.ValidationError(
                "A detailed justification (minimum 10 characters) is required when reopening "
                "an incident from MITIGATED status."
            )

    return message

@staticmethod
def requires_closure_reason(
    incident: Incident, target_status: IncidentStatus
) -> bool:
    """Check if closing this incident to the target status requires a closure reason.

    Based on the workflow diagram:
    - P1/P2 and P3/P4/P5: require reason when closing from Opened or Investigating
    """
    if target_status != IncidentStatus.CLOSED:
        return False

    current_status = incident.status

    # Require reason if closing from Opened or Investigating (for any priority)
    return current_status.value in {
        IncidentStatus.OPEN,
        IncidentStatus.INVESTIGATING,
    }

def to_python(self, value: Any) -> int | str | Any:
    """Return a value from the enum class."""
    if value in self.empty_values:
        return ""
    # Cast to int if it's a string representation of an int
    if isinstance(value, str) and value.isdigit():
        value = int(value)

    # If value is already a valid enum member, return it
    if isinstance(value, self.enum_class):
        return value
    try:
        return self.coerce_func(value)
    except ValueError as exc:
        err_msg = f"{value} is not a valid {self.enum_class.__name__}"
        raise ValidationError(err_msg, code="invalid_choice") from exc

def validate(self, value: Any) -> None:
    """Log validation for debugging."""
    logger.debug(f"EnumChoiceField.validate: value={value!r} (type={type(value).__name__}), choices={self.choices}")
    return super().validate(value)