# Ramificazione condizionale

I workflow possono passare a un passaggio con nome in base all'output di un passaggio precedente. Per farlo, si restituisce una chiave speciale `_next_step` nel valore restituito dal passaggio.

Se volete tornare specificamente a un passaggio precedente in base allo stato del workflow, consultate [Ripetizioni](https://queuety.inline0.dev/it/docs/workflows/repeats). In questo modo il collegamento all'indietro resta esplicito nella definizione del workflow, invece di essere nascosto in una classe di passaggio.

## Passaggi con nome

Assegnate un nome ai passaggi usando il secondo argomento di `->then()`:

```php
use Queuety\Queuety;

Queuety::workflow( 'process_order' )
    ->then( ValidateOrderHandler::class, 'validate' )
    ->then( ChargePaymentHandler::class, 'charge' )
    ->then( FulfillOrderHandler::class, 'fulfill' )
    ->then( SendConfirmationHandler::class, 'confirm' )
    ->then( HandleFailureHandler::class, 'failure' )
    ->dispatch( [ 'order_id' => 123 ] );
```

Senza un nome esplicito, i passaggi vengono denominati in base al loro indice (`'0'`, `'1'`, `'2'` e così via).

## La chiave `_next_step`

Un passaggio può restituire `_next_step` per passare a un passaggio con nome, saltando tutti quelli intermedi. I passaggi successivi alla destinazione del salto vengono comunque eseguiti in ordine: senza un salto, il workflow prosegue semplicemente con il passaggio successivo nell'elenco, quindi nell'esempio precedente un passaggio `confirm` completato correttamente prosegue con `failure`, a meno che non restituisca un `_next_step` che lo salta oppure `HandleFailureHandler` controlli prima la presenza di una chiave `error`:

```php
use Queuety\Step;

class ValidateOrderHandler implements Step {
    public function handle( array $state ): array {
        $order = wc_get_order( $state['order_id'] );

        if ( ! $order || $order->get_status() === 'cancelled' ) {
            return [
                'error'  => 'Order is invalid or cancelled',
                '_next_step'  => 'failure',
            ];
        }

        return [
            'order_total' => $order->get_total(),
            'customer_id' => $order->get_customer_id(),
        ];
    }

    public function config(): array {
        return [];
    }
}
```

Quando `ValidateOrderHandler` restituisce `_next_step => 'failure'`, il workflow salta `charge`, `fulfill` e `confirm`, passando direttamente al passaggio `failure`. La chiave `_next_step` viene usata dal motore del workflow e non viene salvata nello stato.

## Modelli di ramificazione

### Salto in base a una condizione

```php
class CheckInventoryHandler implements Step {
    public function handle( array $state ): array {
        $in_stock = check_inventory( $state['sku'] );

        if ( ! $in_stock ) {
            return [
                'reason' => 'Out of stock',
                '_next_step'  => 'notify_backorder',
            ];
        }

        return [ 'inventory_reserved' => true ];
    }

    public function config(): array {
        return [];
    }
}
```

### Completamento anticipato

Passate al passaggio finale per saltare le elaborazioni non necessarie:

```php
class CheckCacheHandler implements Step {
    public function handle( array $state ): array {
        $cached = get_transient( "report_{$state['user_id']}" );

        if ( $cached ) {
            return [
                'report_url' => $cached,
                '_next_step'      => 'done',
            ];
        }

        return [ 'cache_miss' => true ];
    }

    public function config(): array {
        return [];
    }
}
```

## Esempio completo

```php
Queuety::workflow( 'content_pipeline' )
    ->then( CheckCacheHandler::class, 'check_cache' )
    ->then( FetchDataHandler::class, 'fetch' )
    ->then( CallLLMHandler::class, 'generate' )
    ->then( SaveResultHandler::class, 'save' )
    ->then( ReturnCachedHandler::class, 'done' )
    ->dispatch( [ 'user_id' => 42 ] );
```

Se il controllo della cache trova un risultato, il workflow passa direttamente da `check_cache` a `done`, saltando `fetch`, `generate` e `save`. Se non trova risultati, i passaggi vengono eseguiti in ordine e `save` prosegue anche con `done`, quindi `ReturnCachedHandler` deve gestire entrambi i percorsi.