FurnaceELK/Furnace/FurnaceUI/Views/Operations/TransferMain/CassetteModifyViewModel.cs

using Aitex.Core.Common;
using Aitex.Core.Util;
using Caliburn.Micro.Core;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.UI.Client.ClientBase;
using OpenSEMI.ClientBase;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using FurnaceUI.Models;
using MECF.Framework.Common.SubstrateTrackings;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Event;
using OpenSEMI.Ctrlib.Controls;
using DocumentFormat.OpenXml.Bibliography;
using System.Reflection;
using MECF.Framework.Common.Jobs;

namespace FurnaceUI.Views.Operations
{
    public class CassetteModifyViewModel : FurnaceUIViewModelBase
    {
        #region"订阅"
        [Subscription("Stocker1.Carrier")]
        public CarrierInfo Stocker1CarrierData { get; set; }
        [Subscription("Stocker2.Carrier")]
        public CarrierInfo Stocker2CarrierData { get; set; }
        [Subscription("Stocker3.Carrier")]
        public CarrierInfo Stocker3CarrierData { get; set; }
        [Subscription("Stocker4.Carrier")]
        public CarrierInfo Stocker4CarrierData { get; set; }
        [Subscription("Stocker5.Carrier")]
        public CarrierInfo Stocker5CarrierData { get; set; }
        [Subscription("Stocker6.Carrier")]
        public CarrierInfo Stocker6CarrierData { get; set; }
        [Subscription("Stocker7.Carrier")]
        public CarrierInfo Stocker7CarrierData { get; set; }
        [Subscription("Stocker8.Carrier")]
        public CarrierInfo Stocker8CarrierData { get; set; }
        [Subscription("Stocker9.Carrier")]
        public CarrierInfo Stocker9CarrierData { get; set; }
        [Subscription("Stocker10.Carrier")]
        public CarrierInfo Stocker10CarrierData { get; set; }
        [Subscription("Stocker11.Carrier")]
        public CarrierInfo Stocker11CarrierData { get; set; }
        [Subscription("Stocker12.Carrier")]
        public CarrierInfo Stocker12CarrierData { get; set; }
        [Subscription("Stocker13.Carrier")]
        public CarrierInfo Stocker13CarrierData { get; set; }
        [Subscription("Stocker14.Carrier")]
        public CarrierInfo Stocker14CarrierData { get; set; }
        [Subscription("Stocker15.Carrier")]
        public CarrierInfo Stocker15CarrierData { get; set; }
        [Subscription("Stocker16.Carrier")]
        public CarrierInfo Stocker16CarrierData { get; set; }
        [Subscription("Stocker17.Carrier")]
        public CarrierInfo Stocker17CarrierData { get; set; }
        [Subscription("Stocker18.Carrier")]
        public CarrierInfo Stocker18CarrierData { get; set; }

        [Subscription("FIMS1.Carrier")]
        public CarrierInfo FIMS1CarrierData { get; set; }
        [Subscription("FIMS2.Carrier")]
        public CarrierInfo FIMS2CarrierData { get; set; }
        [Subscription("LP1.Carrier")]
        public CarrierInfo LP1CarrierData { get; set; }
        [Subscription("LP2.Carrier")]
        public CarrierInfo LP2CarrierData { get; set; }
        [Subscription("LP3.Carrier")]
        public CarrierInfo LP3CarrierData { get; set; }
        [Subscription("LP4.Carrier")]
        public CarrierInfo LP4CarrierData { get; set; }

        [Subscription("CarrierRobot.Carrier")]
        public CarrierInfo CassetteRobotCarrierData { get; set; }
        #endregion

        public CassetteModifyViewModel(string module)
        {
            IsProcessCanModifyFoupInfo = (bool)QueryDataClient.Instance.Service.GetConfig("System.ProcessStatusCanModifyFoupInfo");

            ModuleName = module;

            for (int i = 1; i <= 21; i++)
            {
                OriginModuleItems.Add($"Stocker{i}");
            }

            for (int i = (int)QueryDataClient.Instance.Service.GetConfig("System.CassetteSlotCount"); i > 0; i--)
            {
                CassetteWaferInfoItems.Add(new WaferInfoItem() { SlotID = i });
            }
        }
        public string ModuleName { set; get; }

        public List<string> OriginModuleItems { get; set; } = new List<string>();

        private int? _cassetteSlot = 1;
        public int? CassetteSlot
        {
            get => _cassetteSlot;
            set
            {
                _cassetteSlot = value;
                NotifyOfPropertyChange(nameof(CassetteSlot));
            }
        }

        private string _originSelectModule = "Stocker1";
        public string OriginSelectModule
        {
            get => _originSelectModule;
            set
            {
                _originSelectModule = value;
                NotifyOfPropertyChange(nameof(OriginSelectModule));
            }
        }

