SWRIS-HD/Pages/ParameterDialog.xaml.cs

using Panuon.WPF.UI;
using SWRIS.Core;
using SWRIS.Enums;
using SWRIS.Events;
using SWRIS.Extensions;
using SWRIS.Models;
using SWRIS.Models.ViewModel;
using System;
using System.Linq;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls.Primitives;
using System.Windows.Input;

namespace SWRIS.Pages
{
    /// <summary>
    /// ParameterDialog.xaml 的交互逻辑
    /// </summary>
    public partial class ParameterDialog : WindowX
    {
        private string _serialNo;
        private string _ipAddress;
        private Socket _clientSocket;
        private byte _runningMode = 0;
        private EquipmentSettingViewModel Equipment { get; set; }

        public ParameterDialog(EquipmentModel equipment, Socket clientSocket, RunningStatus runningStatus)
        {
            InitializeComponent();
            _serialNo = equipment.SerialNo;
            _ipAddress = equipment.IpAddress;
            _clientSocket = clientSocket;
            _runningMode = GetRunningStatusByte(runningStatus);
            Equipment = equipment.ToEquipmentSettingViewModel(runningStatus);
            Equipment.IsConnected = _clientSocket != null && _clientSocket.Connected;
            if (Equipment.IsConnected)
            {
                App.TcpServer.SendGetTwistFactorData(_serialNo, _clientSocket);
                App.TcpServer.ClockResultReceived += TcpServer_ClockResultReceived;
                App.TcpServer.EncoderDirectionResultReceived += TcpServer_EncoderDirectionResultReceived;
            }
            DataContext = Equipment;
        }

        private void TcpServer_EncoderDirectionResultReceived(object sender, EncoderDirectionResultReceivedEventArgs e)
        {
            Equipment.Parameter.EncoderDirection = e.Direction;
        }

        private void TcpServer_ClockResultReceived(object sender, ClockResultReceivedEventArgs e)
        {
            Equipment.Parameter.SystemTime = e.Timestamp.TimestampToDateTime();
        }

        protected async Task SetParameter()
        {
            bool isConnected = _clientSocket != null && _clientSocket.Connected;
            EquipmentModel equipment;
            if (isConnected)
            {
                // 已连接：后台同步参数到设备
                equipment = await Task.Run(() =>
                {
                    EquipmentModel eq = Equipment.ToEquipmentModel();
                    EquipmentDataModel equipmentData = App.DataCenter.Equipments.FirstOrDefault(c => c.RopeNumber == eq.RopeNumber);
                    var runningStatus = equipmentData?.RunningStatus ?? RunningStatus.SpatialNormal;
                    eq.ToEquipmentDataModel(equipmentData);
                    StartOrStopDetection(equipmentData, RunningStatus.Stopped);
                    Thread.Sleep(1000);
                    App.TcpServer.SendSyncParameters(eq.Parameter, Equipment.SerialNo, _clientSocket);
                    Thread.Sleep(300);
                    App.TcpServer.SendTurnLiveStreamData(true, _serialNo, _clientSocket);
                    Thread.Sleep(1000);
                    StartOrStopDetection(equipmentData, runningStatus);
                    return eq;
                });
            }
            else
            {
                // 未连接：仅转换模型
                equipment = await Task.Run(() => Equipment.ToEquipmentModel());
            }
            // 保存配置
            if (!ConfigHelper.SetEquipment(equipment))
                return;

            DialogResult = true;
            App.UpdateEquipment(equipment);
            NoticeBox.Show(isConnected ? "参数设置成功" : "参数已保存（未连接设备，仅保存到配置文件）",
                           "通知",
                           isConnected ? MessageBoxIcon.Success : MessageBoxIcon.Info,
                           true,
                           5000);
        }

