using CSharpCodeAnalyst.CodeGraph.Contracts;

using System.Collections.ObjectModel;

using System.ComponentModel;

using System.Diagnostics;

using System.Globalization;

using System.IO;

using System.Runtime.CompilerServices;

using System.Windows;

using System.Windows.Input;

using CSharpCodeAnalyst.AnalyzerSdk.Contracts;

using CSharpCodeAnalyst.AnalyzerSdk.DynamicDataGrid.Contracts.TabularData;

using CSharpCodeAnalyst.AnalyzerSdk.Messages;

using CSharpCodeAnalyst.AnalyzerSdk.Notifications;

using CSharpCodeAnalyst.AnalyzerSdk.Wpf;

using CSharpCodeAnalyst.CodeGraph.Algorithms.Cycles;

using CSharpCodeAnalyst.CodeGraph.Algorithms.Partitioning;

using CSharpCodeAnalyst.CodeGraph.Graph;

using CSharpCodeAnalyst.CodeGraph.Declarations;

using CSharpCodeAnalyst.CodeGraph.Metrics;

using CSharpCodeAnalyst.CodeParser.Parser;

using CSharpCodeAnalyst.CodeParser.Parser.Config;

using CSharpCodeAnalyst.Configuration;

using CSharpCodeAnalyst.Features.AdvancedSearch;

using CSharpCodeAnalyst.Features.Ai;

using CSharpCodeAnalyst.Features.Analyzers;

using CSharpCodeAnalyst.Features.CycleGroups;

using CSharpCodeAnalyst.Features.DsmMatrix;

using CSharpCodeAnalyst.Features.Export;

using CSharpCodeAnalyst.Features.Gallery;

using CSharpCodeAnalyst.Features.Graph;

using CSharpCodeAnalyst.Features.Help;

using CSharpCodeAnalyst.Features.History;

using CSharpCodeAnalyst.Features.Import;

using CSharpCodeAnalyst.Features.Info;

using CSharpCodeAnalyst.Features.Mcp;

using CSharpCodeAnalyst.Features.Partitions;

using CSharpCodeAnalyst.Features.Refactoring;

using CSharpCodeAnalyst.Features.Statistics;

using CSharpCodeAnalyst.Features.Tree;

using CSharpCodeAnalyst.Persistence.Contracts;

using CSharpCodeAnalyst.Persistence.Dto;

using CSharpCodeAnalyst.Resources;

using CSharpCodeAnalyst.Shared;

using CSharpCodeAnalyst.Shared.Contracts;

using CSharpCodeAnalyst.Shared.Filter;

using CSharpCodeAnalyst.Shared.Messages;

using CSharpCodeAnalyst.Shared.Notifications;

using CSharpCodeAnalyst.Shared.Services;

using CSharpCodeAnalyst.Shared.Tabs;

using CSharpCodeAnalyst.Shared.UI;

using CSharpCodeAnalyst.Shared.Wpf;

using CSharpCodeAnalyst.TreeMap;

// Both this application and DsmSuite have a MainViewModel.

using DsmMainViewModel = DsmSuite.DsmViewer.ViewModel.Main.MainViewModel;

namespace CSharpCodeAnalyst;

internal sealed class MainViewModel : INotifyPropertyChanged

