using System;
using System.Collections.Generic;
using PrimaryInterOp.Cross3Krc;

namespace KukaInterface
{
	public enum LogMessageLevel
	{
		Error,
		Warning,
		Information
	}

	public class CrossComm : ICKCallbackVar, IKCallbackError
	{
		private bool crossIsConnected;
		private Dictionary<int, string> setInfoLookup = new Dictionary<int, string>();
		private Dictionary<string, int> setInfoReverseLookup = new Dictionary<string, int>();
		private IKServiceFactory serviceFactory;
		private ICKSyncVar itfSyncVar;
		private ICKAsyncVar itfAsyncVar;
		private int requestId;

		public event SetInfoEventHandler EventSetInfo;
		public event MessageEventHandler Message;

		private void FireMessage(string message, LogMessageLevel logLevel)
		{
			if (Message != null)
			{
				Message(this, new CrossCommMessageEventArgs(message, logLevel));
			}
		}

		public string[] GetWatchList()
		{
			List<string> watchList = new List<string>();
			foreach (string varName in setInfoLookup.Values)
			{
				watchList.Add(varName);
			}
			return watchList.ToArray();
		}

		public bool ConnectToCross(string strConnectName)
		{
			try
			{
				itfSyncVar = (ICKSyncVar)serviceFactory.GetService("WBC_KrcLib.SyncVar", strConnectName);
				itfAsyncVar = (ICKAsyncVar)serviceFactory.GetService("WBC_KrcLib.ASyncVar", strConnectName);
				crossIsConnected = true;
			}
			catch (Exception ex)
			{
				crossIsConnected = false;
				throw new CrossCommException("Error in CrossComm.ConnectToCross(): " + ex.Message, ex);
			}
			return true;
		}

		public void Init()
		{
			try
			{
				serviceFactory = new KrcServiceFactoryClass();
			}
			catch (Exception ex)
			{
				crossIsConnected = false;
				throw new CrossCommException("Error in CrossComm.Init(): " + ex.Message, ex);
			}
			crossIsConnected = true;
		}

		public void OnSetInfo(int requestId, string varValue)
		{
			if (setInfoLookup.ContainsKey(requestId))
			{
				if (EventSetInfo != null)
				{
					string varName = setInfoLookup[requestId];
					FireMessage(String.Format("Cross.OnSetInfo({0}, {1})", varName, varValue), LogMessageLevel.Debug);
					EventSetInfo(this, new SetInfoEventArgs(varName, varValue));
				}
			}
		}

		public void OnDialog(int id, ref TKDialog dialog)
		{
			FireMessage(String.Format("Cross.OnDialog({0}, {1}) ({2})", id, dialog.eDialogType, dialog.bstrCause), LogMessageLevel.Debug);
		}

		public void OnError(int id, ref TKMessage message)
		{
			FireMessage(String.Format("Cross.OnError({0}, {1}) ({2})", id, message.eMessageType, message.bstrCause), LogMessageLevel.Debug);
		}

		public void OnSubMessage(int nMessageHandle)
		{
			FireMessage(String.Format("Cross.OnSubMessage({0})", nMessageHandle), LogMessageLevel.Debug);
		}

		public void OnSetMultiVar(int requestId) { }
		public void OnSetVar(int requestId) { }
		public void OnShowMultiVar(int requestId, object varVals) { }
		public void OnShowVar(int requestId, string bstrVal) { }

		public void ServerOff()
		{
			try
			{
				ClearWatchList();
			}
			catch (CrossNotConnectedException) { }
			catch (CrossCommException ex)
			{
				FireMessage("ClearWatchList: CrossCommException " + ex.Message, LogMessageLevel.Error);
			}
			itfSyncVar = null;
			itfAsyncVar = null;
			serviceFactory = null;
		}

