public interface IServiceProviderAssignable : IServiceProvider
{
    /// <summary>
    ///  Sets the service provider for this component.
    /// </summary>
    IServiceProvider SetServiceProvider(object serviceProvider);
}

namespace Microsoft.Extensions.WinForms;

/// <summary>
///  Represents a configured Windows Forms application.
/// </summary>
public sealed class WinFormsApplication : IHost, IDisposable
{
    /// <summary>
    ///  Gets the current running instance of the WinFormsApplication.
    /// </summary>
    public static WinFormsApplication? Current { get; }
    
    /// <summary>
    ///  Gets the application's configured service provider.
    /// </summary>
    public IServiceProvider Services { get; }
    
    /// <summary>
    ///  Creates a new WinFormsApplicationBuilder with pre-configured defaults.
    /// </summary>
    public static WinFormsApplicationBuilder CreateBuilder();
    
    /// <summary>
    ///  Starts the host and runs the Windows Forms application with the configured startup form.
    /// </summary>
    public void Run();
    
    /// <summary>
    ///  Starts the host and runs the Windows Forms application with the specified form type.
    /// </summary>
    public void Run<TForm>() where TForm : Form;
    
    /// <summary>
    ///  Starts the host asynchronously.
    /// </summary>
    public Task StartAsync(CancellationToken cancellationToken = default);
    
    /// <summary>
    ///  Stops the host asynchronously.
    /// </summary>
    public Task StopAsync(CancellationToken cancellationToken = default);
}

namespace Microsoft.Extensions.WinForms;

/// <summary>
///  A builder for Windows Forms applications.
/// </summary>
public sealed class WinFormsApplicationBuilder : IHostApplicationBuilder
{
    /// <summary>
    ///  Gets the collection of services for the application.
    /// </summary>
    public IServiceCollection Services { get; }
    
    /// <summary>
    ///  Gets the application configuration.
    /// </summary>
    public ConfigurationManager Configuration { get; }
    
    /// <summary>
    ///  Gets the logging builder for the application.
    /// </summary>
    public ILoggingBuilder Logging { get; }
    
    /// <summary>
    ///  Gets the host environment for the application.
    /// </summary>
    public IHostEnvironment Environment { get; }
    
    /// <summary>
    ///  Sets the startup form for the application using a form type.
    /// </summary>
    public WinFormsApplicationBuilder UseStartupForm<TForm>() where TForm : Form, new();
    
    /// <summary>
    ///  Sets an existing form instance as the startup form.
    /// </summary>
    public WinFormsApplicationBuilder UseStartupForm(Form startupForm);
    
    /// <summary>
    ///  Configures the high DPI mode for the application.
    /// </summary>
    public WinFormsApplicationBuilder UseHighDpiMode(HighDpiMode highDpiMode);
    
    /// <summary>
    ///  Configures the color mode (Dark/Light/System) for the application.
    /// </summary>
    public WinFormsApplicationBuilder UseColorMode(SystemColorMode colorMode);
    
    /// <summary>
    ///  Configures the default font for the application.
    /// </summary>
    public WinFormsApplicationBuilder UseDefaultFont(Font defaultFont);
    
    /// <summary>
    ///  Configures whether to enable visual styles.
    /// </summary>
    public WinFormsApplicationBuilder UseVisualStyles(bool enable = true);
    
    /// <summary>
    ///  Configures whether to use GDI+ text rendering (v2).
    /// </summary>
    public WinFormsApplicationBuilder UseTextRenderingV2(bool enable = true);
    
    /// <summary>
    ///  Configures whether to allow WinForms settings from appsettings.json.
    /// </summary>
    public WinFormsApplicationBuilder AllowWinFormsJsonAppSettings(bool allowJson = true);
    
    /// <summary>
    ///  Configures the application to use settings from the project file.
    /// </summary>
    public WinFormsApplicationBuilder UseProjectSettings();
    
    /// <summary>
    ///  Adds WinForms-specific debug logging.
    /// </summary>
    public WinFormsApplicationBuilder UseWinFormsDebugLogger();
    
