LPLocalhostMES/LocalhostMES/ViewModels/Services/MesWorkspace.cs

using LocalhostMES.Core;
using LocalhostMES.DataBase;
using LocalhostMES.Models;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;

namespace LocalhostMES.ViewModels.Services
{
    public sealed class MesWorkspace : BindableBase, IMesWorkspace
    {
        private LogHelper.LogChangHandler _logHandler;
        private bool _initialized;
        private string _statusLine;
        private Brush _statusForeground = Brushes.Green;
        private int _selectedTabIndex = 0;
        private string _crossPageSn;

        public Management MesManagement => Management.GetManagement();

        public ObservableCollection<WorkOrderInfo> WorkOrders { get; } = new ObservableCollection<WorkOrderInfo>();

        public ObservableCollection<string> Logs { get; } = new ObservableCollection<string>();

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

        public Brush StatusForeground
        {
            get => _statusForeground;
            private set => SetProperty(ref _statusForeground, value);
        }

        public int SelectedTabIndex
        {
            get => _selectedTabIndex;
            set => SetProperty(ref _selectedTabIndex, value);
        }

        public string CrossPageSn
        {
            get => _crossPageSn;
            set => SetProperty(ref _crossPageSn, value);
        }

        public void Initialize()
        {
            if (_initialized)
            {
                return;
            }

            _initialized = true;
            DatabaseHelper.CreataDataTable();
            ReloadWorkOrders();
            EnsureOrderNotifyClient();

            _logHandler = msg =>
            {
                Application.Current?.Dispatcher.Invoke(() =>
                {
                    Logs.Add($"[{DateTime.Now:HH:mm:ss}] {msg}\n");
                });
            };
            LogHelper.logChangHandler += _logHandler;
        }

        public void Shutdown()
        {
            if (MesManagement.WorkOrderNotifyTcpClient != null)
            {
                MesManagement.WorkOrderNotifyTcpClient.MessageReceived -= OnOrderNotifyMessage;
                MesManagement.WorkOrderNotifyTcpClient.LogReceived -= OnOrderNotifyLog;
                MesManagement.WorkOrderNotifyTcpClient.Dispose();
                MesManagement.WorkOrderNotifyTcpClient = null;
            }

            if (_logHandler != null)
            {
                LogHelper.logChangHandler -= _logHandler;
                _logHandler = null;
            }
        }

        public void ReloadWorkOrders()
        {
            WorkOrders.Clear();
            foreach (var w in DatabaseHelper.SelectWorkOrderInfo())
            {
                WorkOrders.Add(w);
            }
        }

        public void ShowStatus(string message, bool isError)
        {
            Application.Current?.Dispatcher.Invoke(() =>
            {
                StatusLine = message;
                StatusForeground = isError ? Brushes.Red : Brushes.Green;
            });
        }

        private void EnsureOrderNotifyClient()
        {
            if (MesManagement.WorkOrderNotifyTcpClient != null)
            {
                return;
            }

            var client = new WorkOrderNotifyTcpClient("127.0.0.1", 9000);
            client.MessageReceived += OnOrderNotifyMessage;
            client.LogReceived += OnOrderNotifyLog;
            MesManagement.WorkOrderNotifyTcpClient = client;

            Task.Run(async () =>
            {
                try
                {
                    await client.ConnectAsync();
                }
                catch (Exception ex)
                {
                    ShowStatus($"TCP客户端连接失败: {ex.Message}", true);
                }
            });
        }

        private void OnOrderNotifyLog(string message)
        {
            Application.Current?.Dispatcher.Invoke(() =>
            {
                Logs.Add($"[{DateTime.Now:HH:mm:ss}] {message}\n");
            });
        }

        private async void OnOrderNotifyMessage(string message)
        {
            if (string.IsNullOrWhiteSpace(message))
            {
                return;
            }

            if (!message.StartsWith("OrderRef|", StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            try
            {
                var httpHelper = MesManagement.ApiClient;
                if (httpHelper == null)
                {
                    ShowStatus("未配置API客户端，无法自动刷新工单", true);
                    return;
                }

                ApiResponse<List<WorkOrderInfo>> apiResponse = await httpHelper.GetWorkOrdersAsync();
                if (!apiResponse.success)
                {
                    return;
                }
                if (apiResponse.data == null || apiResponse.data.Count == 0)
                {
                    return;
                }

                MesManagement.GetOrderInfo = apiResponse.data;

                foreach (var item in apiResponse.data.Where(it => !string.IsNullOrWhiteSpace(it.WorkOrderNo)))
                {
                    if (!DatabaseHelper.UpdateWorkOrderInfo(item))
                    {
                        DatabaseHelper.InsertWorkOrderInfo(item);
                    }
                }

                ReloadWorkOrders();
                ShowStatus($"收到{message}，工单已自动刷新", false);
            }
            catch
            {
            }
        }
    }
}