Set-Cookie: session=abc123xyz; Domain=.example.com; Path=/; Max-Age=3600; Secure; HttpOnly; SameSite=Lax

alice:s3cr3t_p@ssw0rd
→ Base64 →
YWxpY2U6czNjcjN0X3BAc3N3MHJk

Authorization: Basic YWxpY2U6czNjcjN0X3BAc3N3MHJk

using System.Net.Http.Headers;
using System.Text;

// httpbingo.org/basic-auth/{user}/{password} — реальна перевірка Basic Auth
// Повертає 401 при невірних даних, 200 при правильних
using var client = new HttpClient
{
    BaseAddress = new Uri("https://httpbingo.org/")
};

// Кодуємо "alice:secret" у Base64
string credentials = Convert.ToBase64String(
    Encoding.UTF8.GetBytes("alice:secret")
);

// Варіант 1: на рівні клієнта (для всіх запитів)
// GET /basic-auth/alice/secret → перевіряє Base64("alice:secret") у заголовку
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Basic", credentials);

// Варіант 2: на рівні одного запиту
var request = new HttpRequestMessage(HttpMethod.Get, "basic-auth/alice/secret");
request.Headers.Authorization =
    new AuthenticationHeaderValue("Basic", credentials);

HttpResponseMessage response = await client.SendAsync(request);

// Варіант 3: через NetworkCredential
var handler = new HttpClientHandler
{
    Credentials = new NetworkCredential("alice", "secret")
};
using var credClient = new HttpClient(handler);

1. Клієнт → GET /private
2. Сервер → 401 WWW-Authenticate: Digest realm="example.com",
              nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",
              qop="auth"
3. Клієнт обчислює:
   HA1 = MD5("alice:example.com:password")
   HA2 = MD5("GET:/private")
   response = MD5(HA1:nonce:nc:cnonce:qop:HA2)
4. Клієнт → GET /private
   Authorization: Digest username="alice",
     realm="example.com", nonce="dcd98b...",
     response="6629fae49393a05397450978507c4ef1"

Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiI0MiIsIm5hbWUiOiJBbGljZSIsInJvbGVzIjpbInVzZXIiXSwiZXhwIjoxNzQ3NDgwMDAwfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

sub  — subject: ідентифікатор суб'єкта (userId)
iss  — issuer: хто видав токен
aud  — audience: для кого токен (перевіряється при валідації)
exp  — expiration time: Unix timestamp закінчення
nbf  — not before: токен недійсний до цього часу
iat  — issued at: час видачі
jti  — JWT ID: унікальний ідентифікатор (для blacklist)

1. Перевірити підпис — HMAC/RSA верифікація
2. Перевірити exp (expiration) — токен не протух
3. Перевірити nbf (not before) — токен вже активний
4. Перевірити iss (issuer) — від правильного видавця
5. Перевірити aud (audience) — для цього сервісу
6. Перевірити alg — алгоритм відповідає очікуваному (не "none"!)
7. Опційно: перевірити jti у blacklist (для відкликання)

using System.Net.Http.Headers;
using System.Net.Http.Json;

// ── Крок 1: Отримати JWT-токен ───────────────────────────────────────────────
// dummyjson.com — реальний API з JWT аутентифікацією (справжній eyJ... токен)
using var client = new HttpClient { BaseAddress = new Uri("https://dummyjson.com/") };

// POST /auth/login → справжній JWT access + refresh token
var credentials = new { username = "emilys", password = "emilyspass", expiresInMins = 30 };
HttpResponseMessage authResponse = await client.PostAsJsonAsync("auth/login", credentials);
authResponse.EnsureSuccessStatusCode();

var tokenResult = await authResponse.Content.ReadFromJsonAsync<TokenResponse>();
Console.WriteLine($"Access token:  {tokenResult?.AccessToken[..30]}...");
Console.WriteLine($"Token type:    {tokenResult?.TokenType ?? "Bearer"}");

// ── Крок 2: Використовувати токен ────────────────────────────────────────────
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", tokenResult?.AccessToken);

// GET /auth/me — захищений endpoint, повертає поточного користувача
HttpResponseMessage profileResponse = await client.GetAsync("auth/me");
profileResponse.EnsureSuccessStatusCode();

var profile = await profileResponse.Content.ReadFromJsonAsync<UserProfile>();
Console.WriteLine($"Hello, {profile?.FirstName} {profile?.LastName}!");
Console.WriteLine($"Email: {profile?.Email}, Role: {profile?.Role}");

