Platform Support

var db = new WitDatabaseBuilder()
    .WithFilePath("app.witdb")
    .WithBTree()
    .WithTransactions()
    .Build();

var db = new WitDatabaseBuilder()
    .WithIndexedDbStorage("MyApp", JSRuntime)
    .WithBTree()
    .WithBouncyCastleEncryption("password")  // ChaCha20 for WASM
    .Build();
await db.InitializeAsync();

var dbPath = Path.Combine(FileSystem.AppDataDirectory, "app.witdb");
var db = new WitDatabaseBuilder()
    .WithFilePath(dbPath)
    .WithBTree()
    .WithEncryption("password")
    .Build();

// Windows desktop app
var dbPath = Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
    "MyApp",
    "data.witdb"
);

var db = new WitDatabaseBuilder()
    .WithFilePath(dbPath)
    .WithBTree()
    .WithEncryption("password")  // AES-GCM, hardware accelerated
    .WithTransactions()
    .Build();

// Linux server
var dbPath = "/var/lib/myapp/data.witdb";

var db = new WitDatabaseBuilder()
    .WithFilePath(dbPath)
    .WithBTree()
    .WithEncryption("password")  // AES-GCM on x64
    .WithTransactions()
    .Build();

FROM mcr.microsoft.com/dotnet/aspnet:9.0

WORKDIR /app
COPY --from=build /app/publish .

# Create data directory
RUN mkdir -p /data && chown -R app:app /data
VOLUME /data

ENV DB_PATH=/data/app.witdb

ENTRYPOINT ["dotnet", "MyApp.dll"]

// In app
var dbPath = Environment.GetEnvironmentVariable("DB_PATH") ?? "/data/app.witdb";

// macOS app
var dbPath = Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
    "MyApp",
    "data.witdb"
);

var db = new WitDatabaseBuilder()
    .WithFilePath(dbPath)
    .WithBTree()
    .WithEncryption("password")  // AES-GCM on both Intel and M-series
    .WithTransactions()
    .Build();

"Data Source=/var/lib/myapp/prod.witdb;Encryption=aes-gcm;Password=<from-secrets>;Cache Size=10000;MVCC=true;Isolation Level=Snapshot"

// Program.cs
builder.Services.AddDbContext<AppDbContext>(options =>
{
    var connStr = builder.Configuration.GetConnectionString("WitDb");
    options.UseWitDb(connStr);
});

// appsettings.json
{
  "ConnectionStrings": {
    "WitDb": "Data Source=/data/app.witdb;Encryption=aes-gcm;Password=${DB_PASSWORD}"
  }
}

<PackageReference Include="OutWit.Database.Core.IndexedDb" Version="1.0.0" />
<PackageReference Include="OutWit.Database.Core.BouncyCastle" Version="1.0.0" />

<script src="_content/OutWit.Database.Core.IndexedDb/witdb-indexeddb.js"></script>
<script src="_content/OutWit.Database.Core.IndexedDb/witdb-indexeddb-index.js"></script>

@page "/data"
@inject IJSRuntime JSRuntime
@using OutWit.Database.Core.Builder
@using OutWit.Database.Core.IndexedDb
@using OutWit.Database.Core.BouncyCastle

@code {
    private WitDatabase? _db;
    
    protected override async Task OnInitializedAsync()
    {
        _db = new WitDatabaseBuilder()
            .WithIndexedDbStorage("MyAppDatabase", JSRuntime)
            .WithBTree()
            .WithTransactions()
            .Build();
        
        // Must initialize async in WASM
        await ((StorageIndexedDb)_db.Store).InitializeAsync();
    }
    
    private async Task SaveData(string key, byte[] value)
    {
        await _db!.PutAsync(Encoding.UTF8.GetBytes(key), value);
    }
    
    private async Task<byte[]?> LoadData(string key)
    {
        return await _db!.GetAsync(Encoding.UTF8.GetBytes(key));
    }
    
    public async ValueTask DisposeAsync()
    {
        if (_db != null)
        {
            await _db.FlushAsync();
            _db.Dispose();
        }
    }
}

_db = new WitDatabaseBuilder()
    .WithIndexedDbStorage("SecureApp", JSRuntime)
    .WithBTree()
    .WithBouncyCastleEncryptionFast("user", userPassword)  // ChaCha20, fast mode
    .WithTransactions()
    .Build();

// Services/DatabaseService.cs
public class DatabaseService : IAsyncDisposable
{
    private readonly IJSRuntime _jsRuntime;
    private WitDatabase? _db;
    
    public DatabaseService(IJSRuntime jsRuntime)
    {
        _jsRuntime = jsRuntime;
    }
    
    public async Task InitializeAsync(string? password = null)
    {
        var builder = new WitDatabaseBuilder()
            .WithIndexedDbStorage("MyApp", _jsRuntime)
            .WithBTree()
            .WithTransactions();
        
        if (!string.IsNullOrEmpty(password))
        {
            builder.WithBouncyCastleEncryption(password);
        }
        
        _db = builder.Build();
        await ((StorageIndexedDb)_db.Store).InitializeAsync();
    }
    
    public WitDatabase Database => _db 
        ?? throw new InvalidOperationException("Database not initialized");
    
    public async ValueTask DisposeAsync()
    {
        if (_db != null)
        {
            await _db.FlushAsync();
            _db.Dispose();
        }
    }
}

// Register in Program.cs
builder.Services.AddScoped<DatabaseService>();

<PackageReference Include="OutWit.Database.Core" Version="1.0.0" />
<!-- Or for SQL support -->
<PackageReference Include="OutWit.Database.AdoNet" Version="1.0.0" />
<!-- For ChaCha20 on older ARM devices -->
<PackageReference Include="OutWit.Database.Core.BouncyCastle" Version="1.0.0" />

