Build your first model analysis tool

using System.Globalization;
using Microsoft.Extensions.DependencyInjection;
using Speckle.Objects.Data;
using Speckle.Sdk;
using Speckle.Sdk.Api;
using Speckle.Sdk.Credentials;
using Speckle.Sdk.Models;
using Speckle.Sdk.Models.Extensions;

static class SpeckleBootstrap
{
    static readonly ServiceProvider Provider = new ServiceCollection()
        .AddSpeckleSdk(
            new Application("Model Analysis", "model-analysis"),
            "1.0.0",
            typeof(Speckle.Objects.Geometry.Point).Assembly
        )
        .BuildServiceProvider();

    public static IOperations Operations => Provider.GetRequiredService<IOperations>();
    public static IAccountFactory AccountFactory => Provider.GetRequiredService<IAccountFactory>();
    public static IClientFactory ClientFactory => Provider.GetRequiredService<IClientFactory>();
}

var token = Environment.GetEnvironmentVariable("SPECKLE_TOKEN")
    ?? throw new InvalidOperationException("Set SPECKLE_TOKEN");
var serverUrl = Environment.GetEnvironmentVariable("SPECKLE_SERVER") ?? "https://app.speckle.systems";
var projectId = Environment.GetEnvironmentVariable("SPECKLE_PROJECT_ID")
    ?? throw new InvalidOperationException("Set SPECKLE_PROJECT_ID");
var modelId = Environment.GetEnvironmentVariable("SPECKLE_MODEL_ID")
    ?? throw new InvalidOperationException("Set SPECKLE_MODEL_ID");

var account = await SpeckleBootstrap.AccountFactory.CreateAccount(new Uri(serverUrl), token);
using var client = SpeckleBootstrap.ClientFactory.Create(account);

var versions = await client.Version.GetVersions(modelId, projectId, limit: 1);
var latest = versions.items.FirstOrDefault()
    ?? throw new InvalidOperationException("No versions found on this model");

Console.WriteLine($"Loading version: {latest.id} ({latest.message})");

var root = await SpeckleBootstrap.Operations.Receive2(
    client.ServerUrl,
    projectId,
    latest.referencedObject!,
    account.token,
    onProgressAction: null,
    cancellationToken: default
);

static string GetCategory(Base obj)
{
    if (obj is DataObject dataObject)
    {
        if (dataObject.properties.TryGetValue("category", out var cat) && cat is string s)
            return s;
        if (dataObject.properties.TryGetValue("builtInCategory", out var builtIn) && builtIn is string b)
            return b;
    }

    return obj["category"] as string ?? obj.speckle_type ?? "Unknown";
}

var counts = root.Flatten()
    .GroupBy(GetCategory)
    .OrderByDescending(g => g.Count())
    .ToDictionary(g => g.Key, g => g.Count());

var outputPath = Path.Combine(Environment.CurrentDirectory, "model-health-report.csv");
await using (var writer = new StreamWriter(outputPath))
{
    await writer.WriteLineAsync("Category,Count");
    foreach (var (category, count) in counts)
    {
        var escaped = category.Contains(',') ? $"\"{category}\"" : category;
        await writer.WriteLineAsync($"{escaped},{count}");
    }
}

Console.WriteLine($"Wrote {counts.Count} categories to {outputPath}");
foreach (var (category, count) in counts.Take(10))
    Console.WriteLine($"  {category}: {count}");