XplorePlane/XplorePlane/ViewModels/Cnc/CncNodeViewModel.cs

using Prism.Mvvm;
using System;
using System.Collections.ObjectModel;
using System.Windows.Media.Imaging;
using XplorePlane.Models;

namespace XplorePlane.ViewModels.Cnc
{
    /// <summary>
    /// CNC node ViewModel with editable properties and tree children.
    /// </summary>
    public class CncNodeViewModel : BindableBase
    {
        private readonly Action<CncNodeViewModel, CncNode> _modelChangedCallback;
        private CncNode _model;
        private string _icon;
        private bool _isExpanded = true;
        private NodeExecutionState _executionState = NodeExecutionState.Idle;
        private double _executionProgressPercent;

        /// <summary>执行后缓存的流水线输出图像（仅 InspectionModuleNode）</summary>
        public BitmapSource ResultImage { get; set; }

        public CncNodeViewModel(CncNode model, Action<CncNodeViewModel, CncNode> modelChangedCallback)
        {
            _model = model ?? throw new ArgumentNullException(nameof(model));
            _modelChangedCallback = modelChangedCallback ?? throw new ArgumentNullException(nameof(modelChangedCallback));
            _icon = GetIconForNodeType(model.NodeType);
            Children = new ObservableCollection<CncNodeViewModel>();
        }

        public ObservableCollection<CncNodeViewModel> Children { get; }

        public CncNode Model => _model;

        public Guid Id => _model.Id;

        public int Index => _model.Index;

        public string Name
        {
            get => _model.Name;
            set => UpdateModel(_model with { Name = value ?? string.Empty });
        }

        public bool IsReadOnlyNodeProperties => IsReferencePoint || IsSavePosition;

        public CncNodeType NodeType => _model.NodeType;

        public string NodeTypeDisplay => NodeType.ToString();

        public string Icon
        {
            get => _icon;
            private set => SetProperty(ref _icon, value);
        }

        public bool IsExpanded
        {
            get => _isExpanded;
            set => SetProperty(ref _isExpanded, value);
        }

        public bool HasChildren => Children.Count > 0;

        public NodeExecutionState ExecutionState
        {
            get => _executionState;
            set
            {
                if (SetProperty(ref _executionState, value))
                {
                    RaisePropertyChanged(nameof(IsRunningNode));
                    RaisePropertyChanged(nameof(IsSucceededNode));
                    RaisePropertyChanged(nameof(IsFailedNode));
                    RaisePropertyChanged(nameof(IsDelayProgressVisible));
                }
            }
        }

        public bool IsRunningNode   => ExecutionState == NodeExecutionState.Running;
        public bool IsSucceededNode => ExecutionState == NodeExecutionState.Succeeded;
        public bool IsFailedNode    => ExecutionState == NodeExecutionState.Failed;
        public bool IsDelayProgressVisible => IsWaitDelay && IsRunningNode;

        public double ExecutionProgressPercent
        {
            get => _executionProgressPercent;
            set
            {
                if (SetProperty(ref _executionProgressPercent, Math.Clamp(value, 0d, 100d)))
                {
                    RaisePropertyChanged(nameof(ExecutionProgressText));
                }
            }
        }

        public string ExecutionProgressText => $"{ExecutionProgressPercent:0}%";

        public bool IsReferencePoint => _model is ReferencePointNode;
        public bool IsSaveNode => _model is SaveNodeNode;
        public bool IsSaveNodeWithImage => _model is SaveNodeWithImageNode;
        public bool IsSavePosition => _model is SavePositionNode;
        public bool IsInspectionModule => _model is InspectionModuleNode;
        public bool IsInspectionMarker => _model is InspectionMarkerNode;
        public bool IsPauseDialog => _model is PauseDialogNode;
        public bool IsWaitDelay => _model is WaitDelayNode;
        public bool IsCompleteProgram => _model is CompleteProgramNode;
        public bool IsPositionChild => _model is InspectionModuleNode or InspectionMarkerNode;
        public bool IsMotionSnapshotNode => _model is ReferencePointNode or SaveNodeNode or SaveNodeWithImageNode or SavePositionNode;
        public string RelationTag => _model switch
        {
            SavePositionNode => "位置",
            InspectionModuleNode => "检测模块",
            InspectionMarkerNode => "检测标记",
            _ => string.Empty
        };