		private object setInfoSyncObj = new object();
		public void SetInfoOn(string varName)
		{
			lock (setInfoSyncObj)
			{
				if (!crossIsConnected)
				{
					throw new CrossNotConnectedException("SetInfoOn: Not connected to cross");
				}
				if (itfAsyncVar == null)
				{
					throw new CrossCommException("AsyncVar interface is null");
				}
				if (setInfoLookup.ContainsValue(varName))
				{
					FireMessage("Already watching " + varName, LogMessageLevel.Warning);
					return;
				}

				requestId++;
				FireMessage(String.Format("Adding watch for variable {0} (ID:{1})", varName, requestId), LogMessageLevel.Verbose);
				try
				{
					itfAsyncVar.SetInfo(this, requestId, varName, 200);
				}
				catch (Exception ex)
				{
					FireMessage(String.Format("Failed to add watch for variable {0} (ID:{1}) ({2})", varName, requestId, ex.Message), LogMessageLevel.Error);
					throw new CrossCommException("Error in CrossComm.SetInfoOn()\n" + ex.Message);
				}
				setInfoLookup.Add(requestId, varName);
				setInfoReverseLookup.Add(varName, requestId);
			}
		}

		public void SetInfoOff(string varName)
		{
			lock (setInfoSyncObj)
			{
				if (!crossIsConnected)
				{
					throw new CrossNotConnectedException("SetInfoOff: Not connected to cross");
				}
				if (itfAsyncVar == null)
				{
					throw new CrossCommException("AsyncVar interface is null");
				}
				if (setInfoLookup.ContainsValue(varName))
				{
					int id = setInfoReverseLookup[varName];
					try
					{
						itfAsyncVar.Cancel(id);
					}
					catch (Exception ex)
					{
						throw new CrossCommException("Error in CrossComm.SetInfoOff()", ex);
					}
					finally
					{
						setInfoLookup.Remove(id);
						setInfoReverseLookup.Remove(varName);
					}
				}
			}
		}

		public void ClearWatchList()
		{
			if (!crossIsConnected)
			{
				throw new CrossNotConnectedException("ClearWatchList: Not connected to cross");
			}
			if (itfAsyncVar == null)
			{
				throw new CrossCommException("AsyncVar interface is null");
			}
			List<string> varNames = new List<string>(setInfoLookup.Values);
			foreach (string varName in varNames)
			{
				SetInfoOff(varName);
			}
		}

		public void SetVar(string varName, string newValue)
		{
			if (!crossIsConnected)
			{
				throw new CrossNotConnectedException("SetVar: Not connected to cross");
			}
			if (itfSyncVar == null)
			{
				throw new CrossCommException("SyncVar interface is null");
			}
			try
			{
				itfSyncVar.SetVar(varName, newValue);
			}
			catch (Exception ex)
			{
				throw new CrossCommException("Error in CrossComm.SetVar\n" + ex.Message, ex);
			}
		}

		public string ShowVar(string varName)
		{
			if (!crossIsConnected)
			{
				throw new CrossNotConnectedException("ShowVar: Not connected to Cross");
			}
			if (itfSyncVar == null)
			{
				throw new CrossCommException("SyncVar interface is null");
			}
			string varValue;
			try
			{
				varValue = itfSyncVar.ShowVar(varName);
			}
			catch (Exception ex)
			{
				throw new CrossCommException("Error in CrossComm.ShowVar(): " + ex.Message, ex);
			}
			return varValue;
		}

