var result = await CurlDotNet
    .Create("https://api.example.com/data")
    .WithHeader("Accept", "application/json")
    .SendAsync();

// Paste your curl command directly
var response = await Curl
    .Parse(@"curl -X POST https://api.stripe.com/v1/charges \
             -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
             -d amount=2000")
    .SendAsync();

// Mock it for testing
var mockCurl = new Mock<ICurlDotNet>();
mockCurl.Setup(x => x.SendAsync())
        .ReturnsAsync(new CurlResponse { StatusCode = 200 });

// Traditional HttpClient - 15 lines for a simple request
using var handler = new HttpClientHandler();
handler.ServerCertificateCustomValidationCallback = 
    (sender, cert, chain, errors) => true;
using var client = new HttpClient(handler);
client.DefaultRequestHeaders.Add("Accept", "application/json");
client.DefaultRequestHeaders.Add("User-Agent", "MyApp/1.0");
client.DefaultRequestHeaders.Authorization = 
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "token123");
var content = new StringContent(
    JsonSerializer.Serialize(new { name = "test" }), 
    Encoding.UTF8, 
    "application/json"
);
var response = await client.PostAsync("https://api.example.com/users", content);
var result = await response.Content.ReadAsStringAsync();

// CurlDotNet - 3 lines for the same request
var response = await Curl
    .Parse(@"curl -X POST https://api.example.com/users \
             -H 'Authorization: Bearer token123' \
             -H 'Accept: application/json' \
             -H 'User-Agent: MyApp/1.0' \
             -k \
             -d '{""name"":""test""}'")
    .SendAsync();

// Basic Auth (like curl -u username:password)
var response = await Curl
    .Get("https://api.example.com")
    .WithBasicAuth("username", "password")
    .SendAsync();

// Bearer Token - JWT and OAuth2 ready
var response = await Curl
    .Get("https://api.example.com")
    .WithBearerToken("your-jwt-token")
    .SendAsync();

// API Key - Any header, any format
var response = await Curl
    .Get("https://api.example.com")
    .WithHeader("X-API-Key", "your-api-key")
    .SendAsync();

// Client Certificates
var response = await Curl
    .Get("https://secure-api.example.com")
    .WithCertificate("client.pfx", "password")
    .SendAsync();

// Upload files (multipart/form-data)
// Like: curl -F "file=@photo.jpg" -F "name=profile" https://api.example.com/upload
var response = await Curl
    .Post("https://api.example.com/upload")
    .WithFile("file", "photo.jpg", File.ReadAllBytes("photo.jpg"))
    .WithFormField("name", "profile")
    .WithFormField("description", "Profile photo upload")
    .SendAsync();

// Download with progress
var response = await Curl
    .Get("https://cdn.example.com/large-file.zip")
    .WithProgressCallback((bytes, total) => 
        Console.WriteLine($"Downloaded {bytes}/{total} bytes"))
    .SaveTo("downloads/file.zip")
    .SendAsync();

// Follow redirects automatically
// Like: curl -L https://bit.ly/shortlink
var response = await Curl
    .Get("https://bit.ly/shortlink")
    .FollowRedirects()
    .MaxRedirects(10)
    .SendAsync();

// Proxy with authentication
// Like: curl --proxy http://proxy:8080 --proxy-user user:pass https://api.example.com
var response = await Curl
    .Get("https://api.example.com")
    .WithProxy("http://proxy:8080", "username", "password")
    .SendAsync();

// Custom DNS resolution
var response = await Curl
    .Get("https://api.example.com")
    .ResolveDns("api.example.com", "192.168.1.100")
    .SendAsync();

// Timeout and retry logic
// Like: curl --max-time 30 --retry 3 https://api.example.com
var response = await Curl
    .Get("https://api.example.com")
    .WithTimeout(TimeSpan.FromSeconds(30))
    .WithRetry(3, TimeSpan.FromSeconds(1))
    .WithExponentialBackoff()
    .SendAsync();

// Circuit breaker pattern
var response = await Curl
    .Get("https://api.example.com")
    .WithCircuitBreaker(5, TimeSpan.FromMinutes(1))
    .SendAsync();

// GitHub API example
var curl = @"curl -H 'Accept: application/vnd.github.v3+json' \
             -H 'Authorization: token OAUTH-TOKEN' \
             https://api.github.com/user/repos \
             -d '{""name"":""Hello-World"",""description"":""This is your first repo!""}'";

var response = await Curl.Parse(curl).SendAsync();

// Generate reusable C# code
var code = Curl.Parse(curl).ToCode();
Console.WriteLine(code);
// Output: Complete C# implementation you can customize

// Old way - WebClient
using var client = new WebClient();
client.DownloadFile("https://example.com/file.zip", "file.zip");
// No resume support. No recursive downloads. No mirroring.

// Current way - HttpClient  
using var client = new HttpClient();
using var response = await client.GetAsync("https://example.com/file.zip");
using var fs = new FileStream("file.zip", FileMode.Create);
await response.Content.CopyToAsync(fs);
// Still no resume. Still no recursive. Still complex.