// MauiProgram.cs
public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .ConfigureFonts(fonts =>
            {
                fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
            });
        
        // Register database service
        builder.Services.AddSingleton<IDatabaseService, DatabaseService>();
        
        return builder.Build();
    }
}

// Services/DatabaseService.cs
public interface IDatabaseService
{
    WitDatabase Database { get; }
    Task InitializeAsync();
}

public class DatabaseService : IDatabaseService, IDisposable
{
    private WitDatabase? _db;
    
    public WitDatabase Database => _db 
        ?? throw new InvalidOperationException("Database not initialized");
    
    public Task InitializeAsync()
    {
        var dbPath = Path.Combine(
            FileSystem.AppDataDirectory,  // Platform-appropriate location
            "app.witdb"
        );
        
        _db = new WitDatabaseBuilder()
            .WithFilePath(dbPath)
            .WithBTree()
            .WithEncryption("your-secure-password")
            .WithTransactions()
            .Build();
        
        return Task.CompletedTask;
    }
    
    public void Dispose()
    {
        _db?.Dispose();
    }
}

// FileSystem.AppDataDirectory resolves to:
// iOS:     /var/mobile/Containers/Data/Application/{GUID}/Library/
// Android: /data/data/{package-name}/files/
// Windows: C:\Users\{user}\AppData\Local\{app}\
// macOS:   /Users/{user}/Library/Containers/{bundle-id}/Data/Library/

// AES-GCM (hardware accelerated on modern devices)
var db = new WitDatabaseBuilder()
    .WithFilePath(dbPath)
    .WithBTree()
    .WithEncryption("password")  // AES-GCM
    .Build();

// ChaCha20 (faster on older ARM)
var db = new WitDatabaseBuilder()
    .WithFilePath(dbPath)
    .WithBTree()
    .WithBouncyCastleEncryption("password")  // ChaCha20
    .Build();

// App.xaml.cs
public partial class App : Application
{
    private readonly IDatabaseService _dbService;
    
    public App(IDatabaseService dbService)
    {
        InitializeComponent();
        _dbService = dbService;
        
        MainPage = new AppShell();
    }
    
    protected override async void OnStart()
    {
        await _dbService.InitializeAsync();
    }
}

// Flush on background/suspend
protected override void OnSleep()
{
    _dbService.Database.Flush();
}

// Mobile devices have limited memory
var db = new WitDatabaseBuilder()
    .WithFilePath(dbPath)
    .WithBTree()
    .WithCache(cacheSize: 500)  // Conservative for mobile
    .Build();

// iOS Data Protection is automatic for app container files
// WitDatabase encryption adds additional layer

public class OfflineRepository<T> where T : class, IEntity
{
    private readonly WitDatabase _db;
    private readonly string _tableName;
    
    public OfflineRepository(WitDatabase db, string tableName)
    {
        _db = db;
        _tableName = tableName;
    }
    
    public async Task SaveAsync(T entity)
    {
        var key = $"{_tableName}:{entity.Id}";
        var value = JsonSerializer.SerializeToUtf8Bytes(entity);
        await _db.PutAsync(Encoding.UTF8.GetBytes(key), value);
    }
    
    public async Task<T?> GetAsync(string id)
    {
        var key = $"{_tableName}:{id}";
        var value = await _db.GetAsync(Encoding.UTF8.GetBytes(key));
        return value != null 
            ? JsonSerializer.Deserialize<T>(value) 
            : null;
    }
    
    public async Task DeleteAsync(string id)
    {
        var key = $"{_tableName}:{id}";
        await _db.DeleteAsync(Encoding.UTF8.GetBytes(key));
    }
}

// Built-in, no extra package needed
var db = new WitDatabaseBuilder()
    .WithFilePath("secure.witdb")
    .WithEncryption("password")  // AES-GCM
    .Build();

// Requires OutWit.Database.Core.BouncyCastle
var db = new WitDatabaseBuilder()
    .WithIndexedDbStorage("SecureApp", JSRuntime)
    .WithBouncyCastleEncryptionFast("user", "password")  // ChaCha20, fast PBKDF2
    .Build();

public WitDatabaseBuilder ConfigureEncryption(WitDatabaseBuilder builder, string password)
{
    // Detect if we should use ChaCha20
    bool useChaCha20 = 
        OperatingSystem.IsBrowser() ||  // Blazor WASM
        (OperatingSystem.IsAndroid() && !HasAesNi());  // Older Android
    
    if (useChaCha20)
    {
        return builder.WithBouncyCastleEncryption(password);
    }
    else
    {
        return builder.WithEncryption(password);
    }
}

private bool HasAesNi()
{
    // On Android, check CPU features
    // Most devices from 2015+ have ARMv8 crypto
    return true;  // Simplified; implement actual detection if needed
}

// Blazor WASM — fast PBKDF2
builder.WithBouncyCastleEncryptionFast("user", "password");

// Or via connection string
"Encryption=chacha20-poly1305;Password=secret;Fast Encryption=true"

"Data Source=/path/to/app.witdb;Encryption=aes-gcm;Password=secret"

var db = new WitDatabaseBuilder()
    .WithIndexedDbStorage("AppName", JSRuntime)
    .WithBouncyCastleEncryptionFast("user", "password")
    .WithBTree()
    .Build();
await db.InitializeAsync();

var path = Path.Combine(FileSystem.AppDataDirectory, "app.witdb");
"Data Source=" + path + ";Encryption=aes-gcm;Password=secret"