V2

.gitignore

@@ -364,3 +364,6 @@ appsettings.*.json
 .Trashes
 ehthumbs.db
 Thumbs.db
+
+# Build
+dist/

App.xaml

@@ -1,9 +1,8 @@
 <Application x:Class="BARS_Client_V2.App"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:local="clr-namespace:BARS_Client_V2"
-             StartupUri="MainWindow.xaml">
+             xmlns:local="clr-namespace:BARS_Client_V2">
     <Application.Resources>
-         
+
     </Application.Resources>
 </Application>

App.xaml.cs

@@ -1,14 +1,98 @@
-using System.Configuration;
-using System.Data;
-using System.Windows;
+using System.Windows;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Http;
+using BARS_Client_V2.Domain;
+using BARS_Client_V2.Application; // Contains SimulatorManager; no conflict if fully qualified below
+using BARS_Client_V2.Presentation.ViewModels;
+using BARS_Client_V2.Services;
+using System.Windows.Threading;
 
 namespace BARS_Client_V2
 {
-    /// <summary>
-    /// Interaction logic for App.xaml
-    /// </summary>
-    public partial class App : Application
+    public partial class App : System.Windows.Application
     {
+        private IHost? _host;
+
+        protected override void OnStartup(StartupEventArgs e)
+        {
+            base.OnStartup(e);
+            _host = Host.CreateDefaultBuilder()
+                .ConfigureLogging(lb =>
+                {
+                    lb.ClearProviders();
+                    lb.AddConsole();          // Console (visible if app started from console / debug output window)
+                    lb.AddDebug();            // VS Debug Output window
+                    lb.AddEventSourceLogger(); // ETW / PerfView if needed
+                    lb.SetMinimumLevel(LogLevel.Trace);
+                })
+                .ConfigureServices(services =>
+                {
+                    services.AddSingleton<ISimulatorConnector, Infrastructure.Simulators.Msfs.MsfsSimulatorConnector>();
+                    services.AddSingleton<IAirportRepository, Infrastructure.Networking.HttpAirportRepository>();
+                    services.AddSingleton<ISettingsStore, Infrastructure.Settings.JsonSettingsStore>();
+                    services.AddSingleton<SimulatorManager>();
+                    services.AddHostedService(sp => sp.GetRequiredService<SimulatorManager>()); // background stream
+                    services.AddHttpClient();
+                    services.AddSingleton<INearestAirportService, NearestAirportService>();
+                    services.AddSingleton<BARS_Client_V2.Infrastructure.Networking.AirportWebSocketManager>();
+                    services.AddHostedService(sp => sp.GetRequiredService<BARS_Client_V2.Infrastructure.Networking.AirportWebSocketManager>());
+                    services.AddHostedService<BARS_Client_V2.Services.DiscordPresenceService>();
+                    services.AddSingleton<BARS_Client_V2.Infrastructure.Networking.AirportStateHub>();
+                    services.AddSingleton<BARS_Client_V2.Infrastructure.Simulators.Msfs.MsfsPointController>(sp =>
+                    {
+                        var connectors = sp.GetServices<ISimulatorConnector>();
+                        var logger = sp.GetRequiredService<Microsoft.Extensions.Logging.ILogger<BARS_Client_V2.Infrastructure.Simulators.Msfs.MsfsPointController>>();
+                        var hub = sp.GetRequiredService<BARS_Client_V2.Infrastructure.Networking.AirportStateHub>();
+                        var simManager = sp.GetRequiredService<SimulatorManager>();
+                        return new BARS_Client_V2.Infrastructure.Simulators.Msfs.MsfsPointController(connectors, logger, hub, simManager, null);
+                    });
+                    services.AddHostedService(sp => sp.GetRequiredService<BARS_Client_V2.Infrastructure.Simulators.Msfs.MsfsPointController>());
+                    services.AddSingleton<MainWindowViewModel>();
+                    services.AddTransient<MainWindow>();
+                })
+                .Build();
+
+
+            var mainWindow = _host.Services.GetRequiredService<MainWindow>();
+            var vm = _host.Services.GetRequiredService<MainWindowViewModel>();
+            mainWindow.DataContext = vm;
+            var wsMgr = _host.Services.GetRequiredService<BARS_Client_V2.Infrastructure.Networking.AirportWebSocketManager>();
+            var hub = _host.Services.GetRequiredService<BARS_Client_V2.Infrastructure.Networking.AirportStateHub>();
+            wsMgr.AttachHub(hub);
+            wsMgr.Connected += () => vm.NotifyServerConnected();
+            wsMgr.ConnectionError += code => vm.NotifyServerError(code);
+            wsMgr.MessageReceived += msg => { vm.NotifyServerMessage(); _ = hub.ProcessAsync(msg); };
+            var pointController = _host.Services.GetRequiredService<BARS_Client_V2.Infrastructure.Simulators.Msfs.MsfsPointController>();
+            wsMgr.Disconnected += reason => { pointController.Suspend(); _ = pointController.DespawnAllAsync(); };
+            wsMgr.Connected += () => pointController.Resume();
+            mainWindow.Show();
+            Dispatcher.BeginInvoke(DispatcherPriority.ApplicationIdle, async () =>
+            {
+                try
+                {
+                    if (_host != null)
+                    {
+                        await _host.StartAsync();
+                    }
+                }
+                catch
+                {
+                    // Swallow to avoid UI crash;
+                }
+            });
+        }
+
+        protected override async void OnExit(ExitEventArgs e)
+        {
+            if (_host != null)
+            {
+                try { await _host.StopAsync(); } catch { }
+                _host.Dispose();
+            }
+            base.OnExit(e);
+        }
     }
 
 }

