using System;
using System.CodeDom;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows;
using System.Windows.Media;
using Aitex.Core.Account;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.SCCore;
using Aitex.Core.UI.MVVM;
using System.Windows.Input;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using Aitex.Sorter.UI;
using Aitex.Sorter.UI.Config;
using Aitex.Sorter.UI.ViewModel;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.UI.Core.Accounts;

namespace Sorter.UI.ViewModel
{

	public class TopViewModel : UIViewModelBase
	{

		public string SoftwareVersion
		{
			get;
			set;
		}

		[Subscription(ParamName.ControlStatus, SystemStateModule)]
		public string HostControlStatus
        {
			get;
			set;
		}

 	    public string HostControlStatusBackground
	    {
	        get
	        {
	            switch (HostControlStatus)
	            {
                    case "Unknown":
                        return "Yellow";
	                case "EquipmentOffline":
	                case "AttemptOnline":
	                case "HostOffline":
	                    return "Transparent";
	                case "OnlineLocal":
	                case "OnlineRemote":
	                    return "LawnGreen";
	                default:
	                    return "Yellow";
                }
            }
	    }


        [Subscription(ParamName.CommunicationStatus, SystemStateModule)]
		public string HostCommunicationStatus
		{
			get;
			set;
		}

	    ///  Disabled = 0,
	    ///  Enabled = 1,
	    ///  EnabledNotCommunicating = 2,
	    ///  EnabledCommunicating = 3,
	    ///  WaitCRA = 4,
	    ///  WaitDelay = 5,
	    ///  WaitCRFromHost = 6,
        public string HostCommunicationStatusBackground
        {
	        get
	        {
	            switch (HostControlStatus)
	            {
	                case "Disabled":
	                    return "Yellow";
	                case "Enabled":
	                case "EnabledNotCommunicating":
	                case "WaitCRA":
	                case "WaitDelay":
	                case "WaitCRFromHost":
	                    return "Transparent";
	                case "EnabledCommunicating":
	                    return "LawnGreen";
	                default:
	                    return "Yellow";
	            }
	        }
	    }

        [Subscription(ParamName.RTStatus, SystemStateModule)]
		public int RoutManagerState
		{
			get;
			set;
		}
		public string SystemStatus
		{
			get { return ((RtState)RoutManagerState).ToString(); }
		}
	    public string SystemStatusBackground
	    {
	        get
	        {
	            switch (RoutManagerState)
	            {
	                case (int)RtState.Init:
	                    return "Yellow";
	                case (int)RtState.Initializing:
	                case (int)RtState.ManualTransfer:
	                case (int)RtState.Transfer:
	                case (int)RtState.Cycle:
	                case (int)RtState.PrepareCycle:
	                case (int)RtState.PostCycle:
	                case (int)RtState.Reset:
	                case (int)RtState.Processing:
	                case (int)RtState.PostProcess:
	                case (int)RtState.PauseProcess:
	                case (int)RtState.SetSpeed:
	                    return "LawnGreen";
	                case (int)RtState.Error:
	                case (int)RtState.Maintenance:
	                    return "Red";
	                case (int)RtState.Idle:
	                    return "Transparent";
	                default:
	                    return "Goldenrod";

	            }
	        }
	    }

        [Subscription(ParamName.LoadportState, DeviceName.LoadportA)]
	    public string LoadPort1Status
        {
	        get;
	        set;
	    }

	    public string LoadPort1StatusBackground
	    {
	        get { return GetUnitStatusBackground(LoadPort1Status); }
	    }

	    [Subscription(ParamName.LoadportState, DeviceName.LoadportB)]
	    public string LoadPort2Status
        {
	        get;
	        set;
	    }
	    public string LoadPort2StatusBackground
	    {
	        get { return GetUnitStatusBackground(LoadPort2Status); }
	    }
        [Subscription(ParamName.AlignerState, DeviceName.Aligner)]
	    public string AlignerStatus
	    {
	        get;
	        set;
	    }
	    public string AlignerStatusBackground
        {
	        get { return GetUnitStatusBackground(AlignerStatus); }
	    }

        [Subscription(ParamName.RobotState, DeviceName.Robot)]
	    public string RobotStatus
	    {
	        get;
	        set;
	    }
	    public string RobotStatusBackground
        {
	        get { return GetUnitStatusBackground(RobotStatus); }
	    }

        [Subscription(DeviceName.SignalTower, SystemDeviceModule)]
		public AITSignalTowerData SignalTower
		{
			get;
			set;
		}

		[Subscription(ParamName.IsAutoMode, SystemStateModule)]
		public bool IsAutoMode { get; set; }
 

		private bool _simulatorMode = false;