    /// <summary>
    ///  Adds WinForms-specific release logging.
    /// </summary>
    public WinFormsApplicationBuilder UseWinFormsReleaseLogger();
    
    /// <summary>
    ///  Builds the WinFormsApplication.
    /// </summary>
    public WinFormsApplication Build();
}

namespace Microsoft.Extensions.WinForms;

/// <summary>
///  Represents the lifetime of a Windows Forms application.
/// </summary>
public sealed class WinFormsApplicationLifetime
{
    /// <summary>
    ///  Occurs when the application has been fully started.
    /// </summary>
    public event EventHandler<EventArgs>? ApplicationStarted;
    
    /// <summary>
    ///  Occurs when the application is stopping.
    /// </summary>
    public event EventHandler<EventArgs>? ApplicationStopping;
    
    /// <summary>
    ///  Occurs when the application has completely stopped.
    /// </summary>
    public event EventHandler<EventArgs>? ApplicationStopped;
}

// Core hosting infrastructure
namespace Microsoft.Extensions.WinForms
{
    public sealed class WinFormsApplication { }
    public sealed class WinFormsApplicationBuilder { }
    public sealed class WinFormsApplicationLifetime { }
    internal sealed class WinFormsApplicationOptions { }
}

// Service provider integration for Designer compatibility
namespace System.ComponentModel
{
    public interface IServiceProviderAssignable : IServiceProvider { }
}

// Extension methods for service registration
namespace Microsoft.Extensions.DependencyInjection
{
    public static class WinFormsServiceCollectionExtensions
    {
        public static IServiceCollection AddWinFormsUserSettings(this IServiceCollection services);
        public static IServiceCollection AddWinFormsExceptionHandling(this IServiceCollection services);
        public static IServiceCollection AddWinFormsDialogs(this IServiceCollection services);
    }
}

// Logging extensions
namespace Microsoft.Extensions.Logging
{
    public static class WinFormsLoggingExtensions
    {
        public static ILoggingBuilder AddDebugLogger(this ILoggingBuilder builder);
        public static ILoggingBuilder AddFileLogger(this ILoggingBuilder builder);
    }
}

// Core services and interfaces
namespace Microsoft.Extensions.WinForms.Services
{
    public interface IUserSettingsService { }
    public interface IWinFormsExceptionService { }
    public interface IWinFormsDialogService { }
}

// Example: Blazor Hybrid support
namespace Microsoft.AspNetCore.Components.WebView.WindowsForms
{
    public static class BlazorWebViewServiceCollectionExtensions
    {
        public static IServiceCollection AddWindowsFormsBlazorWebView(
            this IServiceCollection services);
    }
}

// Example: AI integration
namespace Microsoft.Extensions.AI.WinForms
{
    public static class AIServiceCollectionExtensions
    {
        public static IServiceCollection AddAIChatClient(
            this IServiceCollection services);
    }
}

namespace System.ComponentModel;

/// <summary>
///  Represents a component that can receive a service provider after construction.
///  This enables dependency injection while maintaining Windows Forms Designer compatibility.
/// </summary>
public interface IServiceProviderAssignable : IServiceProvider
{
    /// <summary>
    ///  Sets the service provider for this component.
    /// </summary>
    /// <param name="serviceProvider">The service provider to assign.</param>
    /// <returns>The service provider for chaining.</returns>
    IServiceProvider SetServiceProvider(object serviceProvider);
}

namespace Microsoft.Extensions.DependencyInjection;

public static class WinFormsServiceCollectionExtensions
{
    /// <summary>
    ///  Adds the WinForms user settings service to the service collection.
    /// </summary>
    public static IServiceCollection AddWinFormsUserSettings(
        this IServiceCollection services);
    
    /// <summary>
    ///  Adds the WinForms exception handling service.
    /// </summary>
    public static IServiceCollection AddWinFormsExceptionHandling(
        this IServiceCollection services);
    
    /// <summary>
    ///  Adds the WinForms dialog service for showing dialogs.
    /// </summary>
    public static IServiceCollection AddWinFormsDialogs(
        this IServiceCollection services);
    
    /// <summary>
    ///  Gets a component from the service provider.
    /// </summary>
    public static TComponent? GetComponent<TComponent>(
        this IServiceProvider serviceProvider);
    