        private int? _originSlot = 1;
        public int? OriginSlot
        {
            get => _originSlot;
            set
            {
                _originSlot = value;
                NotifyOfPropertyChange(nameof(OriginSlot));
            }
        }
        public bool SDIsChecked { get; set; } = true;
        public bool EDIsChecked { get; set; }
        public bool PIsChecked { get; set; }
        public bool M1IsChecked { get; set; }
        public bool M2IsChecked { get; set; }
        public bool TIsChecked { get; set; }
        public bool XDIsChecked { get; set; }
        [Subscription("Stocker1.CassettePresent")]
        public bool IsCassettePresent { get; set; }
        [Subscription("Rt.Status")]
        public string RtStatus { get; set; }
        [Subscription("PM1.Status")]
        public string PM1Status { get; set; }
        public bool IsProcessCanModifyFoupInfo { get; set; } = false;

        public bool IsCassetteModifyEnabled
        {
            get
            {
                if (ControlJobs != null && ControlJobs.Count > 0)
                {
                    return ControlJobs.FirstOrDefault().State == EnumControlJobState.Paused;
                }

                var pmStatus = PM1Status == "Init" || PM1Status == "Idle" || PM1Status == "Error" || (IsProcessCanModifyFoupInfo && PM1Status == "Process");
                var rtstatus = (RtStatus == "Init" || RtStatus == "Idle" || RtStatus == "Error") || (IsProcessCanModifyFoupInfo && RtStatus == "AutoRunning");
                return pmStatus && rtstatus;
            }
        }
        [Subscription("Scheduler.ControlJobList")]
        public List<ControlJobInfo> ControlJobs
        {
            get;
            set;
        }

        private ObservableCollection<WaferInfoItem> _cassetteWaferInfoItems = new ObservableCollection<WaferInfoItem>();
        public ObservableCollection<WaferInfoItem> CassetteWaferInfoItems
        {
            get => _cassetteWaferInfoItems;
            set
            {
                _cassetteWaferInfoItems = value;
                NotifyOfPropertyChange(nameof(CassetteWaferInfoItems));
            }
        }

        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            RefreshCassetteDataTask();
        }

        private void RefreshCassetteDataTask()
        {
            if (!ModuleManager.ModuleInfos.ContainsKey(ModuleName))
            {
                return;
            }
            var wafers = ModuleManager.ModuleInfos[ModuleName].WaferManager.Wafers;

            if (wafers != null)
            {
                for (int i = 0; i < wafers.Count; i++)
                {
                    if (wafers[i].WaferStatus != 0)
                    {
                        CassetteWaferInfoItems[i].ModuleID = wafers[i].ModuleID;
                        CassetteWaferInfoItems[i].SourceName = wafers[i].SourceName;
                        CassetteWaferInfoItems[i].WaferStatus = wafers[i].WaferStatus;
                        CassetteWaferInfoItems[i].WaferType = wafers[i].WaferType.ToString();
                        CassetteWaferInfoItems[i].UseCount = wafers[i].UseCount.ToString();
                        CassetteWaferInfoItems[i].UseTime = wafers[i].UseTime.ToString();
                        CassetteWaferInfoItems[i].UseThick = wafers[i].UseThick.ToString();
                    }
                    else
                    {
                        CassetteWaferInfoItems[i].ModuleID = "";
                        CassetteWaferInfoItems[i].SourceName = "";
                        CassetteWaferInfoItems[i].WaferStatus = 0;
                        CassetteWaferInfoItems[i].WaferType = "";
                        CassetteWaferInfoItems[i].UseCount = "";
                        CassetteWaferInfoItems[i].UseTime = "";
                        CassetteWaferInfoItems[i].UseThick = "";
                    }
                }
            }
        }

