HC_APTBS/ViewModels/ResultDisplayViewModel.cs

using System.Collections.Generic;
using System.Collections.ObjectModel;
using CommunityToolkit.Mvvm.ComponentModel;
using HC_APTBS.Models;

namespace HC_APTBS.ViewModels
{
    /// <summary>
    /// A single result row shown in the results grid for one receive parameter.
    /// </summary>
    public sealed partial class ResultRowViewModel : ObservableObject
    {
        [ObservableProperty] private string _phaseName     = string.Empty;
        [ObservableProperty] private string _parameterName = string.Empty;
        [ObservableProperty] private double _target;
        [ObservableProperty] private double _tolerance;
        [ObservableProperty] private double _average;
        [ObservableProperty] private bool   _passed;

        /// <summary>"PASS" or "FAIL".</summary>
        public string ResultLabel => Passed ? "PASS" : "FAIL";
    }

    /// <summary>
    /// ViewModel for the ResultDisplay user control.
    ///
    /// <para>
    /// Shows a flat table of all phase/parameter combinations with their
    /// measured average, target, tolerance, and pass/fail result.
    /// </para>
    /// </summary>
    public sealed partial class ResultDisplayViewModel : ObservableObject
    {
        // ── Properties ────────────────────────────────────────────────────────────

        /// <summary>Name of the test whose results are displayed.</summary>
        [ObservableProperty] private string _testName = string.Empty;

        /// <summary>Overall pass/fail for all displayed results.</summary>
        [ObservableProperty] private bool _overallPassed;

        /// <summary>All result rows.</summary>
        public ObservableCollection<ResultRowViewModel> Results { get; } = new();

        // ── Public API ────────────────────────────────────────────────────────────

        /// <summary>
        /// Populates the results table from a completed <see cref="TestDefinition"/>.
        /// </summary>
        public void LoadResults(TestDefinition test)
        {
            TestName = test.Name;
            Results.Clear();

            bool allPassed = true;
            foreach (var phase in test.Phases)
            {
                if (!phase.Enabled || phase.Receives == null) continue;
                foreach (var tp in phase.Receives)
                {
                    if (tp.Result == null) continue;
                    allPassed = allPassed && tp.Result.Passed;
                    Results.Add(new ResultRowViewModel
                    {
                        PhaseName     = phase.Name,
                        ParameterName = tp.Name,
                        Target        = tp.Value,
                        Tolerance     = tp.Tolerance,
                        Average       = tp.Result.Average,
                        Passed        = tp.Result.Passed
                    });
                }
            }
            OverallPassed = allPassed && Results.Count > 0;
        }

        /// <summary>Adds or updates a live measurement row during test execution.</summary>
        public void UpdateLiveValue(string phaseName, string paramName, double currentValue,
            double target, double tolerance)
        {
            foreach (var row in Results)
            {
                if (row.PhaseName == phaseName && row.ParameterName == paramName)
                {
                    row.Average = currentValue;
                    return;
                }
            }
            Results.Add(new ResultRowViewModel
            {
                PhaseName     = phaseName,
                ParameterName = paramName,
                Target        = target,
                Tolerance     = tolerance,
                Average       = currentValue
            });
        }

        /// <summary>
        /// Populates the results table from all completed tests in the pump's test list.
        /// Clears existing results first, then appends rows from every test that has results.
        /// </summary>
        /// <param name="tests">All test definitions for the current pump.</param>
        public void LoadAllResults(IReadOnlyList<TestDefinition> tests)
        {
            Results.Clear();
            bool allPassed = true;

            foreach (var test in tests)
            {
                foreach (var phase in test.Phases)
                {
                    if (!phase.Enabled || phase.Receives == null) continue;
                    foreach (var tp in phase.Receives)
                    {
                        if (tp.Result == null) continue;
                        allPassed = allPassed && tp.Result.Passed;
                        Results.Add(new ResultRowViewModel
                        {
                            PhaseName     = phase.Name,
                            ParameterName = tp.Name,
                            Target        = tp.Value,
                            Tolerance     = tp.Tolerance,
                            Average       = tp.Result.Average,
                            Passed        = tp.Result.Passed
                        });
                    }
                }
            }

            TestName      = tests.Count > 0 ? "All Tests" : string.Empty;
            OverallPassed = allPassed && Results.Count > 0;
        }

        /// <summary>Clears all results.</summary>
        public void Clear()
        {
            Results.Clear();
            OverallPassed = false;
        }
    }
}