// ── Крок 3: Оновити токен через Refresh Token ─────────────────────────────────
if (tokenResult?.RefreshToken is not null)
{
    var refreshBody = new { refreshToken = tokenResult.RefreshToken, expiresInMins = 30 };
    var refreshResp = await client.PostAsJsonAsync("auth/refresh", refreshBody);

    if (refreshResp.IsSuccessStatusCode)
    {
        var newTokens = await refreshResp.Content.ReadFromJsonAsync<TokenResponse>();
        client.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Bearer", newTokens?.AccessToken);
        Console.WriteLine("Токен успішно оновлено.");
    }
}

// ── Моделі ───────────────────────────────────────────────────────────────────
record TokenResponse(string AccessToken, string RefreshToken, int ExpiresIn = 1800, string? TokenType = null);
record UserProfile(int Id, string FirstName, string LastName, string Email, string? Role);

// Server-to-server автентифікація без участі користувача.
// Замініть URL на ваш OAuth-сервер:
//   Auth0:     https://YOUR-DOMAIN.auth0.com/oauth/token
//   Keycloak:  https://YOUR-KEYCLOAK/realms/REALM/protocol/openid-connect/token
//   Azure AD:  https://login.microsoftonline.com/TENANT-ID/oauth2/v2.0/token
using var client = new HttpClient();

var tokenRequest = new FormUrlEncodedContent(new[]
{
    new KeyValuePair<string, string>("grant_type", "client_credentials"),
    new KeyValuePair<string, string>("client_id", "my-service-id"),
    new KeyValuePair<string, string>("client_secret", "my-service-secret"),
    new KeyValuePair<string, string>("scope", "read:analytics write:reports"),
});

// httpbingo.org/post — відображає тіло запиту (демонстрація формату без реального OAuth-сервера)
// У реальному проєкті: замінити на URL вашого OAuth-сервера
HttpResponseMessage echoResponse = await client.PostAsync(
    "https://httpbingo.org/post",
    tokenRequest
);
echoResponse.EnsureSuccessStatusCode();

Console.WriteLine("Запит відправлено. Формат: application/x-www-form-urlencoded");
Console.WriteLine("Параметри: grant_type=client_credentials, scope=read:analytics");

// Реальний OAuth-сервер поверне:
// {"access_token":"eyJ...","token_type":"Bearer","expires_in":3600,"scope":"read:analytics"}
// var token = await tokenResponse.Content.ReadFromJsonAsync<OAuthToken>();
// client.DefaultRequestHeaders.Authorization =
//     new AuthenticationHeaderValue("Bearer", token?.AccessToken);
// var data = await client.GetFromJsonAsync<object>("https://your-api.com/analytics/summary");

record OAuthToken(
    string AccessToken,
    string TokenType,
    int ExpiresIn,
    string? Scope
);

1. Client → POST /token (refresh_token=RT1)
2. Server → access_token=AT2, refresh_token=RT2 (RT1 інвалідовано)

Якщо зловмисник перехопив RT1:
3. Evil → POST /token (refresh_token=RT1)
4. Server: RT1 вже використано! → Блокувати всю сесію користувача

Certificate:
  Version:      3
  Serial:       0A:B4:C2:...
  Algorithm:    SHA256withRSA
  Issuer:       C=US, O=Let's Encrypt, CN=R10
  Validity:
    Not Before: 2025-01-01 00:00:00
    Not After:  2025-04-01 00:00:00   ← 90 днів для Let's Encrypt
  Subject:      CN=api.example.com
  Subject Alt Names (SAN):
    DNS: api.example.com
    DNS: *.example.com
  Public Key:   RSA 2048 bits (або EC P-256)
  Extensions:
    Key Usage: Digital Signature, Key Encipherment
    Extended Key Usage: TLS Web Server Authentication
    OCSP URL: http://ocsp.pki.goog/
    CRL URL:  http://crl.pki.goog/
  Signature:    [підпис Issuer приватним ключем]

Strict-Transport-Security: max-age=31536000; includeSubDomains; preload

using System.Net;
using System.Net.Http;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;

// ── Стандартне HTTPS — без додаткового налаштування ──────────────────────────
// HttpClient автоматично перевіряє сертифікат та використовує TLS 1.2/1.3
using var defaultClient = new HttpClient();
var response = await defaultClient.GetAsync("https://httpbingo.org/get");

