FodErrorHandler

<FodErrorPopup
    ErrorReport="@_errorReport"
    ShowTechnicalDetails="true"
    ShowRetryButton="true"
    ShowContactSupportButton="true"
    MaxRetryAttempts="3"
    OnRetry="HandleRetry"
    OnDismiss="HandleDismiss"
    OnContactSupport="HandleContactSupport" />

@code {
    private FodErrorReport? _errorReport;

    private void ShowError(HttpResponseMessage response)
    {
        _errorReport = new FodErrorReport
        {
            ErrorId = ErrorIdGenerator.Generate(),
            StatusCode = (int)response.StatusCode,
            ErrorTitle = "Request Failed",
            UserFriendlyMessage = "Please try again later.",
            RequestUrl = response.RequestMessage?.RequestUri?.ToString(),
            Timestamp = DateTime.UtcNow
        };
    }
}

<!-- In Routes.razor - wraps entire application -->
<FodErrorBoundary>
    <ChildContent>
        <Router AppAssembly="typeof(Routes).Assembly">
            ...
        </Router>
    </ChildContent>
</FodErrorBoundary>

<!-- Custom error content (optional) -->
<FodErrorBoundary OnError="HandleError">
    <ChildContent>
        <YourComponent />
    </ChildContent>
    <ErrorContent Context="errorReport">
        <div class="my-custom-error">
            <h2>Error: @errorReport.ErrorId</h2>
            <p>@errorReport.UserFriendlyMessage</p>
        </div>
    </ErrorContent>
</FodErrorBoundary>

@code {
    private void HandleError(FodErrorReport report)
    {
        Console.WriteLine($"Error caught: {report.ErrorId}");
    }
}

@inject IFodPiiMaskingService PiiMaskingService

@code {
    private void MaskSensitiveData()
    {
        // IDNP: "1234567890123" -> "1234567****23"
        var maskedIdnp = PiiMaskingService.MaskIdnp("1234567890123");

        // Phone: "+37369123456" -> "******3456"
        var maskedPhone = PiiMaskingService.MaskPhone("+37369123456");

        // Email: "john.doe@example.com" -> "jo***@example.com"
        var maskedEmail = PiiMaskingService.MaskEmail("john.doe@example.com");

        // IDNO: "1003600123456" -> "1003*********"
        var maskedIdno = PiiMaskingService.MaskIdno("1003600123456");

        // MPowerCode: "MPower-12345678" -> "MPower-****5678"
        var maskedMPowerCode = PiiMaskingService.MaskMPowerCode("MPower-12345678");
    }
}

public class DeviceInfo
{
    public string? Browser { get; set; }
    public string? BrowserVersion { get; set; }
    public string? OperatingSystem { get; set; }
    public string? DeviceType { get; set; }  // Desktop, Mobile, Tablet
    public string? ScreenResolution { get; set; }
    public string? TimeZone { get; set; }
    public string? Language { get; set; }
    public bool OnlineStatus { get; set; }
    public bool CookiesEnabled { get; set; }
}

// Device info is automatically captured via JavaScript interop
// and included in FodErrorReport.Device property

// Register HttpClient with error handling in Program.cs
builder.Services.AddHttpClient("DemoApi", client =>
{
    client.BaseAddress = new Uri("https://api.example.com/");
}).WithErrorHandling();

// Usage - errors are automatically intercepted
@inject IHttpClientFactory HttpClientFactory

@code {
    private async Task CallApi()
    {
        var client = HttpClientFactory.CreateClient("DemoApi");
        var response = await client.GetAsync("/api/data");
        // If status code is in InterceptStatusCodes,
        // ErrorHandlingHttpMessageHandler creates FodErrorReport automatically
    }
}

public class RetryPolicy
{
    public int MaxRetries { get; set; } = 3;
    public int BaseDelayMs { get; set; } = 100;

    public async Task<T> ExecuteAsync<T>(
        Func<Task<T>> operation,
        CancellationToken ct = default)
    {
        for (int attempt = 1; attempt <= MaxRetries; attempt++)
        {
            try
            {
                return await operation();
            }
            catch when (attempt < MaxRetries)
            {
                int delayMs = (int)Math.Pow(2, attempt - 1) * BaseDelayMs;
                await Task.Delay(delayMs, ct);
            }
        }

        throw new InvalidOperationException("Max retries exceeded");
    }
}

public enum CircuitState { Closed = 0, Open = 1, HalfOpen = 2 }

public class CircuitBreaker
{
    public CircuitState State { get; private set; } = CircuitState.Closed;
    public int FailureThreshold { get; set; } = 3;
    private int _failureCount;

    public async Task<T> ExecuteAsync<T>(Func<Task<T>> operation)
    {
        if (State == CircuitState.Open)
            throw new InvalidOperationException("Circuit is open");

        try
        {
            return await operation();
        }
        catch
        {
            _failureCount++;
            if (_failureCount >= FailureThreshold)
                State = CircuitState.Open;
            throw;
        }
    }

    public void Reset()
    {
        _failureCount = 0;
        State = CircuitState.Closed;
    }
}