		public void OpenCloseRedeclare()
		{
			//itfSyncSelect.Cancel(EKInterpreter.eInterpreterRobot);
			//itfSyncSelect.Run(@"KRC:\R1\Program\test", "", true);
			//int handle = itfSyncEdit.Open(@"KRC:\R1\Program\testprog", 0x400, EKEditMode.eEditModeFullEdit, "", "");
			//int nLines = 0;
			//EKCodeType eCodeType = EKCodeType.eCodeTypeUnknown;
			//itfSyncEdit.GetProperties(handle, ref nLines, ref eCodeType);
			//itfSyncFile.Create(@"KRC:\R1\Program\testprog2", EKItemType.eItemTypeModule, EKModulePart.eModulePartSRCDAT, "", true);
			//object o = itfSyncEdit.GetLines(handle, 1, 20);
			//itfSyncEdit.OpenCloseRedeclare(EKEditMode.eEditModeFullEdit, @"KRC:\R1\Program\testprog2.dat", "POS1", "E6POS", "{X 100,Y 200,Z 300,A 0,B 0,C 90}");
			//Array lines = new string[]
			//	{
			//		"LIN_REL {X 10}",
			//		"WAIT SEC 2"
			//	};
			//itfSyncEdit.InsertLines(handle, 0, lines);
			//itfSyncEdit.Redeclare(handle, "TESTVAR", "INT", "1");
			//itfSyncEdit.Close(handle, true);
		}

		public string GetRobotName()
		{
			Microsoft.Win32.RegistryKey nameKey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(@"SOFTWARE\KUKA Roboter GmbH\RobotData");
			if (nameKey == null)
			{
				FireMessage("Failed to get robot name: Registry key does not exist", LogMessageLevel.Error);
				return "Unknown";
			}
			else
			{
				string robotName = (string)nameKey.GetValue("RobotName");
				return robotName.Replace(' ', '_');
			}
		}

		public string GetRobotSerialNumber()
		{
			string serialNo = String.Empty;
			try
			{
				serialNo = ShowVar("$KR_SERIALNO");
			}
			catch (Exception ex)
			{
				FireMessage("Failed to get robot serial number: " + ex.Message, LogMessageLevel.Error);
				return "Unknown";
			}
			return serialNo;
		}

		//		public int AddMessage(int messageNumber, string msg, EKMessageType type)
		//		{
		//			TKMessage message = new TKMessage();
		//			message.eMessageType = type;
		//			message.bstrCause = "ArcClient";
		//			message.bstrDBModule = "ArcClient";
		//			message.bstrDBMessage = msg;
		//			message.nMessage = messageNumber;
		//			message.nMessageHandle = 0;
		//			message.varDBParams = new bool[1];
		//			message.varParams = new string[1];
		//
		//			long num = DateTime.Now.ToFileTime();
		//			message.nHighTimeStamp = (int)(num >> 0x20);
		//			message.nLowTimeStamp = (int)(((ulong)num) & 0xffffffffL);
		//			message.nBiasTimeStamp = -((int)((TimeZone.CurrentTimeZone.GetUtcOffset(DateTime.Now)).TotalMinutes));
		//
		//			return itfSyncMessage.AddMessage(ref message);
		//		}
		//
		//		public void SubMessage(int handle)
		//		{
		//			itfSyncMessage.SubMessage(handle);
		//		}

		public bool CrossIsConnected
		{
			get { return crossIsConnected; }
		}
	}

	public class CrossCommMessageEventArgs : EventArgs
	{
		private string message;
		public string Message
		{
			get { return message; }
		}

		private LogMessageLevel logLevel;
		public LogMessageLevel LogLevel
		{
			get { return logLevel; }
		}

		public CrossCommMessageEventArgs(string message, LogMessageLevel logLevel)
		{
			this.message = message;
			this.logLevel = logLevel;
		}
	}
	public delegate void MessageEventHandler(object sender, CrossCommMessageEventArgs e);

	public class SetInfoEventArgs : EventArgs
	{
		private string varName;
		private string varValue;

		public SetInfoEventArgs(string varName, string varValue)
		{
			this.varName = varName;
			this.varValue = varValue;
		}

		public string VarName
		{
			get { return varName; }
		}

		public string VarValue
		{
			get { return varValue; }
		}
	}
	public delegate void SetInfoEventHandler(object sender, SetInfoEventArgs e);

	public class CrossNotConnectedException : ApplicationException
	{
		public CrossNotConnectedException(string message) : base(message) { }
	}

	public class CrossCommException : ApplicationException
	{
		public CrossCommException(string message) : base(message) { }
		public CrossCommException(string message, Exception innerException) : base(message, innerException) { }
	}
}