// ── Явно вказати дозволені версії TLS ────────────────────────────────────────
var tlsHandler = new HttpClientHandler();
tlsHandler.SslProtocols = System.Security.Authentication.SslProtocols.Tls12
                        | System.Security.Authentication.SslProtocols.Tls13;
using var tlsClient = new HttpClient(tlsHandler);

// ── Кастомна перевірка сертифікату ───────────────────────────────────────────
// ⚠ ТІЛЬКИ ДЛЯ РОЗРОБКИ — ніколи не відключайте перевірку у production!
var devHandler = new HttpClientHandler
{
    ServerCertificateCustomValidationCallback = (message, cert, chain, errors) =>
    {
        if (errors == SslPolicyErrors.None) return true;
        // Приймаємо self-signed тільки для localhost
        return message.RequestUri?.Host is "localhost" or "127.0.0.1";
    }
};
using var devClient = new HttpClient(devHandler);

// ── Клієнтський сертифікат (mTLS — двостороння автентифікація) ────────────────
var mtlsHandler = new HttpClientHandler();
var clientCert = X509Certificate2.CreateFromPemFile("client.crt", "client.key");
mtlsHandler.ClientCertificates.Add(clientCert);
using var mtlsClient = new HttpClient(mtlsHandler);

// ── Отримати інформацію про сертифікат сервера ─────────────────────────────────
var infoHandler = new HttpClientHandler
{
    ServerCertificateCustomValidationCallback = (message, cert, chain, errors) =>
    {
        if (cert is not null)
        {
            Console.WriteLine($"Subject:  {cert.Subject}");
            Console.WriteLine($"Issuer:   {cert.Issuer}");
            Console.WriteLine($"Valid to: {cert.GetExpirationDateString()}");
            Console.WriteLine($"Thumbprint: {cert.GetCertHashString()}");
        }
        return errors == SslPolicyErrors.None;
    }
};
using var infoClient = new HttpClient(infoHandler);
await infoClient.GetAsync("https://httpbingo.org/");

using System.Net.Http;

using var client = new HttpClient();
// mozilla.org — сайт з повним набором security headers (HSTS, CSP, X-Frame-Options тощо)
HttpResponseMessage response = await client.GetAsync("https://www.mozilla.org/");

// Перевірити наявність security headers
var securityHeaders = new[]
{
    "Strict-Transport-Security",
    "Content-Security-Policy",
    "X-Frame-Options",
    "X-Content-Type-Options",
    "Referrer-Policy",
    "Permissions-Policy"
};

Console.WriteLine("Security Headers Audit:");
foreach (string header in securityHeaders)
{
    bool present = response.Headers.Contains(header)
                || response.Content.Headers.Contains(header);

    string status = present ? "✅" : "❌";
    string value = present
        ? response.Headers.TryGetValues(header, out var vals) ? string.Join(", ", vals) : "(in content headers)"
        : "ВІДСУТНІЙ";

    Console.WriteLine($"{status} {header}: {value}");
}

Cache-Control: max-age=60, stale-while-revalidate=30

<!-- BAD: старий URL, може кешуватись нескінченно -->
<script src="/app.js"></script>

<!-- GOOD: хеш вмісту у URL → при зміні файлу URL змінюється -->
<script src="/app.a1b2c3d4.js"></script>

Cache-Control: public, max-age=31536000, immutable

GET /api/products HTTP/1.1

→

HTTP/1.1 200 OK
Last-Modified: Thu, 22 May 2025 10:00:00 GMT
Cache-Control: max-age=60
Content-Length: 51200

[50KB body]

GET /api/products HTTP/1.1
If-Modified-Since: Thu, 22 May 2025 10:00:00 GMT

→

HTTP/1.1 304 Not Modified
Last-Modified: Thu, 22 May 2025 10:00:00 GMT

(без тіла!)

using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;

using var client = new HttpClient { BaseAddress = new Uri("https://httpbingo.org/") };

string? cachedETag = null;
DateTimeOffset? cachedLastModified = null;
string? cachedContent = null;