        public double StageX
        {
            get => _model switch
            {
                ReferencePointNode rp => rp.StageX,
                SaveNodeNode sn => sn.MotionState.StageX,
                SaveNodeWithImageNode sni => sni.MotionState.StageX,
                SavePositionNode sp => sp.MotionState.StageX,
                _ => 0d
            };
            set => UpdateMotion(value, MotionAxis.StageX);
        }

        public double StageY
        {
            get => _model switch
            {
                ReferencePointNode rp => rp.StageY,
                SaveNodeNode sn => sn.MotionState.StageY,
                SaveNodeWithImageNode sni => sni.MotionState.StageY,
                SavePositionNode sp => sp.MotionState.StageY,
                _ => 0d
            };
            set => UpdateMotion(value, MotionAxis.StageY);
        }

        public double SourceZ
        {
            get => _model switch
            {
                ReferencePointNode rp => rp.SourceZ,
                SaveNodeNode sn => sn.MotionState.SourceZ,
                SaveNodeWithImageNode sni => sni.MotionState.SourceZ,
                SavePositionNode sp => sp.MotionState.SourceZ,
                _ => 0d
            };
            set => UpdateMotion(value, MotionAxis.SourceZ);
        }

        public double DetectorZ
        {
            get => _model switch
            {
                ReferencePointNode rp => rp.DetectorZ,
                SaveNodeNode sn => sn.MotionState.DetectorZ,
                SaveNodeWithImageNode sni => sni.MotionState.DetectorZ,
                SavePositionNode sp => sp.MotionState.DetectorZ,
                _ => 0d
            };
            set => UpdateMotion(value, MotionAxis.DetectorZ);
        }

        public double DetectorSwing
        {
            get => _model switch
            {
                ReferencePointNode rp => rp.DetectorSwing,
                SaveNodeNode sn => sn.MotionState.DetectorSwing,
                SaveNodeWithImageNode sni => sni.MotionState.DetectorSwing,
                SavePositionNode sp => sp.MotionState.DetectorSwing,
                _ => 0d
            };
            set => UpdateMotion(value, MotionAxis.DetectorSwing);
        }

        public double StageRotation
        {
            get => _model switch
            {
                ReferencePointNode rp => rp.StageRotation,
                SaveNodeNode sn => sn.MotionState.StageRotation,
                SaveNodeWithImageNode sni => sni.MotionState.StageRotation,
                SavePositionNode sp => sp.MotionState.StageRotation,
                _ => 0d
            };
            set => UpdateMotion(value, MotionAxis.StageRotation);
        }

        public double FixtureRotation
        {
            get => _model switch
            {
                ReferencePointNode rp => rp.FixtureRotation,
                SaveNodeNode sn => sn.MotionState.FixtureRotation,
                SaveNodeWithImageNode sni => sni.MotionState.FixtureRotation,
                SavePositionNode sp => sp.MotionState.FixtureRotation,
                _ => 0d
            };
            set => UpdateMotion(value, MotionAxis.FixtureRotation);
        }

        public double FOD
        {
            get => _model switch
            {
                ReferencePointNode rp => rp.FOD,
                SaveNodeNode sn => sn.MotionState.FOD,
                SaveNodeWithImageNode sni => sni.MotionState.FOD,
                SavePositionNode sp => sp.MotionState.FOD,
                _ => 0d
            };
            set => UpdateMotion(value, MotionAxis.FOD);
        }