		public bool IsManualButtonEnabled
		{
			get
			{
				return IsAutoMode;
			}
		}

		public bool IsAutoButtonEnabled
		{
			get
			{
				return !IsAutoMode;
			}
		}

	    public string GetUnitStatusBackground(string status)
	    {
            if (status!=null)
	            status = status.Trim().ToLower();

            switch (status)
	        {
	            case "unknown":
	                return "Yellow";
	            case "idle":
	                return "Transparent";
	            case "busy":
	                return "LawnGreen";
	            default:
	                return "Yellow";
	        }
	    }




        public string TopViewBackground
		{
			get
			{
				return _simulatorMode ? "Goldenrod" : "Transparent";
			}
		}



		public string User
		{
			get
			{
				return AccountClient.Instance.CurrentUser== null ? "" : AccountClient.Instance.CurrentUser.AccountId;
			}
		}

		public string Role
		{
			get
			{
				return AccountClient.Instance.CurrentUser == null ? "" : AccountClient.Instance.CurrentUser.Role;
			}
		}

		//public int _language;
		//public string LanguageButtonDisplay
		//{
		//    get
		//    {
		//        //显示的文字，和实际的语言相反，用于切换
		//        return _language == 1 ? "中文" : "EN";
		//    }
		//}

		//public bool EnableEnButton
		//{
		//	get
		//	{
		//		return _language != 1;
		//	}
		//}

		//public bool EnableCnButton
		//{
		//	get
		//	{
		//		return _language != 2;
		//	}
		//}

		public string LogoSource
		{
			get
			{
				string file = SystemConfigManager.Instance.GetTopviewLogoFile();

				if (string.IsNullOrEmpty(file))
					file = "LogoEmpty.png";

				return "/Core;component/Resources/Main/" + file;
			}
		}

		public ICommand SwitchOffBuzzerCommand
		{
			get;
			private set;
		}

		public ICommand SwitchLanguageCommand
		{
			get;
			private set;
		}

		public bool IsManualMode
		{
			get
			{
				return !IsAutoMode;
			}
		}

	    public FACommunicationState FACommunicationState
	    {
	        get
	        {
	            return string.IsNullOrEmpty(HostCommunicationStatus) ? FACommunicationState.Disabled
	                : (FACommunicationState)Enum.Parse(typeof(FACommunicationState), HostCommunicationStatus);
	        }
	    }
        public bool IsFAEnableButtonEnabled
        {
		    get { return FACommunicationState == FACommunicationState.Disabled; }
        }
	    public bool IsFADisableButtonEnabled
        {
	        get { return FACommunicationState != FACommunicationState.Disabled; }
        }


        public TopViewModel()
			: base("TopViewModel")
		{
			SwitchOffBuzzerCommand = new DelegateCommand<object>(OnSwitchOffBuzzer);
			SwitchLanguageCommand = new DelegateCommand<object>(OnSwitchOffLanguage);

			SoftwareVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
			InvokePropertyChanged("SoftwareVersion");
		}

		public void Reset()
		{
			InvokeClient.Instance.Service.DoOperation(OperationName.Reset);
		}

		void OnSwitchOffBuzzer(object param)
		{
			InvokeClient.Instance.Service.DoOperation(OperationName.DeviceOperation.ToString(), new object[] { DeviceName.SignalTower.ToString(), AITSignalTowerOperation.SwitchOffBuzzer.ToString() });
		}

		void OnSwitchOffLanguage(object param)
		{
			//int language = param.ToString().ToLower() == "en" ? 1 : 2;
			//InvokeClient.Instance.Service.DoOperation(OperationName.SetConfig.ToString(), SCName.System_Language, language);
		}

		protected override void InvokeBeforeUpdateProperty(Dictionary<string, object> data)
		{
			Application.Current.Dispatcher.Invoke(new Action(() =>
			{

				//int language = (int)QueryDataClient.Instance.Service.GetConfig(SCName.System_Language);
				//if (language != _language)
				//{
				//    _language = language;
				//    SorterUiSystem.Instance.SetCulture(_language == 2 ? "zh-CN" : "en-US");
				//}

				//_simulatorMode = (bool) QueryDataClient.Instance.Service.GetConfig(SCName.System_IsSimulatorMode);
			}));


		}

        public override bool PerformInvokeFunctionCheck(string[] param)
        {
			if (param != null && (param[0]== "SetAutoMode" || param[0] == "SetManualMode"))
			{
				if (param.Length == 1)
				{ return true; }
				if (param.Length == 2 && param[1].ToLower() == "True".ToLower())
				{
					PasswordMsgBox passwordMsgBox = new PasswordMsgBox();
					if (passwordMsgBox.DialogResult != true)
					{
						return false;
					}
				}
			}
            return true;
        }


    }

}