main.go

// Package main demonstrates retry functionality.
package main

import (
	"context"
	"errors"
	"fmt"
	"math/rand"
	"time"

	"github.com/yigithankarabulut/wirekit"
	"github.com/yigithankarabulut/wirekit/retry"
	"go.uber.org/zap"
)

// BasicRetry demonstrates basic retry usage.
func BasicRetry(ctx context.Context) {
	fmt.Println("\n--- Basic Retry ---")

	attempt := 0
	err := wirekit.Retry().
		WithAttempts(5).
		WithDelay(500*time.Millisecond).
		WithBackoff(retry.ExponentialBackoff).
		Do(ctx, func() error {
			attempt++
			wirekit.Debug(fmt.Sprintf("attempt %d", attempt))

			// Simulate random failure
			if rand.Float32() < 0.7 { //nolint:gosec
				return errors.New("random failure")
			}
			return nil
		})

	if err != nil {
		wirekit.Error("operation failed after all retries", zap.Error(err))
	} else {
		wirekit.Info(fmt.Sprintf("succeeded on attempt %d", attempt))
	}
}

// RetryWithData demonstrates retry with data return.
func RetryWithData(ctx context.Context) {
	fmt.Println("\n--- Retry With Data ---")

	fetchAttempt := 0
	data, err := retry.DoWithData(ctx, wirekit.Retry().WithAttempts(3), func() (string, error) {
		fetchAttempt++
		wirekit.Debug(fmt.Sprintf("fetch attempt %d", fetchAttempt))

		if fetchAttempt < 2 {
			return "", errors.New("fetch failed")
		}
		return "fetched data", nil
	})

	if err != nil {
		wirekit.Error("failed to fetch data", zap.Error(err))
	} else {
		fmt.Println("Data:", data)
	}
}

// ConditionalRetry demonstrates retry with condition.
func ConditionalRetry(ctx context.Context) {
	fmt.Println("\n--- Conditional Retry ---")

	ErrNotRetryable := errors.New("not retryable")
	ErrRetryable := errors.New("retryable error")

	retryAttempt := 0
	err := wirekit.Retry().
		WithAttempts(5).
		WithRetryIf(func(err error) bool {
			// Only retry specific errors
			return !errors.Is(err, ErrNotRetryable)
		}).
		Do(ctx, func() error {
			retryAttempt++
			if retryAttempt == 1 {
				return ErrRetryable // Will be retried
			}
			if retryAttempt == 2 {
				return ErrNotRetryable // Will NOT be retried
			}
			return nil
		})

	if errors.Is(err, ErrNotRetryable) {
		wirekit.Info("stopped retrying on non-retryable error")
	}
}

// BackoffStrategies demonstrates different backoff strategies.
func BackoffStrategies() {
	fmt.Println("\n--- Backoff Strategies ---")

	// Constant delay
	constantBackoff := wirekit.Retry().
		WithAttempts(3).
		WithDelay(time.Second).
		WithBackoff(retry.ConstantBackoff)
	fmt.Printf("Constant Backoff: %T\n", constantBackoff)

	// Linear backoff: 1s, 2s, 3s, ...
	linearBackoff := wirekit.Retry().
		WithAttempts(5).
		WithDelay(time.Second).
		WithBackoff(retry.LinearBackoff)
	fmt.Printf("Linear Backoff: %T\n", linearBackoff)

	// Exponential backoff: 1s, 2s, 4s, 8s, ... (capped at maxDelay)
	exponentialBackoff := wirekit.Retry().
		WithAttempts(10).
		WithDelay(time.Second).
		WithMaxDelay(30 * time.Second).
		WithBackoff(retry.ExponentialBackoff)
	fmt.Printf("Exponential Backoff: %T\n", exponentialBackoff)
}

// QuickRetryHelpers demonstrates quick retry functions.
func QuickRetryHelpers(ctx context.Context) {
	fmt.Println("\n--- Quick Retry Helpers ---")

	// Try once (no retries)
	_ = retry.Once(ctx, func() error {
		return nil
	})
	fmt.Println("Once: completed")

	// Try twice
	_ = retry.Twice(ctx, func() error {
		return nil
	})
	fmt.Println("Twice: completed")

	// Try n times
	_ = retry.Times(ctx, 5, func() error {
		return nil
	})
	fmt.Println("Times(5): completed")
}

// ForeverRetry demonstrates infinite retry until success.
func ForeverRetry(ctx context.Context) {
	fmt.Println("\n--- Forever Retry ---")

	ctxWithTimeout, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	foreverAttempt := 0
	err := retry.Forever(ctxWithTimeout, 500*time.Millisecond, func() error {
		foreverAttempt++
		if foreverAttempt < 3 {
			return errors.New("not yet")
		}
		wirekit.Info("forever retry succeeded")
		return nil
	})
	if err != nil {
		wirekit.Error("forever retry cancelled", zap.Error(err))
	}
}

func main() {
	wirekit.Log(wirekit.Zap).WithLevel("debug").Init()

	ctx := context.Background()

	BasicRetry(ctx)
	RetryWithData(ctx)
	ConditionalRetry(ctx)
	BackoffStrategies()
	QuickRetryHelpers(ctx)
	ForeverRetry(ctx)

	wirekit.Info("retry example completed")
}