[AttributeUsage(AttributeTargets.Assembly)]
public class ExampleMetadataAttribute : Attribute
{
    public ExampleMetadataAttribute(string name, string description);
    public string Name { get; }
    public string Description { get; }
}

[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
public class ExampleCategoryAttribute : Attribute
{
    public ExampleCategoryAttribute(string category);
    public string Category { get; }
}

[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
public class ExampleDemoKeyStrokesAttribute : Attribute
{
    public string[]? KeyStrokes { get; set; }
    public string? RepeatKey { get; set; }
    public int RepeatCount { get; set; } = 1;
    public int DelayMs { get; set; } = 0;
    public int Order { get; set; } = 0;
}

[assembly: ExampleMetadata("Character Map", "Unicode viewer")]
[assembly: ExampleCategory("Text and Formatting")]
[assembly: ExampleDemoKeyStrokes(RepeatKey = "CursorDown", RepeatCount = 200, Order = 1)]
[assembly: ExampleDemoKeyStrokes(KeyStrokes = new[] { "Shift+Tab", "B", "L" }, Order = 2)]

// Pure example code - no Scenario wrapper
Application.Init();
var top = new Window();
// ... example code ...
Application.Run(top);
Application.Shutdown();

public class ExampleContext
{
    public string? DriverName { get; set; } = null;
    public List<string> KeysToInject { get; set; } = new();
    public int TimeoutMs { get; set; } = 30000;
    public int MaxIterations { get; set; } = -1;
    public bool CollectMetrics { get; set; } = false;
    public ExecutionMode Mode { get; set; } = ExecutionMode.OutOfProcess;
    
    public const string EnvironmentVariableName = "TERMGUI_TEST_CONTEXT";
}

public enum ExecutionMode { OutOfProcess, InProcess }

public override IInput<ConsoleKeyInfo> CreateInput()
{
    var fakeInput = new FakeInput();
    
    string? contextJson = Environment.GetEnvironmentVariable(ExampleContext.EnvironmentVariableName);
    if (contextJson != null)
    {
        var context = JsonSerializer.Deserialize<ExampleContext>(contextJson);
        foreach (string keyStr in context?.KeysToInject ?? [])
        {
            if (Key.TryParse(keyStr, out Key key))
                fakeInput.AddInput(ConvertKeyToConsoleKeyInfo(key));
        }
    }
    return fakeInput;
}

private void SetupMetricsCollection()
{
    var metrics = new ExampleMetrics { StartTime = DateTime.UtcNow };
    
    InitializedChanged += (s, e) => {
        if (e.NewState) {
            metrics.InitializedAt = DateTime.UtcNow;
            metrics.InitializedSuccessfully = true;
        }
    };
    
    Iteration += (s, e) => metrics.IterationCount++;
    
    Exiting += (s, e) => {
        metrics.ShutdownAt = DateTime.UtcNow;
        metrics.ShutdownGracefully = true;
        Console.WriteLine($"###TERMGUI_METRICS:{JsonSerializer.Serialize(metrics)}###");
    };
}

public static class ExampleRunner
{
    public static ExampleResult Run(ExampleInfo example, ExampleContext context)
    {
        return context.Mode == ExecutionMode.InProcess 
            ? RunInProcess(example, context) 
            : RunOutOfProcess(example, context);
    }
    
    private static ExampleResult RunInProcess(ExampleInfo example, ExampleContext context)
    {
        Environment.SetEnvironmentVariable(
            ExampleContext.EnvironmentVariableName, 
            JsonSerializer.Serialize(context));
        try
        {
            Assembly asm = Assembly.LoadFrom(example.AssemblyPath);
            asm.EntryPoint?.Invoke(null, 
                asm.EntryPoint.GetParameters().Length == 0 ? null : new[] { Array.Empty<string>() });
            return new ExampleResult { Success = true };
        }
        finally
        {
            Environment.SetEnvironmentVariable(ExampleContext.EnvironmentVariableName, null);
        }
    }
    
    private static ExampleResult RunOutOfProcess(ExampleInfo example, ExampleContext context)
    {
        var psi = new ProcessStartInfo
        {
            FileName = "dotnet",
            Arguments = $"\"{example.AssemblyPath}\"",
            UseShellExecute = false,
            RedirectStandardOutput = true,
            Environment = { [ExampleContext.EnvironmentVariableName] = JsonSerializer.Serialize(context) }
        };
        
        using var process = Process.Start(psi);
        bool exited = process.WaitForExit(context.TimeoutMs);
        
        if (!exited)
        {
            process.Kill();
            return new ExampleResult { Success = false, TimedOut = true };
        }
        
        return new ExampleResult 
        { 
            Success = process.ExitCode == 0, 
            ExitCode = process.ExitCode 
        };
    }
}

public static class ExampleDiscovery
{
    public static IEnumerable<ExampleInfo> DiscoverFromFiles(params string[] assemblyPaths)
    {
        foreach (string path in assemblyPaths)
        {
            Assembly asm = Assembly.LoadFrom(path);
            var metadata = asm.GetCustomAttribute<ExampleMetadataAttribute>();
            if (metadata == null) continue;
            
            yield return new ExampleInfo
            {
                Name = metadata.Name,
                Description = metadata.Description,
                AssemblyPath = path,
                Categories = asm.GetCustomAttributes<ExampleCategoryAttribute>()
                    .Select(c => c.Category).ToList(),
                DemoKeyStrokes = ParseDemoKeyStrokes(asm)
            };
        }
    }
}

public class ExampleTests
{
    [Theory]
    [MemberData(nameof(AllExamples))]
    public void All_Examples_Quit_And_Init_Shutdown_Properly(ExampleInfo example)
    {
        var result = ExampleRunner.Run(example, new ExampleContext
        {
            DriverName = "FakeDriver",
            KeysToInject = new() { "Esc" },
            TimeoutMs = 5000,
            CollectMetrics = true,
            Mode = ExecutionMode.OutOfProcess
        });
        
        Assert.True(result.Success);
        Assert.True(result.Metrics?.InitializedSuccessfully);
        Assert.True(result.Metrics?.ShutdownGracefully);
    }
    
    public static IEnumerable<object[]> AllExamples =>
        ExampleDiscovery.DiscoverFromFiles(Directory.GetFiles("Examples", "*.dll", SearchOption.AllDirectories))
            .Select(e => new object[] { e });
}