/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
using System;
using System.Collections;
using System.IO;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Xml;
using Apache.NMS.Util;
using NUnit.Framework;

namespace Apache.NMS.Test
{
	/// <summary>
	/// Useful class for test cases support.
	/// </summary>
	public class NMSTestSupport
	{
		protected TimeSpan receiveTimeout = TimeSpan.FromMilliseconds(15000);
		protected int testRun;
		protected int idCounter;

        protected Type testClassType;
		public Type TestClassType
		{
			get { return this.testClassType; }
			set { this.testClassType = value; }
		}

		#region Constructors

		public NMSTestSupport()
		{
		}

		#endregion

		#region Set up and tear down

		public virtual void SetUp()
		{
			this.testRun++;
		}

		public virtual void TearDown()
		{
		}

		#endregion

		#region Configuration file

		private XmlDocument configurationDocument = null;
		/// <summary>
		/// The configuration document.
		/// </summary>
		public XmlDocument ConfigurationDocument
		{
			get
			{
				if(this.configurationDocument == null)
				{
					this.configurationDocument = LoadConfigFile();
					Assert.IsTrue(this.configurationDocument != null,
						"Error loading configuration.");
				}

				return this.configurationDocument;
			}
		}

		/// <summary>
		/// Loads the configuration file.
		/// </summary>
		/// <returns>XmlDocument of the configuration file</returns>
		public virtual XmlDocument LoadConfigFile()
		{
			return LoadConfigFile(GetConfigFilePath());
		}

		/// <summary>
		/// Loads the configuration file.
		/// </summary>
		/// <param name="configFilePath">Configuration file path</param>
		/// <returns>XmlDocument of the configuration file</returns>
		public virtual XmlDocument LoadConfigFile(string configFilePath)
		{
			XmlDocument configDoc = new XmlDocument();

			configDoc.Load(configFilePath);

			return configDoc;
		}

		/// <summary>
		/// Gets the path of the configuration filename.
		/// </summary>
		/// <returns>Path of the configuration filename</returns>
		public virtual string GetConfigFilePath()
		{
			// The full path may be specified by an environment variable
			string configFilePath = GetEnvVar(GetConfigEnvVarName(), "");
			bool configFound = (!string.IsNullOrEmpty(configFilePath)
				&& File.Exists(configFilePath));

			// Else it may be found in well known locations
			if(!configFound)
			{
				string[] paths = GetConfigSearchPaths();
				string configFileName = GetDefaultConfigFileName();

				foreach(string path in paths)
				{
					string fullpath = Path.Combine(path, configFileName);
					Tracer.Debug("\tScanning folder: " + path);

					if(File.Exists(fullpath))
					{
						Tracer.Debug("\tAssembly found!");
						configFilePath = fullpath;
						configFound = true;
						break;
					}
				}
			}

			Tracer.Debug("\tConfig file: " + configFilePath);
			Assert.IsTrue(configFound, "Connection configuration file does not exist.");
			return configFilePath;
		}

		/// <summary>
		/// Gets the environment variable name for the configuration file path.
		/// </summary>
		/// <returns>Environment variable name</returns>
		public virtual string GetConfigEnvVarName()
		{
			return "NMSTESTCONFIGPATH";
		}

		/// <summary>
		/// Gets the default name for the configuration filename.
		/// </summary>
		/// <returns>Default name of the configuration filename</returns>
		public virtual string GetDefaultConfigFileName()
		{
			return "nmsprovider-test.config";
		}