        private void StartOrStopDetection(EquipmentDataModel equipmentData, RunningStatus runningStatus)
        {
            byte runningMode;
            if (runningStatus.HasFlag(RunningStatus.TemporalNormal))
            {
                // 记录本次请求的检测模式，0x06 应答确认时据此恢复正确模式
                equipmentData.MarkPreRunning(RunningStatus.TemporalNormal);
                runningMode = (byte)RunningStatus.TemporalNormal;
            }
            else if (runningStatus.HasFlag(RunningStatus.SpatialNormal))
            {
                equipmentData.MarkPreRunning(RunningStatus.SpatialNormal);
                runningMode = (byte)RunningStatus.SpatialNormal;
            }
            else
            {
                equipmentData.MarkPreStatus(RunningStatus.PreStop);
                runningMode = (byte)RunningStatus.Stopped;
            }

            App.TcpServer.SendStartOrStopDetection(runningMode, _serialNo, _clientSocket);
        }
        private byte GetRunningStatusByte(RunningStatus runningStatus)
        {
            // 优先级：TemporalNormal > SpatialNormal > Stopped
            if (runningStatus.HasFlag(RunningStatus.TemporalNormal))
                return (byte)RunningStatus.TemporalNormal;

            if (runningStatus.HasFlag(RunningStatus.SpatialNormal))
                return (byte)RunningStatus.SpatialNormal;

            return (byte)RunningStatus.Stopped;
        }
        protected void GetEncoderDirection()
        {
            App.TcpServer.SendGetEncoderDirectionData(_serialNo, _clientSocket);
        }
        protected void SetEncoderDirection(EncoderDirection direction)
        {
            App.TcpServer.SendSetEncoderDirectionData(direction, _serialNo, _clientSocket);
        }
        protected string GetSerialNo()
        {
            return App.Config.GenerateNewSerialNo();
        }
        private async void Save_Click(object sender, RoutedEventArgs e)
        {
            await SetParameter();
        }

        private void SetClockAndDirection_Click(object sender, RoutedEventArgs e)
        {
            if (Equipment.Parameter.SystemTime != null)
            {
                var systemTime = Equipment.Parameter.SystemTime.Value;
                App.TcpServer.SendSetClockData(systemTime.DateTimeToTimestamp(), _serialNo, _clientSocket);
            }
            Task.Delay(20).Wait();
            App.TcpServer.SendSetEncoderDirectionData(Equipment.Parameter.EncoderDirection, _serialNo, _clientSocket);
        }

        private void ReadClockAndDirection_Click(object sender, RoutedEventArgs e)
        {
            App.TcpServer.SendGetClockData(_serialNo, _clientSocket);
            Task.Delay(20).Wait();
            App.TcpServer.SendGetEncoderDirectionData(_serialNo, _clientSocket);
        }

        private void Clock_GotFocus(object sender, RoutedEventArgs e)
        {
            if (Equipment.Parameter.SystemTime == null)
            {
                Equipment.Parameter.SystemTime = DateTime.Now;
            }
        }

        private void SerialNo_GotFocus(object sender, RoutedEventArgs e)
        {
            if (Equipment.SerialNo.IsNullOrEmptyOrWhiteSpace())
            {
                Equipment.SerialNo = App.Config.GenerateNewSerialNo();
            }
        }

        private void SetSerialNo_Click(object sender, RoutedEventArgs e)
        {
            App.TcpServer.SendSerialNoRequest(Equipment.SerialNo, _clientSocket);
        }

        private void Upgrade_MouseDown(object sender, MouseButtonEventArgs e)
        {
            var result = MessageBoxX.Show(this, "是否确认更新设备固件？此操作将会停止设备工作。", "警告",
               MessageBoxButton.YesNo,
               MessageBoxIcon.Warning, DefaultButton.YesOK);
            if (result == MessageBoxResult.Yes)
            {
                App.TcpServer.SendUpgradeRequest(_serialNo, _clientSocket);
            }
        }

        private void RunningStatus_Click(object sender, RoutedEventArgs e)
        {
            if (sender is ToggleButton toggleButton)
            {
                // 检测模式为互斥选择，点击后强制保持选中（不允许取消已选中的模式）
                toggleButton.IsChecked = true;

                if (Enum.TryParse(toggleButton.Tag.ToString(), true, out RunningStatus runningStatus))
                {
                    var newMode = GetRunningStatusByte(runningStatus);
                    if (_runningMode != newMode)
                    {
                        _runningMode = newMode;
                        var equipmentData = App.DataCenter.Equipments.FirstOrDefault(c => c.SerialNo == _serialNo || c.IpAddress == _ipAddress);
                        if (equipmentData != null)
                        {
                            StartOrStopDetection(equipmentData, runningStatus);
                        }
                    }
                }
            }
        }
    }
}