async Task<string?> GetProductsAsync()
{
    // httpbingo.org/etag/{etag} — повертає ETag і відповідає 304 при If-None-Match
    var request = new HttpRequestMessage(HttpMethod.Get, "etag/v5-abc123");

    // Conditional GET: ETag
    if (cachedETag is not null)
        request.Headers.IfNoneMatch.Add(new EntityTagHeaderValue($"\"{cachedETag}\""));

    // Conditional GET: Last-Modified
    if (cachedLastModified.HasValue)
        request.Headers.IfModifiedSince = cachedLastModified.Value;

    HttpResponseMessage response = await client.SendAsync(request);

    if (response.StatusCode == HttpStatusCode.NotModified)
    {
        Console.WriteLine("📦 304 Not Modified — 0 байт завантажено");
        return cachedContent;
    }

    response.EnsureSuccessStatusCode();

    // Зберігаємо валідатори для наступного запиту
    if (response.Headers.ETag is not null)
        cachedETag = response.Headers.ETag.Tag.Trim('"');

    if (response.Content.Headers.LastModified.HasValue)
        cachedLastModified = response.Content.Headers.LastModified;

    cachedContent = await response.Content.ReadAsStringAsync();
    Console.WriteLine($"🔄 200 OK — {cachedContent.Length} байт завантажено");
    return cachedContent;
}

var first = await GetProductsAsync();   // 200 OK — 50000 байт
var second = await GetProductsAsync();  // 304 Not Modified — 0 байт