{

private readonly AiAdvisorService _aiAdvisorService = new();

private readonly AnalyzerManager _analyzerManager;

/// <summary>Busy/status-bar sink shared by Importer, HistoryViewModel and IProjectService.</summary>

private readonly IProgress<BusyState> _busy;

private readonly Exporter _exporter;

private readonly Importer _importer;

private readonly ImporterManager _importerManager = new();

private readonly MessageBus _messaging;

private readonly ExternalContractStore _externalContractStore;

private readonly MetricStore _metricStore;

private readonly ProjectExclusionRegExCollection _projectExclusionFilters;

private readonly IProjectService _projectService;

private readonly RefactoringService _refactoringService;

private readonly IUserNotification _ui;

private AppSettings _applicationSettings;

private CodeGraph.Graph.CodeGraph? _codeGraph;

private Table? _cycles;

private Gallery? _gallery;

private GraphViewModel? _graphViewModel;

private InfoPanelViewModel? _infoPanelViewModel;

private string _loadMessage;

/// <summary>

/// Told when the graph is replaced or refactored, so the MCP server can hand out a fresh copy.

/// Always present, even with the server switched off - it does nothing until someone asks it

/// for a snapshot, which keeps the notifications below free of null checks.

/// </summary>

private readonly CodeGraphSnapshotProvider _mcpSnapshotProvider;

private readonly McpServerService _mcpServerService;

private LegendDialog? _openedLegendDialog;

private AdvancedSearchViewModel? _searchViewModel;

private TreeViewModel? _treeViewModel;

private UserPreferences _userSettings;

internal MainViewModel(MessageBus messaging, AppSettings settings, UserPreferences userSettings,

AnalyzerManager analyzerManager, RefactoringService refactoringService, IProjectService projectService,

MetricStore metricStore, ExternalContractStore externalContractStore,

CodeGraphSnapshotProvider mcpSnapshotProvider, McpServerService mcpServerService)

{

// Initialize settings

_applicationSettings = settings;

_userSettings = userSettings;

_analyzerManager = analyzerManager;

_refactoringService = refactoringService;

_metricStore = metricStore;

_externalContractStore = externalContractStore;

_mcpSnapshotProvider = mcpSnapshotProvider;

_mcpServerService = mcpServerService;

_mcpServerService.StateChanged += OnMcpServerStateChanged;

analyzerManager.AnalyzerDataChanged += OnAnalyzerDataChanged;

_ui = new WindowsUserNotification();

_busy = new Progress<BusyState>(OnBusyStateChanged);

_importer = new Importer(_ui, _busy);

_exporter = new Exporter(_ui);

_projectService = projectService;

_projectService.Progress = _busy;

_projectService.ProjectLoaded += OnProjectLoaded;

_projectService.ProjectSaved += OnProjectSaved;

_projectService.DirtyStateChanged += OnDirtyStateChanged;

History = new HistoryViewModel(messaging, _ui, _busy);

// Table data

_cycles = null;

// Apply settings

_projectExclusionFilters = new ProjectExclusionRegExCollection();

try

{

_projectExclusionFilters.Initialize(_applicationSettings.DefaultProjectExcludeFilter);

}

catch

{

_projectExclusionFilters.Initialize("");

}

_messaging = messaging;

_messaging.Subscribe<ClearQuickInfoRequest>(_ => ClearQuickInfo());

_gallery = new Gallery();

SearchCommand = new WpfCommand(Search);

LoadSolutionCommand = new WpfCommand(OnImportSolution);

ExecuteImporterCommand = new WpfCommand<string>(OnExecuteImporter);

LoadProjectCommand = new WpfCommand(OnLoadProject);

SaveProjectCommand = new WpfCommand(OnSaveProject);

GraphClearCommand = new WpfCommand(OnGraphClear);

GraphLayoutCommand = new WpfCommand(OnGraphLayout);

GraphRefitCommand = new WpfCommand(OnGraphRefit);

StopRenderingCommand = new WpfCommand(OnStopRendering);

FindCyclesCommand = new WpfCommand(OnFindCycles);

ShowDsmCommand = new WpfCommand(OnShowDsm);

AiAdviseCommand = new WpfCommand(OnAiAdvise);

ExecuteAnalyzerCommand = new WpfCommand<string>(OnExecuteAnalyzer);

ShowGalleryCommand = new WpfCommand(OnShowGallery);

OpenFilterDialogCommand = new WpfCommand(OnOpenFilterDialog);

OpenSettingsDialogCommand = new WpfCommand(OnOpenSettingsDialog);

ExportToDgmlCommand = new WpfCommand(OnExportToDgml);

ExportToPlantUmlCommand = new WpfCommand(OnExportToPlantUml);

ExportToSvgCommand = new WpfCommand(OnExportToSvg);

ExportToPngCommand = new WpfCommand(OnExportToPng);

ExportToDsiCommand = new WpfCommand(OnExportToDsi);

ExportPlainTextCommand = new WpfCommand(OnExportPlainText);

CopyBitmapToClipboardCommand = new WpfCommand(OnCopyCanvasToClipboard);

OpenRecentFileCommand = new WpfCommand<string>(OnOpenRecentFile);

SnapshotCommand = new WpfCommand(OnSnapshot);

RestoreCommand = new WpfCommand(OnRestore);

ToggleMcpServerCommand = new WpfCommand(OnToggleMcpServer);

CopyMcpSetupCommand = new WpfCommand(_mcpServerService.CopyClientSetupCommand,

() => _mcpServerService.IsRunning);

_loadMessage = string.Empty;

RefreshMru();

}

public HistoryViewModel History { get; private set; }

public WpfCommand ExportPlainTextCommand { get; set; }

public ObservableCollection<Mru> RecentFiles { get; } = [];

private ICommand OpenRecentFileCommand { get; }

/// <summary>

/// Dynamic result tabs (Method Complexity, Type Cohesion, Partitions, tree-map hotspots, ...),

/// created on demand and keyed by id. MainWindow's code-behind projects this onto the

/// working-area TabControl; see <see cref="DynamicTabActivated" /> for bringing one to the front.

/// </summary>

public ObservableCollection<ITabViewModel> DynamicTabs { get; } = [];

public Table? Cycles

{

get => _cycles;

set

{

_cycles = value;

OnPropertyChanged();

}

}

public InfoPanelViewModel? InfoPanelViewModel

{

get => _infoPanelViewModel;

set

{

if (Equals(value, _infoPanelViewModel))

{

return;

}

_infoPanelViewModel = value;

OnPropertyChanged();

}

}

public ICommand ShowGalleryCommand { get; }

public GraphViewModel? GraphViewModel

{

get => _graphViewModel;

set

{

_graphViewModel = value;

OnPropertyChanged();

}

}

public bool IsLeftPanelExpanded

{

get;

set

{

if (field == value)

{

return;

}

field = value;

OnPropertyChanged();

}

} = true;

public bool IsLoading

{

get;

set

{

field = value;

OnPropertyChanged();

}

}

public string LoadMessage

{

get => _loadMessage;

private set

{

_loadMessage = value;

OnPropertyChanged();

}

}

public ICommand LoadProjectCommand { get; }

public ICommand LoadSolutionCommand { get; }

public ICommand ExecuteImporterCommand { get; }

public ICommand SaveProjectCommand { get; }

public ICommand GraphClearCommand { get; }

public ICommand GraphLayoutCommand { get; }

public ICommand GraphRefitCommand { get; }

public ICommand StopRenderingCommand { get; }

public ICommand ExportToDgmlCommand { get; }

public ICommand ExportToPlantUmlCommand { get; }

public ICommand ExportToSvgCommand { get; set; }

public ICommand FindCyclesCommand { get; }

public ICommand ShowDsmCommand { get; }

public ICommand AiAdviseCommand { get; }

public ICommand ExportToDsiCommand { get; }

public ICommand SearchCommand { get; }

public ICommand ExportToPngCommand { get; }

public bool IsLegendOpen

{

get;

set

{

if (field == value)

{

return;

}

field = value;

OnPropertyChanged();

if (value)

{

OpenLegendDialog();

}

else

{

_openedLegendDialog?.Close();

}

}

}

public ICommand ExecuteAnalyzerCommand { get; set; }

public ICommand SnapshotCommand { get; }

public ICommand ToggleMcpServerCommand { get; }

public ICommand CopyMcpSetupCommand { get; }

public bool IsMcpServerRunning => _mcpServerService.IsRunning;

/// <summary>

/// The button says what pressing it does, not what the state is - a label that reads "Running"

/// leaves the user guessing whether clicking starts or stops it.

/// </summary>

public string McpServerLabel =>

IsMcpServerRunning ? Strings.Mcp_Stop_Label : Strings.Mcp_Start_Label;

/// <summary>

/// Carries the endpoint while running. A user who wants to register the server needs the exact

/// URL, and reconstructing it from a settings file is where the first attempt usually goes

/// wrong.

/// </summary>

public string McpServerTooltip =>

IsMcpServerRunning

? string.Format(Strings.Mcp_Tooltip_Running, _mcpServerService.Endpoint)

: Strings.Mcp_Tooltip_Stopped;

public ICommand RestoreCommand { get; }

public TreeViewModel? TreeViewModel

{

get => _treeViewModel;

set

{

_treeViewModel = value;

OnPropertyChanged();

}

}

public AdvancedSearchViewModel? SearchViewModel

{

get => _searchViewModel;

set

{

_searchViewModel = value;

OnPropertyChanged();

}

}

/// <summary>The in-graph search (its box lives in the web tab tool bar).</summary>

public GraphSearchViewModel? GraphSearchViewModel

{

get;

set

{

field = value;

OnPropertyChanged();

}

}

public int SelectedRightTabIndex

{

get;

set

{

if (value == field)

{

return;

}

field = value;

OnPropertyChanged();

}

} = TabIndices.Right.WebView; // Web View is the start-up tab (so its WebView2 inits eagerly)

public bool IsCanvasHintsVisible

{

get;

set

{

if (field == value)

{

return;

}

field = value;

OnPropertyChanged();

}

} = true;

public ICommand OpenFilterDialogCommand { get; }

public ICommand OpenSettingsDialogCommand { get; }

public ObservableCollection<IStatistic> Statistics

{

set

{

field = value;

OnPropertyChanged();

}

get;

} = [];

public int SelectedLeftTabIndex

{

get;

set

{

if (value == field)

{

return;

}

field = value;

InfoPanelViewModel?.Hide(value != TabIndices.Left.InfoPanel);

OnPropertyChanged();

}

}

public List<IAnalyzer> Analyzers

{

get => _analyzerManager.All.ToList();

}

/// <summary>

/// Bound by the import menu, so a new importer needs no XAML change - exactly like Analyzers.

/// The C# solution import leads because it is the primary one and the split button's default.

/// </summary>

public List<ImportMenuEntry> ImportMenuEntries

{

get =>

[

new(Strings.ImportSolution_Label, Strings.Import_DialogTitle, LoadSolutionCommand, null),

.. _importerManager.All.Select(i => new ImportMenuEntry(i.Name, i.Description, ExecuteImporterCommand, i.Id))

];

}

public ICommand CopyBitmapToClipboardCommand { get; set; }

public bool IsGraphToolPanelVisible

{

get;

set

{

if (value == field)

{

return;

}

field = value;

OnPropertyChanged();

}

} = true;

public string Title

{

get

{

var title = Strings.AppTitle;

if (_projectService.RequiresNewFilePath)

{

// Don't show filename when no longer valid

title = title + " - " + "Refactored (model changed)";

}

else if (!string.IsNullOrEmpty(_projectService.CurrentFilePath))

{

title = title + " - " + _projectService.CurrentFilePath;

}

if (_projectService.IsDirty)

{

title += " *";

}

return title;

}

}

public event PropertyChangedEventHandler? PropertyChanged;

/// <summary>Raised when a dynamic tab should become the active one (new or updated result).</summary>

public event Action<ITabViewModel>? DynamicTabActivated;

private void OnBusyStateChanged(BusyState state)

{

IsLoading = state.IsLoading;

LoadMessage = state.Message;

}

private void OnAnalyzerDataChanged(object? sender, EventArgs e)

{

if (_analyzerManager.IsDirty())

{

_projectService.MarkDirty();

}

}

private void OnProjectLoaded(object? sender, ProjectLoadedEventArgs e)

{

RestoreProjectData(e.Data);

RefreshMru();

LoadMessage = string.Empty;

IsCanvasHintsVisible = false;

IsLoading = false;

}

private void OnProjectSaved(object? sender, string filePath)

{

RefreshMru();

}

private void OnDirtyStateChanged(object? sender, EventArgs e)

{

OnPropertyChanged(nameof(Title));

}

private void RefreshMru()

{

RecentFiles.Clear();

// Always a first browse command to avoid empty menu

RecentFiles.Add(new Mru(Strings.Browse, LoadProjectCommand) { ImageSource = "/Resources/load_project.png" });

foreach (var path in _userSettings.RecentFiles.Where(File.Exists).Select(f => new Mru(f, OpenRecentFileCommand)))

{

RecentFiles.Add(path);

}

}

private void OnCopyCanvasToClipboard()

{

// The graph lives in the web view; it produces a PNG (cy.png) and copies it.

_messaging.Publish(new ExportWebGraphRequest(WebGraphExportFormat.ClipboardPng));

}

private void OnExecuteAnalyzer(string id)

{

if (_codeGraph is null)

{

return;

}

_analyzerManager.GetAnalyzer(id).Analyze(_codeGraph);

}

private void OnShowGallery()

{

if (_graphViewModel is null || _gallery is null || _codeGraph is null)

{

return;

}

var editor = new GalleryEditor

{

Owner = Application.Current.MainWindow

};

var viewModel = new GalleryEditorViewModel(_gallery,

PreviewSession,

AddSession,

RemoveSession,

LoadSession);

var backup = _graphViewModel.GetSession();

var hasPreviewedSession = false;

editor.DataContext = viewModel;

editor.WindowStartupLocation = WindowStartupLocation.CenterScreen;

var result = editor.ShowDialog();

if (result is false && hasPreviewedSession)

{

// Restore original state if previews were shown

_graphViewModel.LoadSession(backup, false);

}

return;

void RemoveSession(GraphSession session)

{

_gallery.Sessions.Remove(session);

_projectService.MarkDirty();

}

void PreviewSession(GraphSession session)

{

_graphViewModel.LoadSession(session, false);

hasPreviewedSession = true;

}

void LoadSession(GraphSession session)

{

_graphViewModel.LoadSession(session, true);

editor.DialogResult = true;

}

GraphSession AddSession(string name)

{

var session = _graphViewModel.GetSession();

session.Name = name;

_gallery.AddSession(session);

_projectService.MarkDirty();

return session;

}

}

private void OpenLegendDialog()

{

if (_openedLegendDialog != null)

{

_openedLegendDialog.Activate();

return;

}

_openedLegendDialog = new LegendDialog

{

Owner = Application.Current.MainWindow,

WindowStartupLocation = WindowStartupLocation.CenterOwner

};

_openedLegendDialog.Closed += OnLegendDialogClosed;

_openedLegendDialog.Show();

}

private void OnLegendDialogClosed(object? sender, EventArgs e)

{

_openedLegendDialog!.Closed -= OnLegendDialogClosed;

_openedLegendDialog = null;

IsLegendOpen = false;

}

private void OnOpenFilterDialog()

{

var filterDialog = new FilterDialog(_projectExclusionFilters);

filterDialog.ShowDialog();

}

private void OnOpenSettingsDialog()

{

var settingsDialog = new SettingsDialog(_applicationSettings, _userSettings)

{

Owner = Application.Current.MainWindow,

WindowStartupLocation = WindowStartupLocation.CenterOwner

};

if (settingsDialog.ShowDialog() == true)

{

_applicationSettings = settingsDialog.AppSettings;

_userSettings = settingsDialog.UserPreferences;

SourceLocationNavigator.PreferredEditor = _userSettings.PreferredEditor;

SaveSettings();

}

}

private void SaveSettings()

{

try

{

var appSettingsPath = Path.Join(Directory.GetCurrentDirectory(), "appsettings.json");

_applicationSettings.Save(appSettingsPath);

_userSettings.Save();

}

catch (Exception ex)

{

_ui.ShowError($"{Strings.Settings_Save_Error} {ex.Message}");

}

}

private void Search()

{

try

{

IsLoading = true;

// The search is quite fast but updating the tree view requires some time

// So running this in a background task has no effect at all.

TreeViewModel?.ExecuteSearch();

}

catch (Exception ex)

{

_ui.ShowError(string.Format(Strings.OperationFailed_Message, ex.Message));

}

finally

{

IsLoading = false;

}

}

/// <summary>

/// Exports the whole project to dsi.

/// </summary>

private void OnExportToDsi()

{

_exporter.ToDsi(_codeGraph);

}

public void HandleShowTabularData(ShowTabularDataRequest tabularDataRequest)

{

ShowTabularDataTab(tabularDataRequest.Id, tabularDataRequest.Title, tabularDataRequest.Table);

}

public void HandleShowHierarchicalData(ShowHierarchicalDataRequest hierarchicalDataRequest)

{

ShowHierarchicalDataTab(hierarchicalDataRequest.Id, hierarchicalDataRequest.Title, hierarchicalDataRequest.Data, hierarchicalDataRequest.OpenMode);

}

/// <summary>

/// Creates a new dynamic tab for <paramref name="id" />, or - if one already exists - updates

/// it in place, so re-running the same analyzer replaces its own tab instead of piling up

/// duplicates. Either way the tab is brought to the front.

/// </summary>

private void ShowTabularDataTab(string id, string title, Table table)

{

var tab = DynamicTabs.OfType<DynamicTabViewModel>().FirstOrDefault(t => t.Id == id);

if (tab is null)

{

tab = new DynamicTabViewModel(id, title, table);

tab.CloseCommand = new WpfCommand(() => DynamicTabs.Remove(tab));

DynamicTabs.Add(tab);

}

else

{

tab.Title = title;

tab.Table = table;

}

DynamicTabActivated?.Invoke(tab);

}

/// <summary>

/// Same as <see cref="ShowTabularDataTab" />, but for tree-map style hierarchical results.

/// </summary>

private void ShowHierarchicalDataTab(string id, string title, HierarchicalDataContext data, RequestOpenMode openMode = RequestOpenMode.Normal)

{

var tab = DynamicTabs.OfType<HierarchicalTabViewModel>().FirstOrDefault(t => t.Id == id);

if (tab is null)

{

if (openMode == RequestOpenMode.UpdateOnly)

{

return;

}

tab = new HierarchicalTabViewModel(id, title, data);

tab.CloseCommand = new WpfCommand(() => DynamicTabs.Remove(tab));

DynamicTabs.Add(tab);

}

else

{

tab.Title = title;

tab.Data = data;

}

DynamicTabActivated?.Invoke(tab);

}

/// <summary>

/// Same as <see cref="ShowTabularDataTab" />, but for the dependency structure matrix. There is only ever

/// one of it — it always shows the whole graph — so the id is fixed.

/// </summary>

private void ShowDsmTab(string id, string title, DsmMainViewModel matrix)

{

var tab = DynamicTabs.OfType<DsmTabViewModel>().FirstOrDefault(t => t.Id == id);

if (tab is null)

{

tab = new DsmTabViewModel(id, title, matrix);

var dsmTab = tab;

tab.CloseCommand = new WpfCommand(() => DynamicTabs.Remove(dsmTab));

tab.OpenFileCommand = new WpfCommand(() => OnOpenDsmFile(dsmTab));

DynamicTabs.Add(tab);

}

else

{

tab.Title = title;

tab.Matrix = matrix;

}

DynamicTabActivated?.Invoke(tab);

}

/// <summary>

/// Builds the dependency structure matrix over the whole type graph and shows it in its own tab.

/// </summary>

private async void OnShowDsm()

{

if (_codeGraph is null)

{

return;

}

DsmMainViewModel? matrix = null;

var codeGraph = _codeGraph;

try

{

IsLoading = true;

LoadMessage = Strings.BuildingDsm_Message;

await Task.Run(() => { matrix = DsmMatrixFactory.Create(codeGraph); });

}

catch (Exception ex)

{

_ui.ShowError(string.Format(Strings.OperationFailed_Message, ex.Message));

}

finally

{

LoadMessage = string.Empty;

IsLoading = false;

}

if (matrix is not null)

{

ShowDsmTab("dsm_id", Strings.Dsm_TabHeader, matrix);

}

}

/// <summary>

/// Opens a DsmSuite model file (.dsm) or analyzer intermediate (.dsi) into the given DSM tab,

/// replacing its matrix. The file dialog and the loading indicator live here, which is why the tab

/// delegates back to this via its <see cref="DsmTabViewModel.OpenFileCommand" />.

/// </summary>

private async void OnOpenDsmFile(DsmTabViewModel tab)

{

var path = _ui.ShowOpenFileDialog(

"DSM/DSI files (*.dsm;*.dsi)|*.dsm;*.dsi|All files (*.*)|*.*",

"Open DSM or DSI file");

if (string.IsNullOrEmpty(path))

{

return;

}

DsmMainViewModel? matrix = null;

try

{

IsLoading = true;

LoadMessage = Strings.BuildingDsm_Message;

await Task.Run(() => { matrix = DsmMatrixFactory.CreateFromFile(path); });

}

catch (Exception ex)

{

_ui.ShowError(string.Format(Strings.OperationFailed_Message, ex.Message));

}

finally

{

LoadMessage = string.Empty;

IsLoading = false;

}

if (matrix is not null)

{

tab.Matrix = matrix;

tab.Title = System.IO.Path.GetFileName(path);

}

}

private async void OnFindCycles()

{

if (_codeGraph is null)

{

return;

}

List<CycleGroup>? cycleGroups = null;

try

{

IsLoading = true;

LoadMessage = Strings.SearchingCycles_Message;

// The groups come back named after their most central element (see CycleFinder).

await Task.Run(() => { cycleGroups = CycleFinder.FindCycleGroups(_codeGraph); });

}

catch (Exception ex)

{

_ui.ShowError(string.Format(Strings.OperationFailed_Message, ex.Message));

}

finally

{

LoadMessage = string.Empty;

IsLoading = false;

}

if (cycleGroups != null)

{

_messaging.Publish(new CycleCalculationComplete(cycleGroups));

SelectedRightTabIndex = TabIndices.Right.Cycles;

}

}

private async void OnAiAdvise()

{

if (_graphViewModel is null)

{

return;

}

var endpoint = _userSettings.AiEndpoint;

if (string.IsNullOrWhiteSpace(endpoint) || !AiCredentialStorage.HasApiKey())

{

ToastManager.ShowWarning(Strings.AiAdvisor_NoEndpoint);

return;

}

var currentGraph = _graphViewModel.GetGraph();

if (currentGraph.Nodes.Count == 0)

{

return;

}

List<CycleGroup>? cycleGroups = null;

try

{

IsLoading = true;

LoadMessage = Strings.AiAdvisor_Analyzing;

await Task.Run(() => { cycleGroups = CycleFinder.FindCycleGroups(currentGraph); });

}

catch (Exception ex)

{

_ui.ShowError(string.Format(Strings.OperationFailed_Message, ex.Message));

return;

}

finally

{

LoadMessage = string.Empty;

IsLoading = false;

}

if (cycleGroups is not { Count: > 0 })

{

ToastManager.ShowWarning(Strings.AiAdvisor_NoCycles);

return;

}

string? response;

try

{

IsLoading = true;

LoadMessage = Strings.AiAdvisor_Querying;

var apiKey = AiCredentialStorage.LoadApiKey();

response = await _aiAdvisorService.GetCycleAdviceAsync(

cycleGroups[0], endpoint, apiKey, _userSettings.AiModel);

}

catch (AiClientException ex)

{

_ui.ShowError(ex.Message);

return;

}

catch (Exception ex)

{

_ui.ShowError(string.Format(Strings.OperationFailed_Message, ex.Message));

return;

}

finally

{

LoadMessage = string.Empty;

IsLoading = false;

}

if (!string.IsNullOrWhiteSpace(response))

{

AiAdvisorWindow.ShowAdvice(response, _ui);

}

}

private void OnGraphLayout()

{

// Full relayout: the web adapter re-runs its layout through the bus.

_messaging.Publish(new RelayoutGraphRequest());

}

private void OnGraphRefit()

{

// Recompute size and fit the view without re-running the layout. Web-only for now

_messaging.Publish(new RefitGraphRequest());

}

private void OnStopRendering()

{

// Abort a runaway render: the web adapter terminates its render process and reloads.

_messaging.Publish(new CancelWebRenderRequest());

}