        public double FDD
        {
            get => _model switch
            {
                ReferencePointNode rp => rp.FDD,
                SaveNodeNode sn => sn.MotionState.FDD,
                SaveNodeWithImageNode sni => sni.MotionState.FDD,
                SavePositionNode sp => sp.MotionState.FDD,
                _ => 0d
            };
            set => UpdateMotion(value, MotionAxis.FDD);
        }

        public double Magnification
        {
            get => _model switch
            {
                ReferencePointNode rp => rp.Magnification,
                SaveNodeNode sn => sn.MotionState.Magnification,
                SaveNodeWithImageNode sni => sni.MotionState.Magnification,
                SavePositionNode sp => sp.MotionState.Magnification,
                _ => 0d
            };
            set => UpdateMotion(value, MotionAxis.Magnification);
        }

        public bool IsRayOn
        {
            get => _model switch
            {
                ReferencePointNode rp => rp.IsRayOn,
                SaveNodeNode sn => sn.RaySourceState.IsOn,
                SaveNodeWithImageNode sni => sni.RaySourceState.IsOn,
                _ => false
            };
            set => UpdateRaySource(isOn: value);
        }

        public double Voltage
        {
            get => _model switch
            {
                ReferencePointNode rp => rp.Voltage,
                SaveNodeNode sn => sn.RaySourceState.Voltage,
                SaveNodeWithImageNode sni => sni.RaySourceState.Voltage,
                _ => 0d
            };
            set => UpdateRaySource(voltage: value);
        }

        public double Current
        {
            get => _model is ReferencePointNode rp ? rp.Current : 0d;
            set
            {
                if (_model is ReferencePointNode rp)
                {
                    UpdateModel(rp with { Current = value });
                }
            }
        }

        public double Power
        {
            get => _model switch
            {
                SaveNodeNode sn => sn.RaySourceState.Power,
                SaveNodeWithImageNode sni => sni.RaySourceState.Power,
                _ => 0d
            };
            set => UpdateRaySource(power: value);
        }

        public bool DetectorConnected
        {
            get => _model switch
            {
                SaveNodeNode sn => sn.DetectorState.IsConnected,
                SaveNodeWithImageNode sni => sni.DetectorState.IsConnected,
                _ => false
            };
            set => UpdateDetector(isConnected: value);
        }

        public bool DetectorAcquiring
        {
            get => _model switch
            {
                SaveNodeNode sn => sn.DetectorState.IsAcquiring,
                SaveNodeWithImageNode sni => sni.DetectorState.IsAcquiring,
                _ => false
            };
            set => UpdateDetector(isAcquiring: value);
        }

        public double FrameRate
        {
            get => _model switch
            {
                SaveNodeNode sn => sn.DetectorState.FrameRate,
                SaveNodeWithImageNode sni => sni.DetectorState.FrameRate,
                _ => 0d
            };
            set => UpdateDetector(frameRate: value);
        }

        public string Resolution
        {
            get => _model switch
            {
                SaveNodeNode sn => sn.DetectorState.Resolution,
                SaveNodeWithImageNode sni => sni.DetectorState.Resolution,
                _ => string.Empty
            };
            set => UpdateDetector(resolution: value ?? string.Empty);
        }

        public string ImageFileName
        {
            get => _model is SaveNodeWithImageNode sni ? sni.ImageFileName : string.Empty;
            set
            {
                if (_model is SaveNodeWithImageNode sni)
                {
                    UpdateModel(sni with { ImageFileName = value ?? string.Empty });
                }
            }
        }

        public bool SaveImage
        {
            get => _model is SavePositionNode sp && sp.SaveImage;
            set
            {
                if (_model is SavePositionNode sp)
                {
                    UpdateModel(sp with { SaveImage = value });
                }
            }
        }