Accept: application/json;q=1.0, application/xml;q=0.8, text/plain;q=0.5, */*;q=0.1

GET /api/users/42 HTTP/1.1
Accept: application/json;q=1.0, application/xml;q=0.8, text/plain;q=0.5
Accept-Language: uk;q=1.0, en;q=0.8
Accept-Encoding: br, gzip, deflate

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Language: uk
Content-Encoding: br
Vary: Accept, Accept-Language, Accept-Encoding

HTTP/1.1 406 Not Acceptable
Content-Type: application/problem+json

{
  "title": "Not Acceptable",
  "detail": "Сервер підтримує тільки application/json і application/xml"
}

using System.Net.Http;
using System.Net.Http.Headers;

using var client = new HttpClient { BaseAddress = new Uri("https://httpbingo.org/") };

// Явно вказати бажані формати з пріоритетами
// httpbingo.org/get — відображає заголовки запиту (для перевірки content negotiation)
var request = new HttpRequestMessage(HttpMethod.Get, "get");

request.Headers.Accept.Clear();
request.Headers.Accept.Add(
    new MediaTypeWithQualityHeaderValue("application/json") { Quality = 1.0 }
);
request.Headers.Accept.Add(
    new MediaTypeWithQualityHeaderValue("application/xml") { Quality = 0.8 }
);

// Мова
request.Headers.AcceptLanguage.Add(
    new StringWithQualityHeaderValue("uk") { Quality = 1.0 }
);
request.Headers.AcceptLanguage.Add(
    new StringWithQualityHeaderValue("en") { Quality = 0.8 }
);

HttpResponseMessage response = await client.SendAsync(request);

Console.WriteLine($"Content-Type: {response.Content.Headers.ContentType}");
Console.WriteLine($"Content-Language: {response.Headers.GetValues("Content-Language").FirstOrDefault()}");
Console.WriteLine($"Content-Encoding: {response.Content.Headers.ContentEncoding.FirstOrDefault()}");

using System.IO.Compression;
using System.Net;
using System.Net.Http;

// HttpClientHandler підтримує автоматичну деcompression
var handler = new HttpClientHandler
{
    AutomaticDecompression = DecompressionMethods.GZip
                           | DecompressionMethods.Deflate
                           | DecompressionMethods.Brotli
};

// Автоматично додає: Accept-Encoding: gzip, deflate, br
// Автоматично розпаковує відповідь — прозоро для коду
using var client = new HttpClient(handler);

// httpbingo.org/gzip — завжди повертає gzip-стиснений JSON
HttpResponseMessage response = await client.GetAsync("https://httpbingo.org/gzip");

Console.WriteLine($"Content-Length: {response.Content.Headers.ContentLength}"); // може бути null при chunked
string content = await response.Content.ReadAsStringAsync(); // вже розпаковано
Console.WriteLine($"Розпакований розмір: {content.Length} символів");

fetch('https://api.example.com/me', {
    credentials: 'include', // відправити cookies та Authorization
})

Access-Control-Allow-Origin: https://app.example.com
Access-Control-Allow-Credentials: true

using System.Net.Http;

// HttpClient не має ніяких CORS обмежень — це суто браузерна функція
using var client = new HttpClient();

// httpbingo.org підтримує CORS — повертає Access-Control-Allow-Origin
// Емуляція cross-origin запиту з Origin заголовком
var request = new HttpRequestMessage(HttpMethod.Get, "https://httpbingo.org/get");
request.Headers.Add("Origin", "https://app.other-domain.com");

HttpResponseMessage response = await client.SendAsync(request);

// Переглянути CORS заголовки відповіді
if (response.Headers.TryGetValues("Access-Control-Allow-Origin", out var origins))
    Console.WriteLine($"Allowed Origin: {string.Join(", ", origins)}");

if (response.Headers.TryGetValues("Access-Control-Allow-Methods", out var methods))
    Console.WriteLine($"Allowed Methods: {string.Join(", ", methods)}");

// Перевірка preflight вручну
var preflight = new HttpRequestMessage(HttpMethod.Options, "https://httpbingo.org/get");
preflight.Headers.Add("Origin", "https://app.other-domain.com");
preflight.Headers.Add("Access-Control-Request-Method", "PUT");
preflight.Headers.Add("Access-Control-Request-Headers", "Authorization, Content-Type");

HttpResponseMessage preflightResp = await client.SendAsync(preflight);
Console.WriteLine($"Preflight: {preflightResp.StatusCode}");
if (preflightResp.Headers.TryGetValues("Access-Control-Max-Age", out var maxAge))
    Console.WriteLine($"Preflight кешується: {string.Join(", ", maxAge)} секунд");

using System.Net;
using System.Net.Http;

// HttpClient за замовчуванням автоматично слідує редиректам (до 50)
using var autoClient = new HttpClient();
// AllowAutoRedirect = true за замовчуванням

// Вимкнути автоматичні редиректи:
var handler = new HttpClientHandler { AllowAutoRedirect = false };
using var manualClient = new HttpClient(handler);

HttpResponseMessage response = await manualClient.GetAsync("https://httpbingo.org/absolute-redirect/2");

while (response.StatusCode is HttpStatusCode.MovedPermanently
                           or HttpStatusCode.Found
                           or HttpStatusCode.SeeOther
                           or HttpStatusCode.TemporaryRedirect
                           or HttpStatusCode.PermanentRedirect)
{
    Uri? newLocation = response.Headers.Location;
    if (newLocation is null) break;

    // Якщо URL відносний — перетворимо на абсолютний
    if (!newLocation.IsAbsoluteUri)
        newLocation = new Uri(new Uri("https://httpbingo.org"), newLocation);

    // Валідація: чи це очікуваний домен?
    if (newLocation.Host != "httpbingo.org")
    {
        Console.WriteLine($"⚠ Підозрілий редирект на: {newLocation}");
        break;
    }

    Console.WriteLine($"→ Редирект {(int)response.StatusCode}: {newLocation}");
    var method = response.StatusCode == HttpStatusCode.SeeOther
        ? HttpMethod.Get // 303 завжди GET
        : HttpMethod.Get; // спрощено; реально — зберегти оригінальний

    response = await manualClient.GetAsync(newLocation);
}

Console.WriteLine($"Фінальна відповідь: {response.StatusCode}");

// Storage/TokenStorage.cs
namespace AuthClient.Storage;

public sealed class TokenStorage
{
    private string? _accessToken;
    private string? _refreshToken;
    private DateTime _expiresAt;

    // 30-секундний буфер щоб не надсилати майже-протухлий токен
    public bool IsExpired =>
        _accessToken is null || DateTime.UtcNow >= _expiresAt.AddSeconds(-30);

    public string? AccessToken => _accessToken;
    public string? RefreshToken => _refreshToken;

    public void Store(string access, string refresh, int expiresInSeconds)
    {
        _accessToken = access;
        _refreshToken = refresh;
        _expiresAt = DateTime.UtcNow.AddSeconds(expiresInSeconds);
    }

    public void Clear()
    {
        _accessToken = null;
        _refreshToken = null;
        _expiresAt = default;
    }
}

// Handlers/AuthHandler.cs
namespace AuthClient.Handlers;

using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using AuthClient.Storage;

public sealed class AuthHandler(TokenStorage storage, IHttpClientFactory factory)
    : DelegatingHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken ct)
    {
        // Пропускаємо login/refresh — вони не потребують Bearer токену
        string? path = request.RequestUri?.AbsolutePath;
        bool isPublicEndpoint = path?.EndsWith("/login") == true
                             || path?.EndsWith("/refresh") == true;
        if (isPublicEndpoint)
            return await base.SendAsync(request, ct);

        // Токен протух — оновлюємо ПЕРЕД відправкою запиту
        if (storage.IsExpired && storage.RefreshToken is not null)
            await RefreshTokenAsync(ct);

        // Прикріплюємо актуальний токен
        if (storage.AccessToken is not null)
            request.Headers.Authorization =
                new AuthenticationHeaderValue("Bearer", storage.AccessToken);

        HttpResponseMessage response = await base.SendAsync(request, ct);

        // 401 — сервер відхилив токен → спробувати refresh і повторити
        if (response.StatusCode == HttpStatusCode.Unauthorized
            && storage.RefreshToken is not null)
        {
            bool refreshed = await RefreshTokenAsync(ct);
            if (refreshed)
            {
                var retryRequest = await CloneRequestAsync(request);
                retryRequest.Headers.Authorization =
                    new AuthenticationHeaderValue("Bearer", storage.AccessToken!);

                response = await base.SendAsync(retryRequest, ct);
            }
        }

        // Якщо знову 401 — всі токени недійсні
        if (response.StatusCode == HttpStatusCode.Unauthorized)
            storage.Clear();

        return response;
    }

    private async Task<bool> RefreshTokenAsync(CancellationToken ct)
    {
        using var refreshClient = factory.CreateClient("Auth");

        var body = new { refreshToken = storage.RefreshToken, expiresInMins = 30 };
        HttpResponseMessage response = await refreshClient.PostAsJsonAsync("auth/refresh", body, ct);

        if (!response.IsSuccessStatusCode)
        {
            storage.Clear();
            return false;
        }

        var result = await response.Content.ReadFromJsonAsync<TokenResponse>(ct);
        if (result is null) return false;

        // ExpiresIn не повертається dummyjson, використовуємо стандарт 1800с
        storage.Store(result.AccessToken, result.RefreshToken, result.ExpiresIn > 0 ? result.ExpiresIn : 1800);
        return true;
    }

    private static async Task<HttpRequestMessage> CloneRequestAsync(HttpRequestMessage original)
    {
        var clone = new HttpRequestMessage(original.Method, original.RequestUri);
        clone.Version = original.Version;

        foreach (var header in original.Headers)
            clone.Headers.TryAddWithoutValidation(header.Key, header.Value);

        if (original.Content is not null)
        {
            byte[] content = await original.Content.ReadAsByteArrayAsync();
            clone.Content = new ByteArrayContent(content);

            foreach (var header in original.Content.Headers)
                clone.Content.Headers.TryAddWithoutValidation(header.Key, header.Value);
        }

        return clone;
    }
}

record TokenResponse(string AccessToken, string RefreshToken, int ExpiresIn = 1800);

// Program.cs
using Microsoft.Extensions.DependencyInjection;
using AuthClient.Handlers;
using AuthClient.Storage;
using System.Net.Http.Json;

var services = new ServiceCollection();
var tokenStorage = new TokenStorage();

services.AddSingleton(tokenStorage);
services.AddTransient<AuthHandler>();

// "Auth" клієнт — для auth-запитів (без AuthHandler!)
services.AddHttpClient("Auth", c =>
    c.BaseAddress = new Uri("https://dummyjson.com/"));

// "Api" клієнт — з AuthHandler у pipeline
services.AddHttpClient("Api", c =>
    c.BaseAddress = new Uri("https://dummyjson.com/"))
    .AddHttpMessageHandler<AuthHandler>();

var sp = services.BuildServiceProvider();
var factory = sp.GetRequiredService<IHttpClientFactory>();

// ── Логін ────────────────────────────────────────────────────────────────────
var authClient = factory.CreateClient("Auth");
// dummyjson.com: POST /auth/login {username, password}
var loginBody = new { username = "emilys", password = "emilyspass", expiresInMins = 30 };
var loginResp = await authClient.PostAsJsonAsync("auth/login", loginBody);

if (loginResp.IsSuccessStatusCode)
{
    var tokens = await loginResp.Content.ReadFromJsonAsync<TokenResponse>();
    int expiresIn = tokens!.ExpiresIn > 0 ? tokens.ExpiresIn : 1800;
    tokenStorage.Store(tokens!.AccessToken, tokens.RefreshToken, expiresIn);
    Console.WriteLine("✅ Аутентифікація успішна");
}

// ── Захищені запити — Bearer token додається автоматично ──────────────────────
var apiClient = factory.CreateClient("Api");

// GET /auth/me — профіль поточного користувача (dummyjson перевіряє Bearer)
var profile = await apiClient.GetAsync("auth/me");
Console.WriteLine($"Profile: {profile.StatusCode}");

// GET /auth/carts — кошики поточного користувача (dummyjson protected endpoint)
var carts = await apiClient.GetAsync("auth/carts");
Console.WriteLine($"Carts: {carts.StatusCode}");

record TokenResponse(string AccessToken, string RefreshToken, int ExpiresIn = 1800);

dotnet new console -n HttpPlayground
cd HttpPlayground
dotnet run

// HttpPlayground — демонстрація HTTP Advanced з реальними API
// Запуск: dotnet new console -n HttpPlayground && cd HttpPlayground && dotnet run

using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;

Console.OutputEncoding = Encoding.UTF8;

// ════════════════════════════════════════════════════════════════════════════
// 1. JWT АУТЕНТИФІКАЦІЯ — dummyjson.com
// ════════════════════════════════════════════════════════════════════════════
Console.WriteLine("═══ 1. JWT Authentication (dummyjson.com) ═══");

using var jwtClient = new HttpClient { BaseAddress = new Uri("https://dummyjson.com/") };

// POST /auth/login → справжній JWT access + refresh token
var loginResp = await jwtClient.PostAsJsonAsync("auth/login", new
{
    username = "emilys",
    password = "emilyspass",
    expiresInMins = 30
});
loginResp.EnsureSuccessStatusCode();

var tokenData = await loginResp.Content.ReadFromJsonAsync<JsonElement>();
string accessToken = tokenData.GetProperty("accessToken").GetString()!;
string refreshToken = tokenData.GetProperty("refreshToken").GetString()!;
Console.WriteLine($"✅ JWT отримано: {accessToken[..40]}...");

// Декодуємо payload (Base64URL) — демонстрація структури JWT без перевірки підпису
string[] parts = accessToken.Split('.');
string payloadJson = Encoding.UTF8.GetString(Convert.FromBase64String(PadBase64(parts[1])));
var payload = JsonDocument.Parse(payloadJson).RootElement;
Console.WriteLine($"   sub (id):  {payload.GetProperty("id")}");
Console.WriteLine($"   username:  {payload.GetProperty("username").GetString()}");

// Захищений запит — GET /auth/me з Bearer токеном
jwtClient.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", accessToken);

var meResp = await jwtClient.GetAsync("auth/me");
meResp.EnsureSuccessStatusCode();
var me = await meResp.Content.ReadFromJsonAsync<JsonElement>();
Console.WriteLine($"   Профіль:   {me.GetProperty("firstName")} {me.GetProperty("lastName")}");
Console.WriteLine($"   Email:     {me.GetProperty("email")}");

// Оновлення токену через Refresh Token
var refreshResp = await jwtClient.PostAsJsonAsync("auth/refresh",
    new { refreshToken, expiresInMins = 30 });
var newTokens = await refreshResp.Content.ReadFromJsonAsync<JsonElement>();
Console.WriteLine($"✅ Токен оновлено: {newTokens.GetProperty("accessToken").GetString()![..40]}...");

// ════════════════════════════════════════════════════════════════════════════
// 2. COOKIE MANAGEMENT — httpbingo.org
// ════════════════════════════════════════════════════════════════════════════
Console.WriteLine("\n═══ 2. Cookie Management (httpbingo.org) ═══");

var cookieContainer = new CookieContainer();
var cookieHandler = new HttpClientHandler { CookieContainer = cookieContainer };
using var cookieClient = new HttpClient(cookieHandler)
{
    BaseAddress = new Uri("https://httpbingo.org/")
};

// /cookies/set встановлює cookie через 302-редирект
// CookieContainer автоматично слідує і зберігає Set-Cookie
await cookieClient.GetAsync("cookies/set?session=token_xyz123");
await cookieClient.GetAsync("cookies/set?theme=dark");

var storedCookies = cookieContainer.GetCookies(new Uri("https://httpbingo.org/"));
Console.WriteLine($"✅ CookieContainer має {storedCookies.Count} cookies:");
foreach (Cookie c in storedCookies)
    Console.WriteLine($"   {c.Name}={c.Value}  HttpOnly={c.HttpOnly}");

// CookieContainer автоматично надсилає cookies у наступних запитах
var cookiesResp = await cookieClient.GetAsync("cookies");
var cookieBody = await cookiesResp.Content.ReadFromJsonAsync<JsonElement>();
Console.Write("   httpbingo бачить: ");
foreach (var prop in cookieBody.GetProperty("cookies").EnumerateObject())
    Console.Write($"{prop.Name}={prop.Value}  ");
Console.WriteLine();

// ════════════════════════════════════════════════════════════════════════════
// 3. BASIC AUTH — httpbingo.org
// ════════════════════════════════════════════════════════════════════════════
Console.WriteLine("\n═══ 3. Basic Auth (httpbingo.org) ═══");

using var basicClient = new HttpClient();

// Невірні облікові дані → 401 Unauthorized
var wrongReq = new HttpRequestMessage(HttpMethod.Get,
    "https://httpbingo.org/basic-auth/alice/secret");
wrongReq.Headers.Authorization = new AuthenticationHeaderValue(
    "Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("alice:wrong")));
var wrongResp = await basicClient.SendAsync(wrongReq);
Console.WriteLine($"✅ Невірний пароль: {wrongResp.StatusCode}");

// Правильні облікові дані → 200 OK
var rightReq = new HttpRequestMessage(HttpMethod.Get,
    "https://httpbingo.org/basic-auth/alice/secret");
rightReq.Headers.Authorization = new AuthenticationHeaderValue(
    "Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("alice:secret")));
var rightResp = await basicClient.SendAsync(rightReq);
var authBody = await rightResp.Content.ReadFromJsonAsync<JsonElement>();
Console.WriteLine($"✅ Правильні дані: {rightResp.StatusCode}, authenticated={authBody.GetProperty("authenticated")}");

// ════════════════════════════════════════════════════════════════════════════
// 4. ETAG CACHING — httpbingo.org
// ════════════════════════════════════════════════════════════════════════════
Console.WriteLine("\n═══ 4. ETag Caching (httpbingo.org) ═══");

using var cacheClient = new HttpClient { BaseAddress = new Uri("https://httpbingo.org/") };

// Перший запит — отримуємо ETag
var firstResp = await cacheClient.GetAsync("etag/v7-product-list");
string etag = firstResp.Headers.ETag?.Tag ?? "";
long firstSize = (await firstResp.Content.ReadAsByteArrayAsync()).Length;
Console.WriteLine($"✅ GET /etag/v7-product-list: {firstResp.StatusCode}, ETag={etag}, {firstSize} байт");

// Conditional GET — If-None-Match: якщо ресурс не змінився → 304 (0 байт тіла)
var condReq = new HttpRequestMessage(HttpMethod.Get, "etag/v7-product-list");
condReq.Headers.IfNoneMatch.Add(new EntityTagHeaderValue(etag));
var condResp = await cacheClient.SendAsync(condReq);
Console.WriteLine($"✅ Conditional GET: {condResp.StatusCode} " +
    $"— тіло {(condResp.StatusCode == HttpStatusCode.NotModified ? "відсутнє (0 байт!)" : "отримано")}");

// ════════════════════════════════════════════════════════════════════════════
// 5. COMPRESSION — httpbingo.org
// ════════════════════════════════════════════════════════════════════════════
Console.WriteLine("\n═══ 5. Compression (httpbingo.org) ═══");

var compHandler = new HttpClientHandler
{
    AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
};
using var compClient = new HttpClient(compHandler);

// /gzip — завжди повертає gzip-стиснений JSON
var gzipResp = await compClient.GetAsync("https://httpbingo.org/gzip");
string gzipBody = await gzipResp.Content.ReadAsStringAsync();
Console.WriteLine($"✅ GZIP: {gzipResp.StatusCode}, розпаковано {gzipBody.Length} символів");

Console.WriteLine("\n═══ Готово! Всі 5 концепцій продемонстровано. ═══");

// ── Допоміжна функція ────────────────────────────────────────────────────────
static string PadBase64(string base64Url)
{
    string base64 = base64Url.Replace('-', '+').Replace('_', '/');
    return base64.Length % 4 switch
    {
        2 => base64 + "==",
        3 => base64 + "=",
        _ => base64
    };
}