var client = new Client("FAUNA_SECRET");

// Scoped key that impersonates an `admin` key for
// the `childDB` child database.
fn...:childDB:admin

var client = new Client("fn...:childDB:admin");

// Create a native var
var collectionName = "Product";

// Pass the var to an FQL query
var query = FQL($@"
    let collection = Collection({collectionName})
    collection.byName('cups').first() {{ price }}"
);

client.QueryAsync(query);

// Create a reusable query fragment.
var product = FQL($@"Product.byName(""pizza"").first()");

// Use the fragment in another FQL query.
var query = FQL($@"
    let product = {product}
    product {{
        name,
        price
    }}
");

client.QueryAsync(query);

using Fauna.Mapping;

class Category
{
    // Property names are automatically converted to camelCase.
    [Id]
    public string? Id { get; set; }

    // Manually specify a name by providing a string.
    [Field("name")]
    public string? CatName { get; set; }
}

class Product
{
    [Id]
    public string? Id { get; set; }

    public string? Name { get; set; }

    public string? Description { get; set; }

    public int Price { get; set; }

    // Reference to document
    public Ref<Category> Category { get; set; }
}

var query = FQL($@"Product.sortedByPriceLowToHigh()");
var products = client.PaginateAsync<Product>(query).FlattenAsync();

await foreach (var p in products)
{
    Console.WriteLine($"{p.Name} {p.Description} {p.Price}");
}

var product = new Product {
    Id = "12345",
    Name = "limes",
    Description = "Organic, 2 ct",
    Price = 95
};

client.QueryAsync(FQL($@"Product.create({product})"));

class CustomerDb : DataContext
{
    public class CustomerCollection : Collection<Customer>
    {
        public Index<Customer> ByEmail(string email) => Index().Call(email);
        public Index<Customer> ByName(string name) => Index().Call(name);
    }

    public CustomerCollection Customer { get => GetCollection<CustomerCollection>(); }
}

var db = client.DataContext<CustomerDb>

var result = db.QueryAsync(FQL($"Customer.all().first()"));
var customer = (Customer)result.Data!;

Console.WriteLine(customer.name);

// General query.
var cust = db.Customer
        .Where(c => c.Email == "alice.appleseed@example.com")
        .Select(p => new { c.Name, c.Email })
        .First();

// Or start with an index:
var custViaIndex = db.Customer.byEmail("alice.appleseed@example.com")
        .Select(c => new { p.Name, p.Email })
        .First();

// Query without projecting document references.
var product = db.Product.Where(p => p.Name == "limes")
        .First();
// product.Category contains a document reference
// but the referenced document is not loaded.

// Query with projection to load the referenced document.
var productWithCategory = db.Product.Where(p => p.Name == "limes")
        .Select(p => new {
            p.Name
            Category = new { p.Category.Get().Name }
        })
        .First();
// productWithCategory.Category.Name contains the category's name.

var syncCount = db.Customer.Count();
var asyncCount = await db.Customer.CountAsync();

var query = FQL($"Customer.all()");
await foreach (var page in client.PaginateAsync<Customer>(query))
{
    // handle each page
}

await foreach (var item in client.PaginateAsync<Customer>(query).FlattenAsync())
{
    // handle each item
}

class MyResult
{
    [Field("customers")]
    public Page<Customer>? Customers { get; set; }
}

var query = FQL($"{{customers: Customer.all()}}");
var result = await client.QueryAsync<MyResult>(query);

await foreach (var page in client.PaginateAsync(result.Data.Customers!))
{
    // handle each page
}

await foreach (var item in client.PaginateAsync(result.Data.Customers!).FlattenAsync())
{
    // handle each item
}

try
{
    var client = new Client("FAUNA_SECRET");

    var query = FQL($@"'Hello world'");
    var response = await client.QueryAsync<string>(query);

    Console.WriteLine(response.Stats.ToString());
}
catch (FaunaException e)
{
  if (e is ServiceException serviceException)
  {
    Console.WriteLine(serviceException.Stats.ToString());
    Console.WriteLine(e);
  }
  else {
    Console.WriteLine(e);
  }
}

export FAUNA_SECRET=FAUNA_SECRET
export FAUNA_ENDPOINT=https://db.fauna.com/

var client = new Client();

var config = new Configuration("FAUNA_SECRET")
{
    RetryConfiguration = new RetryConfiguration(3, TimeSpan.FromSeconds(20))
};

var client = new Client(config);

var query = fql($@"
  let set = Customer.all()

  {{
    initialPage: set.pageSize(10),
    streamToken: set.toStream()
  }}
");

var response = await client.QueryAsync(query);
var streamToken = response["streamToken"].ToString();

await using var stream = client.SubscribeStream<Customer>(streamToken);
await foreach (var evt in stream)
{
    Console.WriteLine($"Received Event Type: {evt.Type}");
    if (evt.Data != null) // Status events won't have Data
    {
        Customer customer = evt.Data;
        Console.WriteLine($"Name: {customer.Name} - Email: {customer.Email}");
    }
}

var stream = await client.EventStreamAsync<Customer>(FQL($"Customer.all().toStream()"));
await foreach (var evt in stream)
{
    Console.WriteLine($"Received Event Type: {evt.Type}");
    if (evt.Data != null)
    {
        Customer customer = evt.Data;
        Console.WriteLine($"Name: {customer.Name} - Email: {customer.Email}");
    }
}

var options = new StreamOptions(
    token: "<STREAM_TOKEN>",
    cursor: "gsGghu789"
);

var stream = await client.EventStreamAsync<Customer>(
    query: FQL("Product.all().toStream()"),
    streamOptions: options
);

await foreach (var evt in stream)
{
    Console.WriteLine($"Received Event Type: {evt.Type}");
    if (evt.Data != null)
    {
        Customer customer = evt.Data;
        Console.WriteLine($"Name: {customer.Name} - Email: {customer.Email}");
    }
}