        public string PipelineName
        {
            get => _model is InspectionModuleNode im ? im.Pipeline?.Name ?? string.Empty : string.Empty;
            set
            {
                if (_model is InspectionModuleNode im)
                {
                    var pipeline = im.Pipeline ?? new PipelineModel();
                    pipeline.Name = value ?? string.Empty;
                    UpdateModel(im with { Pipeline = pipeline });
                }
            }
        }

        public PipelineModel Pipeline
        {
            get => _model is InspectionModuleNode im ? im.Pipeline : null;
            set
            {
                if (_model is InspectionModuleNode im)
                {
                    UpdateModel(im with { Pipeline = value ?? new PipelineModel() });
                }
            }
        }

        public string MarkerType
        {
            get => _model is InspectionMarkerNode mk ? mk.MarkerType : string.Empty;
            set
            {
                if (_model is InspectionMarkerNode mk)
                {
                    UpdateModel(mk with { MarkerType = value ?? string.Empty });
                }
            }
        }

        public double MarkerX
        {
            get => _model is InspectionMarkerNode mk ? mk.MarkerX : 0d;
            set
            {
                if (_model is InspectionMarkerNode mk)
                {
                    UpdateModel(mk with { MarkerX = value });
                }
            }
        }

        public double MarkerY
        {
            get => _model is InspectionMarkerNode mk ? mk.MarkerY : 0d;
            set
            {
                if (_model is InspectionMarkerNode mk)
                {
                    UpdateModel(mk with { MarkerY = value });
                }
            }
        }

        public string DialogTitle
        {
            get => _model is PauseDialogNode pd ? pd.DialogTitle : string.Empty;
            set
            {
                if (_model is PauseDialogNode pd)
                {
                    UpdateModel(pd with { DialogTitle = value ?? string.Empty });
                }
            }
        }

        public string DialogMessage
        {
            get => _model is PauseDialogNode pd ? pd.DialogMessage : string.Empty;
            set
            {
                if (_model is PauseDialogNode pd)
                {
                    UpdateModel(pd with { DialogMessage = value ?? string.Empty });
                }
            }
        }

        public int DelayMilliseconds
        {
            get => _model is WaitDelayNode wd ? wd.DelayMilliseconds : 0;
            set
            {
                if (_model is WaitDelayNode wd)
                {
                    UpdateModel(wd with { DelayMilliseconds = value });
                }
            }
        }

        public void ReplaceModel(CncNode model)
        {
            _model = model ?? throw new ArgumentNullException(nameof(model));
            Icon = GetIconForNodeType(model.NodeType);
            RaiseAllPropertiesChanged();
        }

        public static string GetIconForNodeType(CncNodeType nodeType)
        {
            return nodeType switch
            {
                CncNodeType.ReferencePoint => "/Assets/Icons/reference.png",
                CncNodeType.SaveNodeWithImage => "/Assets/Icons/saveall.png",
                CncNodeType.SaveNode => "/Assets/Icons/save.png",
                CncNodeType.SavePosition => "/Assets/Icons/add-pos.png",
                CncNodeType.InspectionModule => "/Assets/Icons/Module.png",
                CncNodeType.InspectionMarker => "/Assets/Icons/mark.png",
                CncNodeType.PauseDialog => "/Assets/Icons/message.png",
                CncNodeType.WaitDelay => "/Assets/Icons/wait.png",
                CncNodeType.CompleteProgram => "/Assets/Icons/finish.png",
                _ => "/Assets/Icons/cnc.png",
            };
        }

