using GenerativeAI;
using GenerativeAI.Clients;
using GenerativeAI.Types;

var googleAi = new GoogleAi(apiKey);

var decisions    = googleAi.CreateDecisionsClient();
var voices       = googleAi.CreateVoicesClient();
var agents       = googleAi.CreateAgentsClient();
var environments = googleAi.CreateEnvironmentsClient();
var triggers     = googleAi.CreateTriggersClient();
var credentials  = googleAi.CreateCredentialsClient();
// Each client can also be constructed directly, e.g. new DecisionsClient(new GoogleAIPlatformAdapter(apiKey)).

var response = await decisions.CreateAsync(
    DecisionModels.GeminiDecision1,
    "The sky on a clear day is blue.",
    new Dictionary<string, DecisionQuestion>
    {
        ["sky_color"] = new ChoiceDecisionQuestion
        {
            Instructions = "Which color does the text say the sky is?",
            Criteria = new Dictionary<string, string>
            {
                ["blue"] = "The text says the sky is blue.",
                ["green"] = "The text says the sky is green."
            }
        },
        ["is_factual"] = new NoulDecisionQuestion
        {
            Instructions = "Is the statement factually correct?",
            Criteria = new NoulCriteria { TrueDescription = "Correct", FalseDescription = "Incorrect" }
        }
    });

if (response.Answers?["sky_color"] is ChoiceDecisionAnswer choice)
    Console.WriteLine($"{choice.Choice} ({choice.Confidence})");
if (response.Answers?["is_factual"] is NoulDecisionAnswer noul)
    Console.WriteLine($"P(true) = {noul.Noul}");

// Voice design: create a voice from a description ("prompted" voice).
Voice designed = await voices.DesignAsync("A calm, warm narrator voice.", displayName: "narrator", store: true);
Console.WriteLine($"{designed.Id} {designed.Key} {designed.Type}");   // Type == VoiceTypes.Prompted

// Remix an existing voice.
Voice remixed = await voices.RemixAsync(designed.Id!, "Make it slightly faster and brighter.", store: true);

// Replicate a voice from recorded audio. A consent recording from the speaker is required.
Voice replicated = await voices.ReplicateAsync(
    VoiceAudioData.FromBytes(await File.ReadAllBytesAsync("speaker.wav"), "audio/wav"),
    VoiceAudioData.FromBytes(await File.ReadAllBytesAsync("consent.wav"), "audio/wav"),
    displayName: "my-voice", store: true);

// List voices (custom and prebuilt), with optional filters.
var page = await voices.ListAsync(new ListVoicesOptions { Type = new List<string> { VoiceTypes.Prebuilt } }, pageSize: 20);
await foreach (var v in voices.ListAllAsync())
    Console.WriteLine($"{v.Id} {v.DisplayName} {v.Gender} {v.LanguageCode}");

var voice = await voices.GetAsync(designed.Id!);
await voices.DeleteAsync(designed.Id!);

var agent = await agents.CreateAsync(new Agent
{
    Id = "research-helper",
    BaseAgent = InteractionAgents.DeepResearchPreview042026,
    Description = "Researches topics for the support team.",
    SystemInstruction = "Cite your sources."
});

var fetched = await agents.GetAsync("research-helper");
var page = await agents.ListAsync(pageSize: 10);
await foreach (var a in agents.ListAllAsync())
    Console.WriteLine(a.Id);

await agents.DeleteAsync("research-helper");

AgentEnvironment env = await environments.CreateAsync();   // or pass a CreateEnvironmentRequest
Console.WriteLine($"{env.Id} {env.Status}");

// Upload from a stream (or use the overload that takes a local file path).
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes("hello")))
{
    await environments.UploadFileAsync(env.Id!, "data/hello.txt", stream, "text/plain", overwrite: true);
}

// Upload a tar/tar.gz archive and unpack it into a folder.
await environments.UploadFileAsync(env.Id!, "project", "project.tar.gz", extract: true);

// List and download workspace files.
await foreach (var file in environments.ListAllFilesAsync(env.Id!, recursive: true))
    Console.WriteLine($"{file.Path} {file.Type} {file.SizeBytes}");

byte[] content = await environments.DownloadFileAsync(env.Id!, "data/hello.txt");

await environments.DeleteAsync(env.Id!);

Trigger trigger = await triggers.CreateAsync(new CreateTriggerRequest
{
    DisplayName = "daily-digest",
    Schedule = "0 8 * * *",
    TimeZone = "Europe/London",
    Interaction = new CreateInteractionRequest
    {
        Agent = InteractionAgents.DeepResearchPreview042026,
        Input = "Summarize yesterday's AI news."
    }
});

await triggers.PauseAsync(trigger.Id!);
await triggers.ResumeAsync(trigger.Id!);
await triggers.UpdateAsync(trigger.Id!, new UpdateTriggerRequest { DisplayName = "morning-digest" });

// Run it now and wait for the execution.
TriggerExecution run = await triggers.RunAsync(trigger.Id!);
var finished = await triggers.WaitForExecutionAsync(trigger.Id!, run.Id!, timeout: TimeSpan.FromMinutes(30));
Console.WriteLine($"{finished.Status} {finished.InteractionId}");   // TriggerExecutionStatuses.*

await foreach (var exec in triggers.ListAllExecutionsAsync(trigger.Id!))
    Console.WriteLine($"{exec.Id} {exec.Status}");

await triggers.DeleteAsync(trigger.Id!);

var created = await credentials.CreateAsync(new EnvironmentVariableCredentialConfig
{
    Id = "github-token",
    // System.Environment: GenerativeAI.Types also has an Environment type.
    Value = System.Environment.GetEnvironmentVariable("GITHUB_TOKEN"),
    InjectionLocation = new List<string> { CredentialInjectionLocations.Header },
    TrustedDomains = new List<string> { "api.github.com" }
});

// Other types: BearerTokenCredentialConfig (Token, HeaderName, Prefix) and
// OAuth2CredentialConfig (ClientId, ClientSecret, RefreshToken, TokenUrl, Scopes).

var cred = await credentials.GetAsync("github-token");
await foreach (var c in credentials.ListAllAsync())
    Console.WriteLine($"{c.Id} {c.Type} {c.Status}");

await credentials.UpdateAsync("github-token",
    new EnvironmentVariableCredentialConfig { Value = "new-value" }, updateMask: "value");
await credentials.DeleteAsync("github-token");

try
{
    var env = await environments.CreateAsync();
}
catch (ApiException ex) when (ex.ErrorCode is 403 or 404 || ex.ErrorStatus == "FAILED_PRECONDITION")
{
    Console.WriteLine($"Environments are not available for this project: {ex.ErrorMessage}");
}