    /// <summary>
    ///  Gets a required component from the service provider.
    /// </summary>
    public static TComponent GetRequiredComponent<TComponent>(
        this IServiceProvider serviceProvider);
}

namespace Microsoft.Extensions.WinForms.Services;

/// <summary>
///  Provides a modern, JSON-based user settings service.
/// </summary>
public interface IUserSettingsService
{
    /// <summary>
    ///  Gets a setting value with a default fallback.
    /// </summary>
    T GetSetting<T>(string key, T defaultValue);
    
    /// <summary>
    ///  Saves a setting value.
    /// </summary>
    void SaveSetting<T>(string key, T value);
    
    /// <summary>
    ///  Loads settings from disk.
    /// </summary>
    void Load();
    
    /// <summary>
    ///  Saves settings to disk.
    /// </summary>
    void Save();
    
    /// <summary>
    ///  Removes a setting.
    /// </summary>
    void Remove(string key);
}

namespace Microsoft.Extensions.WinForms.Services;

/// <summary>
///  Provides centralized exception handling for WinForms applications.
/// </summary>
public interface IWinFormsExceptionService
{
    /// <summary>
    ///  Handles an exception that occurred in the application.
    /// </summary>
    void HandleException(Exception exception, bool canContinue = true);
    
    /// <summary>
    ///  Configures global exception handlers.
    /// </summary>
    void ConfigureGlobalHandlers();
}

namespace Microsoft.Extensions.Logging;

public static class WinFormsLoggingExtensions
{
    /// <summary>
    ///  Adds a timestamped debug logger suitable for Windows Forms development.
    /// </summary>
    public static ILoggingBuilder AddDebugLogger(
        this ILoggingBuilder builder,
        string? timeStampFormat = null,
        bool minuteSeparator = true);
    
    /// <summary>
    ///  Adds a file logger for Windows Forms applications.
    /// </summary>
    public static ILoggingBuilder AddFileLogger(
        this ILoggingBuilder builder,
        string? applicationName = null,
        string? logDirectory = null);
}

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.WinForms;
using Microsoft.Extensions.Logging;

namespace MyWinFormsApp;

internal static class Program
{
    [STAThread]
    static void Main()
    {
        // Create the application builder
        WinFormsApplicationBuilder builder = WinFormsApplication.CreateBuilder();

        // Configure services
        builder.Services.AddWinFormsUserSettings();
        builder.Services.AddWinFormsExceptionHandling();
        builder.Services.AddWinFormsDialogs();

        // Register application forms and components
        builder.Services.AddScoped<MainForm>();
        builder.Services.AddScoped<SettingsForm>();
        
        // Configure logging
        builder.Logging.AddDebugLogger();
        builder.Logging.AddFileLogger();

        // Configure WinForms-specific options
        builder.UseStartupForm<MainForm>()
               .UseHighDpiMode(HighDpiMode.PerMonitorV2)
               .UseColorMode(SystemColorMode.System)
               .UseTextRenderingV2()
               .UseVisualStyles()
               .AllowWinFormsJsonAppSettings();

        // Build and run
        WinFormsApplication app = builder.Build();
        app.Run();
    }
}

using Microsoft.AspNetCore.Components.WebView.WindowsForms;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.WinForms;
using Microsoft.Extensions.Logging;

namespace ChattyApp;

internal static class Program
{
    [STAThread]
    static void Main()
    {
        WinFormsApplicationBuilder builder = WinFormsApplication.CreateBuilder();

        // Core services
        builder.Services.AddWinFormsUserSettings();
        builder.Services.AddWinFormsExceptionHandling();

        // Blazor Hybrid support
        builder.Services.AddWindowsFormsBlazorWebView();

        // Application components
        builder.Services.AddScoped<FrmMain>();
        builder.Services.AddScoped<ChatViewModel>();

        // Logging
        builder.Logging.AddDebugLogger();

        // WinForms configuration
        builder.UseStartupForm<FrmMain>()
               .UseHighDpiMode(HighDpiMode.SystemAware)
               .UseColorMode(SystemColorMode.System)
               .UseTextRenderingV2()
               .UseVisualStyles();

        // Build and run
        WinFormsApplication app = builder.Build();
        app.Run();
    }
}