        private void UpdateMotion(double value, MotionAxis axis)
        {
            switch (_model)
            {
                case ReferencePointNode rp:
                    UpdateModel(axis switch
                    {
                        MotionAxis.StageX => rp with { StageX = value },
                        MotionAxis.StageY => rp with { StageY = value },
                        MotionAxis.SourceZ => rp with { SourceZ = value },
                        MotionAxis.DetectorZ => rp with { DetectorZ = value },
                        MotionAxis.DetectorSwing => rp with { DetectorSwing = value },
                        MotionAxis.StageRotation => rp with { StageRotation = value },
                        MotionAxis.FixtureRotation => rp with { FixtureRotation = value },
                        MotionAxis.FOD => rp with { FOD = value },
                        MotionAxis.FDD => rp with { FDD = value },
                        MotionAxis.Magnification => rp with { Magnification = value },
                        _ => rp
                    });
                    break;
                case SaveNodeNode sn:
                    UpdateModel(sn with { MotionState = UpdateMotionState(sn.MotionState, axis, value) });
                    break;
                case SaveNodeWithImageNode sni:
                    UpdateModel(sni with { MotionState = UpdateMotionState(sni.MotionState, axis, value) });
                    break;
                case SavePositionNode sp:
                    UpdateModel(sp with { MotionState = UpdateMotionState(sp.MotionState, axis, value) });
                    break;
            }
        }

        private void UpdateRaySource(bool? isOn = null, double? voltage = null, double? current = null, double? power = null)
        {
            switch (_model)
            {
                case ReferencePointNode rp:
                    UpdateModel(rp with
                    {
                        IsRayOn = isOn ?? rp.IsRayOn,
                        Voltage = voltage ?? rp.Voltage,
                        Current = current ?? rp.Current
                    });
                    break;
                case SaveNodeNode sn:
                    UpdateModel(sn with
                    {
                        RaySourceState = sn.RaySourceState with
                        {
                            IsOn = isOn ?? sn.RaySourceState.IsOn,
                            Voltage = voltage ?? sn.RaySourceState.Voltage,
                            Power = power ?? sn.RaySourceState.Power
                        }
                    });
                    break;
                case SaveNodeWithImageNode sni:
                    UpdateModel(sni with
                    {
                        RaySourceState = sni.RaySourceState with
                        {
                            IsOn = isOn ?? sni.RaySourceState.IsOn,
                            Voltage = voltage ?? sni.RaySourceState.Voltage,
                            Power = power ?? sni.RaySourceState.Power
                        }
                    });
                    break;
            }
        }

        private void UpdateDetector(bool? isConnected = null, bool? isAcquiring = null, double? frameRate = null, string resolution = null)
        {
            switch (_model)
            {
                case SaveNodeNode sn:
                    UpdateModel(sn with
                    {
                        DetectorState = sn.DetectorState with
                        {
                            IsConnected = isConnected ?? sn.DetectorState.IsConnected,
                            IsAcquiring = isAcquiring ?? sn.DetectorState.IsAcquiring,
                            FrameRate = frameRate ?? sn.DetectorState.FrameRate,
                            Resolution = resolution ?? sn.DetectorState.Resolution
                        }
                    });
                    break;
                case SaveNodeWithImageNode sni:
                    UpdateModel(sni with
                    {
                        DetectorState = sni.DetectorState with
                        {
                            IsConnected = isConnected ?? sni.DetectorState.IsConnected,
                            IsAcquiring = isAcquiring ?? sni.DetectorState.IsAcquiring,
                            FrameRate = frameRate ?? sni.DetectorState.FrameRate,
                            Resolution = resolution ?? sni.DetectorState.Resolution
                        }
                    });
                    break;
            }
        }

        private static MotionState UpdateMotionState(MotionState state, MotionAxis axis, double value)
        {
            return axis switch
            {
                MotionAxis.StageX => state with { StageX = value },
                MotionAxis.StageY => state with { StageY = value },
                MotionAxis.SourceZ => state with { SourceZ = value },
                MotionAxis.DetectorZ => state with { DetectorZ = value },
                MotionAxis.DetectorSwing => state with { DetectorSwing = value },
                MotionAxis.StageRotation => state with { StageRotation = value },
                MotionAxis.FixtureRotation => state with { FixtureRotation = value },
                MotionAxis.FOD => state with { FOD = value },
                MotionAxis.FDD => state with { FDD = value },
                MotionAxis.Magnification => state with { Magnification = value },
                _ => state
            };
        }