// WgetDotNet - The wget you know and love
await Wget
    .Download("https://example.com/file.zip")
    .Resume()  // Resume partial downloads automatically
    .WithProgressBar()  // Built-in progress reporting
    .SaveAs("downloads/file.zip")
    .ExecuteAsync();

// Mirror entire websites for offline browsing
await Wget
    .Mirror("https://docs.example.com")
    .WithDepth(3)  // Follow links 3 levels deep
    .ConvertLinksForOffline()  // Make it browseable offline
    .ExcludeDirectories("/api", "/admin")
    .SaveTo("offline-docs/")
    .ExecuteAsync();

// Download with smart retry and bandwidth management
await Wget
    .Download("https://cdn.example.com/large-file.iso")
    .LimitBandwidth("500k")  // Limit to 500KB/s
    .Retry(5)  // Retry failed downloads
    .WaitBetweenRetries(TimeSpan.FromSeconds(10))
    .Timeout(TimeSpan.FromMinutes(30))
    .ExecuteAsync();

// Recursive download with filters
await Wget
    .Download("https://archive.org/details/manuscripts")
    .Recursive()
    .AcceptExtensions(".pdf", ".epub", ".mobi")
    .RejectPatterns("*draft*", "*temp*")
    .MaxSize("100M")  // Skip files larger than 100MB
    .ExecuteAsync();

// Coming with PipelineDotNet - Compose Linux commands naturally
var result = await Pipeline
    .Start(Curl.Get("https://api.github.com/repos/microsoft/dotnet"))
    .Pipe(Jq.Parse(".stargazers_count"))
    .Pipe(Awk.Print("Stars: $1"))
    .ExecuteAsync();

// Real-world data processing pipeline
await Pipeline
    .Start(Wget.Download("https://data.gov/census.tar.gz"))
    .Pipe(Tar.Extract())
    .Pipe(Grep.Match("population"))
    .Pipe(Awk.Sum("$2"))
    .Pipe(Curl.Post("https://analytics.example.com/ingest"))
    .ExecuteAsync();

// API aggregation pipeline
var results = await Pipeline
    .Start(Curl.Get("https://api1.example.com/data"))
    .Parallel(
        Curl.Get("https://api2.example.com/data"),
        Curl.Get("https://api3.example.com/data")
    )
    .Pipe(Jq.Merge())
    .Pipe(Gzip.Compress())
    .SaveTo("aggregated-data.json.gz")
    .ExecuteAsync();

using CurlDotNet;

var response = await Curl
    .Get("https://api.github.com/users/octocat")
    .WithHeader("Accept", "application/json")
    .SendAsync();

Console.WriteLine(response.Body);

var response = await Curl
    .Parse(@"curl -X POST https://api.example.com/v1/users \
             -H 'Content-Type: application/json' \
             -d '{""name"":""John""}'")
    .SendAsync();

var request = new CurlBuilder()
    .WithMethod(HttpMethod.Post)
    .WithUrl("https://api.example.com/users")
    .WithJsonBody(new { name = "John" })
    .WithTimeout(TimeSpan.FromSeconds(30))
    .Build();

var response = await request.SendAsync();

// Startup.cs or Program.cs
services.AddCurlDotNet(options =>
{
    options.DefaultTimeout = TimeSpan.FromSeconds(30);
    options.EnableLogging = true;
    options.EnableMetrics = true;
    options.AddInterceptor<AuthenticationInterceptor>();
    options.AddInterceptor<LoggingInterceptor>();
});

// Your service
public class ApiService
{
    private readonly ICurlDotNet _curl;
    
    public ApiService(ICurlDotNet curl)
    {
        _curl = curl;
    }
    
    public async Task<User> GetUserAsync(int id)
    {
        var response = await _curl
            .Get($"https://api.example.com/users/{id}")
            .SendAsync();
            
        return response.Deserialize<User>();
    }
}

[Test]
public async Task Should_Authenticate_User()
{
    // Arrange
    var mockCurl = new Mock<ICurlDotNet>();
    mockCurl
        .Setup(x => x.Post("https://api.example.com/auth")
                     .WithJsonBody(It.IsAny<object>())
                     .SendAsync())
        .ReturnsAsync(new CurlResponse 
        { 
            StatusCode = 200,
            Body = "{\"token\":\"abc123\"}"
        });
    
    var service = new AuthService(mockCurl.Object);
    
    // Act
    var token = await service.AuthenticateAsync("user", "pass");
    
    // Assert
    Assert.AreEqual("abc123", token);
    mockCurl.Verify(x => x.Post(It.IsAny<string>()), Times.Once);
}

// Record API calls for testing
services.AddCurlDotNet(options =>
{
    options.EnableRecording("recordings/api-calls.json");
});

// Replay in tests
var responses = CurlRecording.Load("recordings/api-calls.json");
var mockCurl = new MockCurl(responses);

// DANGEROUS - Shell injection vulnerability
var url = GetUrlFromUser();  // User inputs: "; rm -rf /"
Process.Start("curl", url);  // Disaster!

// SAFE - No shell execution
var url = GetUrlFromUser();  // User inputs anything
await Curl.Get(url).SendAsync();  // Safe, validated, secure