        public void CreateWafer()
        {
            if (!DialogBox.Confirm("Are you sure  want to CreateWafer?"))
                return;

            WaferType waferType = WaferType.None;
            if (SDIsChecked)
                waferType = WaferType.SD;
            else if (EDIsChecked)
                waferType = WaferType.ED;
            else if (PIsChecked)
                waferType = WaferType.P;
            else if (M1IsChecked)
                waferType = WaferType.M1;
            else if (M2IsChecked)
                waferType = WaferType.M2;
            else if (XDIsChecked)
                waferType = WaferType.XD;
            else if (TIsChecked)
                waferType = WaferType.T;

            if (CassetteSlot < 1 || CassetteSlot > (int)QueryDataClient.Instance.Service.GetConfig("System.CassetteSlotCount"))
            {
                DialogBox.ShowWarning($"CassetteSlot input error,can not create,input range 1 to {(int)QueryDataClient.Instance.Service.GetConfig("System.CassetteSlotCount")}");
                return;
            }

            if (OriginSlot < 1 || OriginSlot > (int)QueryDataClient.Instance.Service.GetConfig("System.CassetteSlotCount"))
            {
                DialogBox.ShowWarning($"OriginSlot input error,can not create,input range 1 to {(int)QueryDataClient.Instance.Service.GetConfig("System.CassetteSlotCount")}");
                return;
            }
            var key = $"{ModuleName.ToString()}.Carrier";
            var rtData = QueryDataClient.Instance.Service.PollData(new List<string>() { key });
            if (rtData == null)
            {
                DialogBox.ShowWarning($"{ModuleName} Carrier is null!");
                return;
            }
            var carrierInfo = (CarrierInfo)rtData[key];
            if (carrierInfo == null || carrierInfo.IsEmpty)
            {
                DialogBox.ShowWarning($"{ModuleName} Carrier is null!");
                return;
            }

            InvokeClient.Instance.Service.DoOperation("CreateWafer", $"{ModuleName}", CassetteSlot - 1, waferType.ToString(), OriginSelectModule, OriginSlot - 1);
        }
        public void CreateCarrier()
        {
            if (!DialogBox.Confirm("Are you sure  want to CreateCarrier?"))
                return;


            WaferType waferType = WaferType.None;
            if (SDIsChecked)
                waferType = WaferType.SD;
            else if (EDIsChecked)
                waferType = WaferType.ED;
            else if (PIsChecked)
                waferType = WaferType.P;
            //else if (MIsChecked)
            //    waferType = WaferType.M; 
            else if (M1IsChecked)
                waferType = WaferType.M1;
            else if (M2IsChecked)
                waferType = WaferType.M2;
            else if (XDIsChecked)
                waferType = WaferType.XD;
            else if (TIsChecked)
                waferType = WaferType.T;


            InvokeClient.Instance.Service.DoOperation("System.CreateCarrier", $"{ModuleName}", 1, waferType.ToString(), false.ToString());
        }
        public void DeleteCarrier()
        {

            if (!DialogBox.Confirm("Are you sure  want to DeleteCarrier?"))
                return;


            InvokeClient.Instance.Service.DoOperation("System.DeleteCarrier", $"{ModuleName}", 1);
            foreach (var item in CassetteWaferInfoItems)
            {
                item.SourceName = "";
                item.WaferStatus = 0;
                item.WaferType = "";
                item.UseCount = "";
                item.UseTime = "";
                item.UseThick = "";
                item.MappingResult = ScanResult.Init;
            }
        }

        public void DeleteWafer()
        {

            if (!DialogBox.Confirm("Are you sure  want to DeleteWafer?"))
                return;
            if (CassetteSlot < 1 || CassetteSlot > (int)QueryDataClient.Instance.Service.GetConfig("System.CassetteSlotCount"))
            {
                DialogBox.ShowWarning($"CassetteSlot input error,can not delete,input range 1 to {(int)QueryDataClient.Instance.Service.GetConfig("System.CassetteSlotCount")}");
                return;
            }

            InvokeClient.Instance.Service.DoOperation("DeleteWafer", $"{ModuleName}", CassetteSlot - 1);
        }

        public void CassetteClose()
        {
            ((Window)GetView()).DialogResult = false;
        }
    }

    public class WaferInfoItem : PropertyChangedBase
    {
        private int _slotID;
        public int SlotID
        {
            get => _slotID;
            set
            {
                _slotID = value;
                NotifyOfPropertyChange(nameof(SlotID));
            }
        }

        private string _moduleID;
        public string ModuleID
        {
            get => _moduleID;
            set
            {
                _moduleID = value;
                NotifyOfPropertyChange(nameof(ModuleID));
            }
        }

        private string _sourceName;
        public string SourceName
        {
            get => _sourceName;
            set
            {
                _sourceName = value;
                NotifyOfPropertyChange(nameof(SourceName));
            }
        }

        private int _waferStatus = 0;   // WaferStatus.Empty;
        public int WaferStatus
        {
            get => _waferStatus;
            set
            {
                _waferStatus = value;
                NotifyOfPropertyChange("WaferStatus");
            }
        }

        private string waferType;
        public string WaferType
        {
            get
            { return waferType; }
            set
            {
                waferType = value;
                NotifyOfPropertyChange("WaferType");
            }
        }

        private string useCount;
        public string UseCount
        {
            get
            { return useCount; }
            set
            {
                useCount = value;
                NotifyOfPropertyChange("UseCount");
            }
        }

        private string useTime;
        public string UseTime
        {
            get
            { return useTime; }
            set
            {
                useTime = value;
                NotifyOfPropertyChange("UseTime");
            }
        }

        private string useThick;
        public string UseThick
        {
            get
            { return useThick; }
            set
            {
                useThick = value;
                NotifyOfPropertyChange("UseThick");
            }
        }

        private string bgColor;

        public string BgColor
        {
            get { return bgColor; }
            set
            {
                bgColor = value;
                NotifyOfPropertyChange("BgColor");
            }
        }
        /// <summary>
        /// 记录对象是否进行过增删或者数据变动
        /// </summary>
        public bool IsChanged { get; set; }
        private ScanResult _mappingResult;
        /// <summary>
        /// mapping结果
        /// </summary>
        public ScanResult MappingResult
        {
            get { return _mappingResult; }
            set
            {
                if (_mappingResult != value)
                {
                    _mappingResult = value;
                    NotifyOfPropertyChange(nameof(MappingResult));
                }
            }
        }
    }
}