        private void UpdateModel(CncNode updatedModel)
        {
            _model = updatedModel ?? throw new ArgumentNullException(nameof(updatedModel));
            RaiseAllPropertiesChanged();
            _modelChangedCallback(this, updatedModel);
        }

        private void RaiseAllPropertiesChanged()
        {
            RaisePropertyChanged(nameof(Model));
            RaisePropertyChanged(nameof(Id));
            RaisePropertyChanged(nameof(Index));
            RaisePropertyChanged(nameof(Name));
            RaisePropertyChanged(nameof(NodeType));
            RaisePropertyChanged(nameof(NodeTypeDisplay));
            RaisePropertyChanged(nameof(Icon));
            RaisePropertyChanged(nameof(IsReferencePoint));
            RaisePropertyChanged(nameof(IsSaveNode));
            RaisePropertyChanged(nameof(IsSaveNodeWithImage));
            RaisePropertyChanged(nameof(IsSavePosition));
            RaisePropertyChanged(nameof(IsInspectionModule));
            RaisePropertyChanged(nameof(IsInspectionMarker));
            RaisePropertyChanged(nameof(IsPauseDialog));
            RaisePropertyChanged(nameof(IsWaitDelay));
            RaisePropertyChanged(nameof(IsCompleteProgram));
            RaisePropertyChanged(nameof(IsPositionChild));
            RaisePropertyChanged(nameof(IsMotionSnapshotNode));
            RaisePropertyChanged(nameof(RelationTag));
            RaisePropertyChanged(nameof(StageX));
            RaisePropertyChanged(nameof(StageY));
            RaisePropertyChanged(nameof(SourceZ));
            RaisePropertyChanged(nameof(DetectorZ));
            RaisePropertyChanged(nameof(DetectorSwing));
            RaisePropertyChanged(nameof(StageRotation));
            RaisePropertyChanged(nameof(FixtureRotation));
            RaisePropertyChanged(nameof(FOD));
            RaisePropertyChanged(nameof(FDD));
            RaisePropertyChanged(nameof(Magnification));
            RaisePropertyChanged(nameof(IsRayOn));
            RaisePropertyChanged(nameof(Voltage));
            RaisePropertyChanged(nameof(Current));
            RaisePropertyChanged(nameof(Power));
            RaisePropertyChanged(nameof(DetectorConnected));
            RaisePropertyChanged(nameof(DetectorAcquiring));
            RaisePropertyChanged(nameof(FrameRate));
            RaisePropertyChanged(nameof(Resolution));
            RaisePropertyChanged(nameof(ImageFileName));
            RaisePropertyChanged(nameof(SaveImage));
            RaisePropertyChanged(nameof(Pipeline));
            RaisePropertyChanged(nameof(PipelineName));
            RaisePropertyChanged(nameof(MarkerType));
            RaisePropertyChanged(nameof(MarkerX));
            RaisePropertyChanged(nameof(MarkerY));
            RaisePropertyChanged(nameof(DialogTitle));
            RaisePropertyChanged(nameof(DialogMessage));
            RaisePropertyChanged(nameof(DelayMilliseconds));
            RaisePropertyChanged(nameof(ExecutionState));
            RaisePropertyChanged(nameof(IsRunningNode));
            RaisePropertyChanged(nameof(IsSucceededNode));
            RaisePropertyChanged(nameof(IsFailedNode));
            RaisePropertyChanged(nameof(IsDelayProgressVisible));
            RaisePropertyChanged(nameof(ExecutionProgressPercent));
            RaisePropertyChanged(nameof(ExecutionProgressText));
        }

        private enum MotionAxis
        {
            StageX,
            StageY,
            SourceZ,
            DetectorZ,
            DetectorSwing,
            StageRotation,
            FixtureRotation,
            FOD,
            FDD,
            Magnification
        }
    }
}