Application/IAirportRepository.cs

@@ -0,0 +1,11 @@
+using BARS_Client_V2.Domain;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BARS_Client_V2.Application;
+
+public interface IAirportRepository
+{
+    Task<(IReadOnlyList<Airport> Items, int TotalCount)> SearchAsync(string? search, int page, int pageSize, CancellationToken ct = default);
+}

Application/ISettingsStore.cs

@@ -0,0 +1,15 @@
+using System.Threading.Tasks;
+using System.Collections.Generic;
+
+namespace BARS_Client_V2.Application;
+
+public interface ISettingsStore
+{
+    Task<ClientSettings> LoadAsync();
+    Task SaveAsync(ClientSettings settings);
+}
+
+public sealed record ClientSettings(string? ApiToken, IDictionary<string, string>? AirportPackages = null)
+{
+    public static ClientSettings Empty => new(null, new Dictionary<string, string>());
+}

Application/SimulatorManager.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BARS_Client_V2.Domain;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace BARS_Client_V2.Application;
+
+public sealed class SimulatorManager : BackgroundService
+{
+    private readonly IEnumerable<ISimulatorConnector> _connectors;
+    private readonly ILogger<SimulatorManager> _logger;
+    private readonly object _lock = new();
+    private ISimulatorConnector? _active;
+    private FlightState? _latest;
+
+    public SimulatorManager(IEnumerable<ISimulatorConnector> connectors, ILogger<SimulatorManager> logger)
+    {
+        _connectors = connectors;
+        _logger = logger;
+    }
+
+    public FlightState? LatestState { get { lock (_lock) return _latest; } }
+    public ISimulatorConnector? ActiveConnector { get { lock (_lock) return _active; } }
+
+    public async Task<bool> ActivateAsync(string simulatorId, CancellationToken ct = default)
+    {
+        var connector = _connectors.FirstOrDefault(c => string.Equals(c.SimulatorId, simulatorId, StringComparison.OrdinalIgnoreCase));
+        if (connector == null) return false;
+        if (connector == _active && connector.IsConnected) return true;
+
+        if (_active != null && _active.IsConnected)
+        {
+            try { await _active.DisconnectAsync(ct); } catch (Exception ex) { _logger.LogWarning(ex, "Error disconnecting previous simulator"); }
+        }
+
+        if (await connector.ConnectAsync(ct))
+        {
+            lock (_lock) _active = connector;
+            _logger.LogInformation("Activated simulator {sim}", connector.DisplayName);
+            return true;
+        }
+        return false;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        var first = _connectors.FirstOrDefault();
+        if (first != null)
+        {
+            await ActivateAsync(first.SimulatorId, stoppingToken);
+        }
+
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            var active = ActiveConnector;
+            if (active == null || !active.IsConnected)
+            {
+                // Attempt reconnect periodically when disconnected
+                if (first != null)
+                {
+                    try
+                    {
+                        await ActivateAsync(first.SimulatorId, stoppingToken);
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogDebug(ex, "Reconnect attempt failed");
+                    }
+                }
+                await Task.Delay(2000, stoppingToken);
+                continue;
+            }
+            try
+            {
+                await foreach (var raw in active.StreamRawAsync(stoppingToken))
+                {
+                    lock (_lock) _latest = new FlightState(raw.Latitude, raw.Longitude, raw.OnGround);
+                }
+            }
+            catch (OperationCanceledException) { }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error streaming flight state");
+                // small backoff
+                await Task.Delay(2000, stoppingToken);
+            }
+        }
+    }
+}