		/// <summary>
		/// Gets an array of paths where the configuration file sould be found.
		/// </summary>
		/// <returns>Array of paths</returns>
		private static string[] GetConfigSearchPaths()
		{
			ArrayList pathList = new ArrayList();

			// Check the current folder first.
			pathList.Add("");
#if !NETCF
			AppDomain currentDomain = AppDomain.CurrentDomain;

			// Check the folder the assembly is located in.
			pathList.Add(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
			if(null != currentDomain.BaseDirectory)
			{
				pathList.Add(currentDomain.BaseDirectory);
			}

			if(null != currentDomain.RelativeSearchPath)
			{
				pathList.Add(currentDomain.RelativeSearchPath);
			}
#endif

			return (string[]) pathList.ToArray(typeof(string));
		}

		/// <summary>
		/// Gets the value of the "value" attribute of the specified node.
		/// </summary>
		/// <param name="parentNode">Parent node</param>
		/// <param name="nodeName">Node name</param>
		/// <param name="defaultVaue">Default value</param>
		/// <returns></returns>
		public string GetNodeValueAttribute(XmlElement parentNode,
			string nodeName, string defaultVaue)
		{
			XmlElement node = (XmlElement)parentNode.SelectSingleNode(nodeName);

			return (node == null ? defaultVaue : node.GetAttribute("value"));
		}

		#endregion

		#region URI node

		/// <summary>
		/// Gets the URI node for the default configuration.
		/// </summary>
		/// <returns>URI node for the default configuration name</returns>
		public virtual XmlElement GetURINode()
		{
			return GetURINode(GetNameTestURI());
		}

		/// <summary>
		/// Gets the URI node for the default configuration.
		/// </summary>
		/// <param name="nameTestURI">Name of the default configuration node
		/// </param>
		/// <returns>URI node for the default configuration name</returns>
		public virtual XmlElement GetURINode(string nameTestURI)
		{
			return (XmlElement)ConfigurationDocument.SelectSingleNode(
				String.Format("/configuration/{0}", nameTestURI));
		}

		/// <summary>
		/// Gets the name of the default connection configuration to be loaded.
		/// </summary>
		/// <returns>Default configuration name</returns>
		public virtual string GetNameTestURI()
		{
			return "testURI";
		}

		#endregion

		#region Factory

		private NMSConnectionFactory nmsFactory;
		/// <summary>
		/// The connection factory interface property.
		/// </summary>
		public IConnectionFactory Factory
		{
			get
			{
				if(this.nmsFactory == null)
				{
					this.nmsFactory = CreateNMSFactory();

					Assert.IsNotNull(this.nmsFactory, "Error creating factory.");
				}

				return this.nmsFactory.ConnectionFactory;
			}
		}

		/// <summary>
		/// Create the NMS Factory that can create NMS Connections.
		/// </summary>
		/// <returns>Connection factory</returns>
		public NMSConnectionFactory CreateNMSFactory()
		{
			return CreateNMSFactory(GetNameTestURI());
		}

		/// <summary>
		/// Create the NMS Factory that can create NMS Connections. This
		/// function loads the connection settings from the configuration file.
		/// </summary>
		/// <param name="nameTestURI">The named connection configuration.
		/// </param>
		/// <returns>Connection factory</returns>
		public NMSConnectionFactory CreateNMSFactory(string nameTestURI)
		{
			XmlElement uriNode = GetURINode(nameTestURI);

			Uri brokerUri = null;
			object[] factoryParams = null;
			if(uriNode != null)
			{
				// Replace any environment variables embedded inside the string.
				brokerUri = new Uri(uriNode.GetAttribute("value"));
				factoryParams = GetFactoryParams(uriNode);
				clientId = GetNodeValueAttribute(uriNode, "clientId", "NMSTestClientId");
				userName = GetNodeValueAttribute(uriNode, "userName", null);
				passWord = GetNodeValueAttribute(uriNode, "passWord", null);
			}

			if(factoryParams == null)
			{
				this.nmsFactory = new Apache.NMS.NMSConnectionFactory(brokerUri);
			}
			else
			{
				this.nmsFactory = new Apache.NMS.NMSConnectionFactory(brokerUri, factoryParams);
			}

			return this.nmsFactory;
		}

		/// <summary>
		/// Get the parameters for the ConnectionFactory from the configuration
		/// file.
		/// </summary>
		/// <param name="uriNode">Parent node of the factoryParams node.</param>
		/// <returns>Object array of parameter objects to be passsed to provider
		/// factory object.  Null if no parameters are specified in
		/// configuration file.</returns>
		public object[] GetFactoryParams(XmlElement uriNode)
		{
			ArrayList factoryParams = new ArrayList();
			XmlElement factoryParamsNode = (XmlElement)uriNode.SelectSingleNode("factoryParams");

			if(factoryParamsNode != null)
			{
				XmlNodeList nodeList = factoryParamsNode.SelectNodes("param");

				if(nodeList != null)
				{
					foreach(XmlElement paramNode in nodeList)
					{
						string paramType = paramNode.GetAttribute("type");
						string paramValue = paramNode.GetAttribute("value");

						switch(paramType)
						{
							case "string":
								factoryParams.Add(paramValue);
								break;

							case "int":
								factoryParams.Add(int.Parse(paramValue));
								break;

							// TODO: Add more parameter types
						}
					}
				}
			}

			if(factoryParams.Count > 0)
			{
				return factoryParams.ToArray();
			}

			return null;
		}

		#endregion

		#region Environment variables

		/// <summary>
		/// Get environment variable value.
		/// </summary>
		/// <param name="varName"></param>
		/// <param name="defaultValue"></param>
		/// <returns></returns>
		public static string GetEnvVar(string varName, string defaultValue)
		{
#if (PocketPC||NETCF||NETCF_2_0)
            string varValue = null;
#else
			string varValue = Environment.GetEnvironmentVariable(varName);
#endif
			if(null == varValue)
			{
				varValue = defaultValue;
			}

			return varValue;
		}

		#endregion

		#region Client id and connection

		protected string clientId;
		/// <summary>
		/// Client id.
		/// </summary>
		public string ClientId
		{
			get { return this.clientId; }
		}

		/// <summary>
		/// Gets a new client id.
		/// </summary>
		/// <returns>Client id</returns>
		public virtual string GetTestClientId()
		{
			System.Text.StringBuilder id = new System.Text.StringBuilder();

			id.Append("ID:");
			id.Append(this.GetType().Name);
			id.Append(":");
			id.Append(this.testRun);
			id.Append(":");
			id.Append(++idCounter);

			return id.ToString();
		}

		protected string userName;
		/// <summary>
		/// User name.
		/// </summary>
		public string UserName
		{
			get { return this.userName; }
		}

		protected string passWord;
		/// <summary>
		/// User pass word.
		/// </summary>
		public string PassWord
		{
			get { return this.passWord; }
		}

		/// <summary>
		/// Create a new connection to the broker.
		/// </summary>
		/// <returns>New connection</returns>
		public virtual IConnection CreateConnection()
		{
			return CreateConnection(null);
		}

		/// <summary>
		/// Create a new connection to the broker.
		/// </summary>
		/// <param name="newClientId">Client ID of the new connection.</param>
		/// <returns>New connection</returns>
		public virtual IConnection CreateConnection(string newClientId)
		{
			IConnection newConnection;

			if(this.userName == null)
			{
				newConnection = Factory.CreateConnection();
			}
			else
			{
				newConnection = Factory.CreateConnection(userName, passWord);
			}

			Assert.IsNotNull(newConnection, "Connection not created");

			if(newClientId != null)
			{
				newConnection.ClientId = newClientId;
			}

			return newConnection;
		}

		/// <summary>
		/// Create a new connection to the broker, and start it.
		/// </summary>
		/// <returns>Started connection</returns>
		public virtual IConnection CreateConnectionAndStart()
		{
			return CreateConnectionAndStart(null);
		}

		/// <summary>
		/// Create a new connection to the broker, and start it.
		/// </summary>
		/// <param name="newClientId">Client ID of the new connection.</param>
		/// <returns>Started connection</returns>
		public virtual IConnection CreateConnectionAndStart(string newClientId)
		{
			IConnection newConnection = CreateConnection(newClientId);
			newConnection.Start();
			return newConnection;
		}

		#endregion

		#region Destination

		/// <summary>
		/// Gets a clear destination.
		/// </summary>
		/// <param name="session">Session</param>
		/// <param name="type">Destination type</param>
		/// <param name="destinationRef">Configuration node name for the
		/// destination URI</param>
		/// <returns>Destination</returns>
		public virtual IDestination GetClearDestination(ISession session,
			DestinationType type, string destinationRef)
		{
			string uri = GetDestinationURI(type, destinationRef);

			return GetClearDestination(session, uri);
		}

		/// <summary>
		/// Gets a clear destination. This will try to delete an existing
		/// destination and re-create it.
		/// </summary>
		/// <param name="session">Session</param>
		/// <param name="destinationURI">Destination URI</param>
		/// <returns>Clear destination</returns>
		public virtual IDestination GetClearDestination(ISession session,
			string destinationURI)
		{
			IDestination destination;

			try
			{
				DeleteDestination(session, destinationURI);
				destination = CreateDestination(session, destinationURI);
			}
			catch(Exception)
			{
				// Can't delete it, so lets try and purge it.
				destination = SessionUtil.GetDestination(session, destinationURI);

				using(IMessageConsumer consumer = session.CreateConsumer(destination))
				{
					while(consumer.Receive(TimeSpan.FromMilliseconds(750)) != null)
					{
					}
				}
			}

			return destination;
		}

		/// <summary>
		/// Deletes a destination.
		/// </summary>
		/// <param name="session">Session</param>
		/// <param name="destinationURI">Destination URI</param>
		protected virtual void DeleteDestination(ISession session,
			string destinationURI)
		{
			// Only delete the destination if it can be recreated
			// SessionUtil.DeleteDestination(session, destinationURI, DestinationType.Queue)
			throw new NotSupportedException();
		}

		/// <summary>
		/// Creates a destination.
		/// </summary>
		/// <param name="session">Session</param>
		/// <param name="destinationURI">Destination URI</param>
		protected virtual IDestination CreateDestination(ISession session,
			string destinationURI)
		{
			throw new NotSupportedException();
		}

		/// <summary>
		/// Gets an existing destination. Don't clear its contents.
		/// </summary>
		/// <param name="session">Session</param>
		/// <param name="type">Destination type</param>
		/// <param name="destinationRef">Configuration node name for the
		/// destination URI</param>
		/// <returns>Destination</returns>
		public virtual IDestination GetDestination(ISession session,
			DestinationType type, string destinationRef)
		{
			string uri = GetDestinationURI(type, destinationRef);

			IDestination destination = SessionUtil.GetDestination(session, uri);

			return destination;
		}

		/// <summary>
		/// Gets a destination URI.
		/// </summary>
		/// <param name="type">Destination type</param>
		/// <param name="destinationRef">Configuration node name for the
		/// destination URI</param>
		/// <returns>Destination URI</returns>
		public virtual string GetDestinationURI(
			DestinationType type, string destinationRef)
		{
			string uri = null;

			if(!string.IsNullOrEmpty(destinationRef))
			{
				XmlElement uriNode = GetURINode();

				if(uriNode != null)
				{
					uri = GetNodeValueAttribute(uriNode, destinationRef, null);
				}
			}

			if(string.IsNullOrEmpty(uri))
			{
				uri = NewDestinationURI(type);
			}

			return uri;
		}

		/// <summary>
		/// Gets a new destination URI.
		/// </summary>
		/// <param name="type">Destination type</param>
		/// <returns>Destination URI</returns>
		public virtual string NewDestinationURI(DestinationType type)
		{
			string name = "TEST." + this.TestClassType.Name
						+ "." + Guid.NewGuid().ToString();
			string scheme;
			switch(type)
			{
				case DestinationType.Queue:
					scheme = "queue://";
					break;

				case DestinationType.Topic:
					scheme = "topic://";
					break;

				case DestinationType.TemporaryQueue:
					scheme = "temp-queue://";
					break;

				case DestinationType.TemporaryTopic:
					scheme = "temp-topic://";
					break;

				default:
					throw new ArgumentException("type: " + type);
			}

			return scheme + name;
		}

		#endregion
	}
}