using System.ComponentModel;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.WinForms.Services;

namespace MyWinFormsApp;

/// <summary>
///  Main application form with dependency injection support.
/// </summary>
public partial class MainForm : Form, IServiceProviderAssignable
{
    private readonly ILogger<MainForm> _logger;
    private readonly IUserSettingsService _settings;
    private IServiceProvider? _serviceProvider;

    // Designer-compatible parameterless constructor
    public MainForm()
    {
        InitializeComponent();
    }

    // Constructor for dependency injection
    public MainForm(
        ILogger<MainForm> logger,
        IUserSettingsService settings) : this()
    {
        _logger = logger;
        _settings = settings;
        
        _logger.LogInformation("MainForm initialized with DI");
    }

    // IServiceProviderAssignable implementation
    public IServiceProvider SetServiceProvider(object serviceProvider)
    {
        _serviceProvider = (IServiceProvider)serviceProvider;
        return _serviceProvider;
    }

    public object? GetService(Type serviceType)
        => _serviceProvider?.GetService(serviceType);

    protected override void OnLoad(EventArgs e)
    {
        base.OnLoad(e);

        // Load window position from settings
        if (_settings.GetSetting("WindowMaximized", false))
        {
            WindowState = FormWindowState.Maximized;
        }
        else
        {
            Location = _settings.GetSetting("WindowLocation", Location);
            Size = _settings.GetSetting("WindowSize", Size);
        }
    }

    protected override void OnFormClosing(FormClosingEventArgs e)
    {
        // Save window position
        _settings.SaveSetting("WindowMaximized", 
            WindowState == FormWindowState.Maximized);
        
        if (WindowState == FormWindowState.Normal)
        {
            _settings.SaveSetting("WindowLocation", Location);
            _settings.SaveSetting("WindowSize", Size);
        }
        
        _settings.Save();

        base.OnFormClosing(e);
    }
}

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.WinForms;
using Microsoft.Extensions.Logging;

var builder = WinFormsApplication.CreateBuilder();

// Configure services
builder.Services.AddWinFormsUserSettings();
builder.Services.AddWinFormsExceptionHandling();
builder.Services.AddScoped<MainForm>();

// Configure logging
builder.Logging.AddDebugLogger();

// Configure WinForms
builder.UseStartupForm<MainForm>()
       .UseHighDpiMode(HighDpiMode.PerMonitorV2)
       .UseColorMode(SystemColorMode.System);

var app = builder.Build();
app.Run();

// In Program.cs
builder.Services.AddWindowsFormsBlazorWebView();
builder.Services.AddScoped<ChatViewModel>();

public class TrayApplicationContext : ApplicationContext
{
    private readonly NotifyIcon _notifyIcon;
    private readonly IServiceProvider _services;

    public TrayApplicationContext(IServiceProvider services)
    {
        _services = services;
        _notifyIcon = new NotifyIcon
        {
            Icon = Resources.AppIcon,
            ContextMenuStrip = CreateContextMenu(),
            Visible = true
        };
    }
    
    private ContextMenuStrip CreateContextMenu()
    {
        var menu = new ContextMenuStrip();
        menu.Items.Add("Open", null, OnOpen);
        menu.Items.Add("Settings", null, OnSettings);
        menu.Items.Add("Exit", null, OnExit);
        return menu;
    }
}

static class Program
{
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetHighDpiMode(HighDpiMode.SystemAware);
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new MainForm());
    }
}

static class Program
{
    [STAThread]
    static void Main()
    {
        var builder = WinFormsApplication.CreateBuilder();
        
        builder.UseStartupForm<MainForm>()
               .UseHighDpiMode(HighDpiMode.SystemAware)
               .UseTextRenderingV2()
               .UseVisualStyles();
        
        var app = builder.Build();
        app.Run();
    }
}

// Save
_settings.SaveSetting("WindowLocation", this.Location);
_settings.Save();

// Load
Location = _settings.GetSetting("WindowLocation", new Point(100, 100));