BARS-Client-V2.csproj

@@ -8,12 +8,40 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <UseWPF>true</UseWPF>
     <ApplicationIcon>appicon.ico</ApplicationIcon>
+    <AssemblyName>BARS Client</AssemblyName>
+    <Name>BARS Client</Name>
+    <Version>2.0.0</Version>
+    <FileVersion>2.0.0</FileVersion>
+    <AssemblyVersion>2.0.0</AssemblyVersion>
+    <PackageId>BARS-Client</PackageId>
+    <!-- Deployment / Publish settings -->
+    <SelfContained>false</SelfContained>
+    <PublishReadyToRun>true</PublishReadyToRun>
+    <GenerateDocumentationFile>false</GenerateDocumentationFile>
+    <DebugType>none</DebugType>
+    <Deterministic>true</Deterministic>
+    <PublishTrimmed>false</PublishTrimmed>
+    <PublishSingleFile>false</PublishSingleFile>
+    <RuntimeIdentifiers>win-x64</RuntimeIdentifiers>
   </PropertyGroup>
 
   <ItemGroup>
     <Content Include="appicon.ico" />
   </ItemGroup>
 
+  <!-- Exclude PDB files from publish output explicitly (belt & suspenders) -->
+  <ItemGroup Condition="'$(Configuration)' == 'Release'">
+    <None Remove="**/*.pdb" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.9" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="9.0.9" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="9.0.9" />
+    <PackageReference Include="DiscordRichPresence" Version="1.6.1.70" />
+    <PackageReference Include="SimConnect.NET" Version="0.1.15-beta" />
+  </ItemGroup>
+
   <ItemGroup>
     <Compile Update="Properties\Settings.Designer.cs">
       <DesignTimeSharedInput>True</DesignTimeSharedInput>

Domain/Airport.cs

@@ -0,0 +1,5 @@
+namespace BARS_Client_V2.Domain;
+
+public sealed record SceneryPackage(string Name);
+
+public sealed record Airport(string ICAO, IReadOnlyList<SceneryPackage> SceneryPackages);

Domain/FlightState.cs

@@ -0,0 +1,3 @@
+namespace BARS_Client_V2.Domain;
+
+public sealed record FlightState(double Latitude, double Longitude, bool OnGround);

Domain/IPointStateListener.cs

@@ -0,0 +1,8 @@
+using System.Threading.Tasks;
+
+namespace BARS_Client_V2.Domain;
+
+public interface IPointStateListener
+{
+    void OnPointStateChanged(PointState state);
+}

Domain/ISimulatorConnector.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BARS_Client_V2.Domain;
+
+public sealed record RawFlightSample(double Latitude, double Longitude, bool OnGround);
+
+public interface ISimulatorConnector
+{
+    string SimulatorId { get; }
+    string DisplayName { get; }
+    bool IsConnected { get; }
+    Task<bool> ConnectAsync(CancellationToken ct = default);
+    Task DisconnectAsync(CancellationToken ct = default);
+    IAsyncEnumerable<RawFlightSample> StreamRawAsync(CancellationToken ct = default);
+}

Domain/Point.cs

@@ -0,0 +1,17 @@
+namespace BARS_Client_V2.Domain;
+
+public sealed record PointMetadata(
+    string Id,
+    string AirportId,
+    string Type,
+    string Name,
+    double Latitude,
+    double Longitude,
+    string? Directionality,
+    string? Orientation,
+    string? Color,
+    bool Elevated,
+    bool Ihp
+);
+
+public sealed record PointState(PointMetadata Metadata, bool IsOn, long TimestampMs);