/*
 * 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.Text;
using System.Collections.Specialized;
using NUnit.Framework;
using NUnit.Framework.Interfaces;
using Apache.NMS;
using Apache.NMS.AMQP.Test.Util;
using System.Diagnostics;
using System.Collections.Generic;
using System.Collections;
using System.Reflection;
using Apache.NMS.AMQP.Test.Attribute;

namespace Apache.NMS.AMQP.Test.TestCase
{

    internal static class NMSTestConstants
    {
        public const string NMS_SOLACE_PLATFORM = "Solace PubSub+";
        public const string NMS_ACTIVE_PRODUCT = "ActiveMQ";
    }

    internal static class NMSPropertyConstants
    {
        public const string NMS_CONNECTION_ENCODING = "NMS.Message.Serialization";
        public const string NMS_CONNECTION_CLIENT_ID = "NMS.ClientId";
        public const string NMS_CONNECTION_USERNAME = "NMS.Username";
        public const string NMS_CONNECTION_PASSWORD = "NMS.Password";
        public const string NMS_CONNECTION_REQUEST_TIMEOUT = "NMS.RequestTimeout";
        public const string NMS_CONNECTION_MAX_FRAME_SIZE = "NMS.MaxFrameSize";
        public const string NMS_CONNECTION_CLOSE_TIMEOUT = "NMS.CloseTimeout";

        #region Transport Properties

        public const string NMS_TRANSPORT_RECEIVE_BUFFER_SIZE = "transport.ReceiveBufferSize";

        public const string NMS_TRANSPORT_RECEIVE_TIMEOUT = "transport.ReceiveTimeout";

        public const string NMS_TRANSPORT_SEND_BUFFER_SIZE = "transport.SendBufferSize";

        public const string NMS_TRANSPORT_SEND_TIMEOUT = "transport.SendTimeout";

        public const string NMS_TRANSPORT_USE_LOGGING = "transport.UseLogging";

        public const string NMS_SECURE_TRANSPORT_ACCEPT_INVALID_BROKER_CERT = "transport.AcceptInvalidBrokerCert";

        public const string NMS_SECURE_TRANSPORT_CLIENT_CERT_FILE_NAME = "transport.ClientCertFileName";

        public const string NMS_SECURE_TANSPORT_KEY_STORE_NAME = "transport.KeyStoreName";

        public const string NMS_SECURE_TANSPORT_KEY_STORE_LOCATION = "transport.KeyStoreLocation";

        public const string NMS_SECURE_TANSPORT_CLIENT_CERT_PASSWORD = "transport.ClientCertPassword";

        public const string NMS_SECURE_TANSPORT_CLIENT_CERT_SUBJECT = "transport.ClientCertSubject";

        public const string NMS_SECURE_TANSPORT_SERVER_NAME = "transport.ServerName";

        public const string NMS_SECURE_TANSPORT_SSL_PROTOCOLS = "transport.SSLProtocol";

        public const string NMS_SECURE_TRANSPORT_SSL_CHECK_CERTIFICATE_REVOCATION = "transport.CheckCertificateRevocation";

        #endregion
    }

    #region NMSTestContainer Class

    /// <summary>
    /// NMSTestContainer Root class for all tests. Container NMS object Instances for testing and manages them.
    /// </summary>
    public abstract class NMSTestContainer
    {
        public static StringDictionary Clone(StringDictionary original)
        {
            if(original == null) return null;
            StringDictionary clone = new StringDictionary();
            foreach (string key in original.Keys)
            {
                clone.Add(key.Clone() as string, original[key].Clone() as string);
            }
            return clone;
        }

        public static string ToString(IDictionary dictionary, int indt = 0)
        {
            if (dictionary == null) return "[]";
            StringBuilder sb = new StringBuilder();

            int indent = Math.Max(0, Math.Min(indt, 16));
            StringBuilder sbTabs = new StringBuilder();
            for (int i = 0; i < indent; i++)
            {
                sbTabs.Append('\t');
            }
            string wspace = sbTabs.ToString();

            sb.AppendFormat("[\n");
            foreach (object key in dictionary.Keys)
            {
                if (key != null)
                {
                    //Console.WriteLine("key: {0}, value: {1}", key, dictionary[key]);
                    
                    sb.AppendFormat("{0}\t[Key:{1}, Value: {2}]\n", wspace, key.ToString(), dictionary[key]?.ToString());
                }
            }
            sb.AppendFormat("{0}]", wspace);
            return sb.ToString();
        }

        public static string ToString(StringDictionary dictionary, int indt = 0)
        {
            if (dictionary == null) return "[]";
            StringBuilder sb = new StringBuilder();
            
            int indent = Math.Max(0, Math.Min(indt, 16));
            StringBuilder sbTabs = new StringBuilder();
            for (int i = 0; i < indent; i++)
            {
                sbTabs.Append('\t');
            }
            string wspace = sbTabs.ToString();
            
            sb.AppendFormat("{0}[\n", wspace);
            foreach (string key in dictionary.Keys)
            {
                if (key != null)
                {
                    sb.AppendFormat("{0}\t[Key:{1}, Value: {2}]\n", wspace, key, dictionary[key] ?? "null");
                }
            }
            sb.AppendFormat("{0}]", wspace);
            return sb.ToString();
        }

        protected StringDictionary properties = null;
        protected StringDictionary DefaultProperties = null;
        private Apache.NMS.NMSConnectionFactory providerFactory = null;

        private IList<IConnectionFactory> connectionFactories = new List<IConnectionFactory>();
        private IList<IConnection> connections = new List<IConnection>();
        private IList<ISession> sessions = new List<ISession>();
        private IList<IMessageProducer> producers = new List<IMessageProducer>();
        private IList<IMessageConsumer> consumers = new List<IMessageConsumer>();
        private IList<IDestination> destinations = new List<IDestination>();

        private IDictionary<string, int> connectionFactoryIndexMap = new Dictionary<string, int>();
        private IDictionary<string, int> connectionIndexMap = new Dictionary<string, int>();
        private IDictionary<string, int> sessionIndexMap = new Dictionary<string, int>();
        private IDictionary<string, int> producerIndexMap = new Dictionary<string, int>();
        private IDictionary<string, int> consumerIndexMap = new Dictionary<string, int>();
        private IDictionary<string, int> destinationIndexMap = new Dictionary<string, int>();
        private IDictionary<Type, IList> NMSInstanceTypeMap = new Dictionary<Type, IList>();
        private IDictionary<Type, IDictionary> NMSInstanceTypeIndexMap = new Dictionary<Type, IDictionary>();

        protected NMSTestContainer()
        {
            NMSInstanceTypeMap[typeof(IConnectionFactory)] = connectionFactories as List<IConnectionFactory> as IList;
            NMSInstanceTypeMap[typeof(IConnection)] = connections as List<IConnection> as IList;
            NMSInstanceTypeMap[typeof(ISession)] = sessions as List<ISession> as IList;
            NMSInstanceTypeMap[typeof(IMessageProducer)] = producers as List<IMessageProducer> as IList;
            NMSInstanceTypeMap[typeof(IMessageConsumer)] = consumers as List<IMessageConsumer> as IList;
            NMSInstanceTypeMap[typeof(IDestination)] = destinations as List<IDestination> as IList;

            NMSInstanceTypeIndexMap[typeof(IConnectionFactory)] = connectionFactoryIndexMap as Dictionary<string, int>;
            NMSInstanceTypeIndexMap[typeof(IConnection)] = connectionIndexMap as Dictionary<string, int>;
            NMSInstanceTypeIndexMap[typeof(ISession)] = sessionIndexMap as Dictionary<string, int>;
            NMSInstanceTypeIndexMap[typeof(IMessageProducer)] = producerIndexMap as Dictionary<string, int>;
            NMSInstanceTypeIndexMap[typeof(IMessageConsumer)] = consumerIndexMap as Dictionary<string, int>;
            NMSInstanceTypeIndexMap[typeof(IDestination)] = destinationIndexMap as Dictionary<string, int>;

            //try
            //{
            //    Console.WriteLine("TYPE MAP: {0}", ToString(NMSInstanceTypeMap as Dictionary<Type, IList>));
            //    Console.WriteLine("TYPE INDEX MAP: {0}", ToString(NMSInstanceTypeIndexMap as Dictionary<Type, IDictionary>));
            //}
            //catch (Exception e)
            //{
            //    Console.Error.WriteLine("Error: {0}", e.Message);
            //    Console.WriteLine(e);
            //}
        }

        public Uri BrokerURI
        {
            get { return TestConfig.Instance.BrokerUri; }
            //protected set { if (connectionFactory != null) { ConnectionFactory.BrokerUri = value; } }
        }
        internal StringDictionary ConnectionFactoryProperties
        {
            get { return Clone(properties); }
        }

        private void UpdateConnectionFactoryProperty(string key, string value)
        {
            if(properties != null && key != null)
            {
                if (this.properties.ContainsKey(key))
                {
                    this.properties[key] = value;
                }
                else 
                {
                    this.properties.Add(key, value);
                }
            }
        }

        internal void InitConnectedFactoryProperties(StringDictionary additionalProperties = null)
        {
            bool isDefault = this.properties == null;
            // add properties from the TestConfig first and use as Default Properties.
            properties = new StringDictionary();
            if (TestConfig.Instance.BrokerUsername != null)
            {
                this.UpdateConnectionFactoryProperty(NMSPropertyConstants.NMS_CONNECTION_USERNAME, TestConfig.Instance.BrokerUsername);
            }
            if (TestConfig.Instance.BrokerPassword != null)
            {
                this.UpdateConnectionFactoryProperty(NMSPropertyConstants.NMS_CONNECTION_PASSWORD, TestConfig.Instance.BrokerPassword);
            }
            if (TestConfig.Instance.ClientId != null)
            {
                ConnectionFactoryProperties[NMSPropertyConstants.NMS_CONNECTION_CLIENT_ID] = TestConfig.Instance.ClientId;
            }

            // init secure properties if broker uri is secure
            if (TestConfig.Instance.IsSecureBroker)
            {
                if (TestConfig.Instance.AcceptInvalidBrokerCert)
                {
                    string value = TestConfig.Instance.AcceptInvalidBrokerCert ? bool.TrueString : bool.FalseString;
                    this.UpdateConnectionFactoryProperty(NMSPropertyConstants.NMS_SECURE_TRANSPORT_ACCEPT_INVALID_BROKER_CERT, value);
                }
                if (TestConfig.Instance.ClientCertFileName != null)
                {
                    this.UpdateConnectionFactoryProperty(NMSPropertyConstants.NMS_SECURE_TRANSPORT_CLIENT_CERT_FILE_NAME, TestConfig.Instance.ClientCertFileName);
                }
                if (TestConfig.Instance.KeyStoreName != null)
                {
                    this.UpdateConnectionFactoryProperty(NMSPropertyConstants.NMS_SECURE_TANSPORT_KEY_STORE_NAME, TestConfig.Instance.KeyStoreName);
                }
                if (TestConfig.Instance.KeyStoreLocation != null)
                {
                    this.UpdateConnectionFactoryProperty(NMSPropertyConstants.NMS_SECURE_TANSPORT_KEY_STORE_NAME, TestConfig.Instance.KeyStoreLocation);
                }
                if (TestConfig.Instance.BrokerName != null)
                {
                    this.UpdateConnectionFactoryProperty(NMSPropertyConstants.NMS_SECURE_TANSPORT_SERVER_NAME, TestConfig.Instance.BrokerName);
                }
                if (TestConfig.Instance.ClientCertSubject != null)
                {
                    this.UpdateConnectionFactoryProperty(NMSPropertyConstants.NMS_SECURE_TANSPORT_CLIENT_CERT_SUBJECT, TestConfig.Instance.ClientCertSubject);
                }
                if (TestConfig.Instance.ClientCertPassword != null)
                {
                    this.UpdateConnectionFactoryProperty(NMSPropertyConstants.NMS_SECURE_TANSPORT_CLIENT_CERT_PASSWORD, TestConfig.Instance.ClientCertPassword);
                }
            }

            if (DefaultProperties == null || isDefault)
                DefaultProperties = Clone(properties);

            // add/overwrite Additional properies for unique purposes.
            if (additionalProperties != null)
            {
                foreach (string key in additionalProperties.Keys)
                {
                    if (properties.ContainsKey(key))
                    {
                        properties[key] = additionalProperties[key];
                    }
                    else
                    {
                        properties.Add(key, additionalProperties[key]);
                    }
                }
            }

        }

        #region NMS Instance Create Methods
        internal IConnectionFactory CreateConnectionFactory()
        {
            if (providerFactory == null)
            {
                providerFactory = new NMSConnectionFactory(BrokerURI, properties);
            }
            return providerFactory.ConnectionFactory;
        }

        internal IConnection CreateConnection(string nmsConnectionFactoryId)
        {
            return CreateConnection(GetConnectionFactory(nmsConnectionFactoryId));
        }

        internal IConnection CreateConnection(int index = 0)
        {
            return CreateConnection(GetConnectionFactory(index));
        }

        internal IConnection CreateConnection(IConnectionFactory factory)
        {
            return factory.CreateConnection();
        }

        internal ISession CreateSession(string nmsConnectionId)
        {
            return CreateSession(GetConnection(nmsConnectionId));
        }

        internal ISession CreateSession(int index = 0)
        {
            return CreateSession(GetConnection(index));
        }

        internal ISession CreateSession(IConnection connection)
        {
            return connection.CreateSession();
        }

        internal IMessageProducer CreateProducer(string nmsSessionId, string nmsDestinationId)
        {
            return CreateProducer(GetSession(nmsSessionId), GetDestination(nmsDestinationId));
        }


        internal IMessageProducer CreateProducer(int sessionIndex = 0, int destinationIndex = 0)
        {
            return CreateProducer(GetSession(sessionIndex), GetDestination(destinationIndex));
        }

        internal IMessageProducer CreateProducer(ISession session, IDestination destination)
        {
            return session.CreateProducer(destination);
        }

        internal IMessageConsumer CreateConsumer(string nmsSessionId, string nmsDestinationId)
        {
            return CreateConsumer(GetSession(nmsSessionId), GetDestination(nmsDestinationId));
        }


        internal IMessageConsumer CreateConsumer(int sessionIndex = 0, int destinationIndex = 0)
        {
            return CreateConsumer(GetSession(sessionIndex), GetDestination(destinationIndex));
        }

        internal IMessageConsumer CreateConsumer(ISession session, IDestination destination)
        {
            return session.CreateConsumer(destination);
        }

        internal ITopic CreateTopic(string name, string nmsId)
        {
            return CreateTopic(GetSession(nmsId), name);
        }

        internal ITopic CreateTopic(string name, int index = 0)
        {
            return CreateTopic(GetSession(index), name);
        }

        internal ITopic CreateTopic(ISession session, string name)
        {
            return session.GetTopic(name);
        }

        internal ITopic CreateTemporaryTopic(string nmsId)
        {
            return CreateTemporaryTopic(GetSession(nmsId));
        }

        internal ITopic CreateTemporaryTopic(int index = 0)
        {
            return CreateTemporaryTopic(GetSession(index));
        }

        internal ITemporaryTopic CreateTemporaryTopic(ISession session)
        {
            return session.CreateTemporaryTopic();
        }

        internal IQueue CreateQueue(string name, string nmsId)
        {
            return CreateQueue(GetSession(nmsId), name);
        }

        internal IQueue CreateQueue(string name, int index = 0)
        {
            return CreateQueue(GetSession(index), name);
        }

        internal IQueue CreateQueue(ISession session, string name)
        {
            return session.GetQueue(name);
        }

        internal IQueue CreateTemporaryQueue(string nmsId)
        {
            return CreateTemporaryQueue(GetSession(nmsId));
        }

        internal IQueue CreateTemporaryQueue(int index = 0)
        {
            return CreateTemporaryQueue(GetSession(index));
        }

        internal ITemporaryQueue CreateTemporaryQueue(ISession session)
        {
            return session.CreateTemporaryQueue();
        }


        #endregion

        #region NMS Instance Get Methods

        internal IConnectionFactory GetConnectionFactory(int index = 0)
        {
            return LookupNMSInstance(connectionFactories, index);
        }

        internal IConnectionFactory GetConnectionFactory(string nmsId)
        {
            int index = connectionFactoryIndexMap[nmsId];
            return LookupNMSInstance(connectionFactories, index);
        }

        internal IConnection GetConnection(int index = 0)
        {
            return LookupNMSInstance(connections, index);
        }

        internal IConnection GetConnection(string nmsId)
        {
            int index = connectionIndexMap[nmsId];
            return LookupNMSInstance(connections, index);
        }

        internal ISession GetSession(int index = 0)
        {
            return LookupNMSInstance(sessions, index);
        }

        internal ISession GetSession(string nmsId)
        {
            //Console.WriteLine("Trying to find Session {0}, in Index Map {1}.", nmsId, ToString(sessionIndexMap as Dictionary<String, int>));
            int index = sessionIndexMap[nmsId];
            return LookupNMSInstance(sessions, index);
        }

        internal IMessageProducer GetProducer(int index = 0)
        {
            return LookupNMSInstance(producers, index);
        }

        internal IMessageProducer GetProducer(string nmsId)
        {
            int index = producerIndexMap[nmsId];
            return LookupNMSInstance(producers, index);
        }

        internal IMessageConsumer GetConsumer(int index = 0)
        {
            return LookupNMSInstance(consumers, index);
        }
        internal IMessageConsumer GetConsumer(string nmsId)
        {
            int index = consumerIndexMap[nmsId];
            return LookupNMSInstance(consumers, index);
        }

        internal IDestination GetDestination(int index = 0)
        {
            return LookupNMSInstance(destinations, index);
        }

        internal IDestination GetDestination(string nmsId)
        {
            int index = destinationIndexMap[nmsId];
            return LookupNMSInstance(destinations, index);
        }

        internal IList<IConnection> GetConnections(params string[] nmsIds)
        {
            return GetNMSIntances<IConnection>(nmsIds);
        }

        internal IList<ISession> GetSessions(params string[] nmsIds)
        {
            return GetNMSIntances<ISession>(nmsIds);
        }
        internal IList<IDestination> GetDestinations(params string[] nmsIds)
        {
            return GetNMSIntances<IDestination>(nmsIds);
        }
        internal IList<IMessageConsumer> GetConsumers(params string[] nmsIds)
        {
            return GetNMSIntances<IMessageConsumer>(nmsIds);
        }
        internal IList<IMessageProducer> GetProducers(params string[] nmsIds)
        {
            return GetNMSIntances<IMessageProducer>(nmsIds);
        }

        private IList<I> GetNMSIntances<I>(params string[] nmsIds)
        {
            IDictionary NMSInstanceIndexMap = NMSInstanceTypeIndexMap[typeof(I)];
            IList NMSInstances = NMSInstanceTypeMap[typeof(I)];
            return GetNMSIntances<I>(NMSInstanceIndexMap as Dictionary<string,int>, NMSInstances as List<I>, nmsIds);
        }

        private IList<I> GetNMSIntances<I>(IDictionary<string, int> indexMap, IList<I> instances, params string[] nmsIds)
        {
            if (nmsIds == null)
            {
                return null;
            }
            else if (nmsIds.Length == 0)
            {
                return new List<I>();
            }
            List<I> list = new List<I>();
            foreach (string id in nmsIds)
            {
                int index = -1;
                if (indexMap.TryGetValue(id, out index))
                {
                    try
                    {
                        list.Add(LookupNMSInstance(instances, index));
                    }
                    catch (Exception ex)
                    {
                        BaseTestCase.Logger.Error("Caught exception when looking up NMS Instance " + typeof(I).Name + " for Id \"" + id + "\" Message : " + ex.Message );
                    }
                }
            }

            return list;
        }

        private I LookupNMSInstance<I>(IList<I> list, int index = 0)
        {
            if (index < 0 || index >= list.Count)
            {
                throw new ArgumentOutOfRangeException(string.Format("Invalid index {0}, for {1} Collection.", index, typeof(I).Name));
            }
            
            I nmsInstance = list[index];
            if (nmsInstance == null)
            {
                throw new ArgumentException(string.Format("Invalid index {0}, for {1} Collection. Return value is null.", index, typeof(I).Name));
            }
            return nmsInstance;
        }

        #endregion
        
        #region NMS Instance Exists Methods
        
        internal bool NMSInstanceExists<I>(int index)
        {
            IList NMSInstances = NMSInstanceTypeMap[typeof(I)];
            if (index < 0 || index >= NMSInstances.Count) return false;
            return NMSInstances[index] != null;
        }

        internal bool NMSInstanceExists<I>(string nmsId)
        {
            IDictionary NMSInstances = NMSInstanceTypeIndexMap[typeof(I)];
            if (NMSInstances.Contains(nmsId)) return false;
            int index = (int)NMSInstances[nmsId];
            return NMSInstanceExists<I>(index);
        }


        #endregion

        #region NMS Instance Add Methods

        internal void AddConnectionFactory(IConnectionFactory factory, string nmsId=null)
        {
            int index = AddNMSInstance(connectionFactories, factory);
            AddNMSInstanceIndexLookup(connectionFactoryIndexMap, nmsId, index);
        }

        internal void AddConnection(IConnection connection, string nmsId = null)
        {
            int index = AddNMSInstance(connections, connection);
            AddNMSInstanceIndexLookup(connectionIndexMap, nmsId, index);
        }

        internal void AddSession(ISession session, string nmsId = null)
        {
            int index = AddNMSInstance(sessions, session);
            AddNMSInstanceIndexLookup(sessionIndexMap, nmsId, index);
        }

        internal void AddProducer(IMessageProducer producer, string nmsId = null)
        {
            int index = AddNMSInstance(producers, producer);
            AddNMSInstanceIndexLookup(producerIndexMap, nmsId, index);
        }

        internal void AddConsumer(IMessageConsumer consumer, string nmsId = null)
        {
            int index = AddNMSInstance(consumers, consumer);
            AddNMSInstanceIndexLookup(consumerIndexMap, nmsId, index);
        }

        internal void AddDestination(IDestination destination, string nmsId = null)
        {
            int index = AddNMSInstance(destinations, destination);
            AddNMSInstanceIndexLookup(destinationIndexMap, nmsId, index);
        }


        private int AddNMSInstance<I>(IList<I> list, I instance)
        {
            if (instance == null)
            {
                return -1;
            }
            int previousIndex = list.IndexOf(instance);
            if (list.Contains(instance)) return previousIndex;
            list.Add(instance);
            return list.IndexOf(instance);
        }

        private void AddNMSInstanceIndexLookup(IDictionary<string,int>lookupTable, string nmsId, int index)
        {
            if (index != -1 && nmsId != null)
            {
                lookupTable.Add(nmsId, index);
            }
        }

        #endregion

        #region Object Override Methods

        public override string ToString()
        {
            string result = "" + this.GetType().Name + ": [\n";
            result += "\tConnection Factories: " + this.connectionFactories.Count + "\n";
            result += "\tConnections: " + this.connections.Count + "\n";
            result += "\tSessions: " + this.sessions.Count + "\n";
            result += "\tProducers: " + this.producers.Count + "\n";
            result += "\tConsumers: " + this.consumers.Count + "\n";
            result += "\tDestinations: " + this.destinations.Count + "\n";
            result += "\tConnection Factory Index Table: " + ToString(this.connectionFactoryIndexMap as IDictionary, 1) + "\n";
            result += "\tConnection Index Table: " + ToString(this.connectionIndexMap as IDictionary, 1) + "\n";
            result += "\tSession Index Table: " + ToString(this.sessionIndexMap as IDictionary, 1) + "\n";
            result += "\tConsumer Index Table: " + ToString(this.consumerIndexMap as IDictionary, 1) + "\n";
            result += "\tProducer Index Table: " + ToString(this.producerIndexMap as IDictionary, 1) + "\n";
            result += "\tDestination Index Table: " + ToString(this.destinationIndexMap as IDictionary, 1) + "\n";
            result += "]";
            return result;
        }

        #endregion

        #region NMS Instance Management Cleanup

        protected void CleanupInstances(bool dispose = false)
        {
            CloseInstances();
            ClearIndexes();
            ClearInstances(dispose);
            GC.Collect();
        }

        private void CloseInstances()
        {
            if (this.producers != null)
            {
                foreach(IMessageProducer p in producers)
                {
                    p?.Close();
                }
            }

            if (this.consumers != null)
            {
                foreach(IMessageConsumer c in consumers)
                {
                    c?.Close();
                }
            }

            if (this.sessions != null)
            {
                foreach(ISession s in sessions)
                {
                    s?.Close();
                }
            }

            if (this.connections != null)
            {
                foreach(IConnection c in connections)
                {
                    c?.Close();
                }
            }
            
        }

        private void ClearIndexes()
        {
            foreach(IDictionary indexTable in NMSInstanceTypeIndexMap.Values)
            {
                indexTable.Clear();
            }
        }

        private void ClearInstances(bool dispose = false)
        {
            
            if (dispose && this.producers != null)
            {
                foreach (IMessageProducer p in producers)
                {
                    p?.Dispose();
                }
            }
            producers?.Clear();

            if (dispose && this.consumers != null)
            {
                foreach (IMessageConsumer c in consumers)
                {
                    c?.Dispose();
                }
            }
            consumers?.Clear();

            if (dispose && this.sessions != null)
            {
                foreach (ISession s in sessions)
                {
                    s?.Close();
                }
            }
            sessions?.Clear();

            if (dispose && this.connections != null)
            {
                foreach (IConnection c in connections)
                {
                    c?.Close();
                }
            }
            connections?.Clear();

            connectionFactories?.Clear();

            providerFactory = null;
        }

        #endregion

    }

    #endregion

    #region BaseTestCase Class

    public abstract class BaseTestCase : NMSTestContainer
    {
        
        internal static ITrace Logger = new NMSLogger(NMSLogger.ToLogLevel(TestConfig.Instance.LogLevel));

        internal const string DURABLE_TOPIC_NAME = "nms.durable.test";
        internal const string DURABLE_SUBSRIPTION_NAME = "uniqueSub";

        static BaseTestCase()
        {
            Tracer.Trace = Logger;
        }

        public virtual bool IsSecureBroker { get => TestConfig.Instance.IsSecureBroker; }

        private static readonly TestSetupAttributeComparer TestSetupOrderComparer = new TestSetupAttributeComparer();
        private class TestSetupAttributeComparer : IComparer<TestSetupAttribute>
        {
            public int Compare(TestSetupAttribute x, TestSetupAttribute y)
            {
                int result = y.ComparableOrder - x.ComparableOrder;
                if(result == 0)
                {
                    result = x.CompareTo(y);
                }
                return result;
            }
        }
        
        private void ApplyTestSetupAttributes()
        {
            // Apply TestSetup Attribute in correct order
            TestContext.TestAdapter testAdapter = TestContext.CurrentContext.Test;
            MethodInfo methodInfo = GetType().GetMethod(testAdapter.MethodName);
            object[] attributes = methodInfo.GetCustomAttributes(true);

            // This set will order the TestSetup Attributes in the appropriate execution order for NMS Instance Initialization.
            // ie, should a test setup a connection and a session dependent that connection it ensure the connection setup attribute
            // execute its setup first.
            ISet<TestSetupAttribute> testSetupAttributes = new SortedSet<TestSetupAttribute>(TestSetupOrderComparer);
            foreach (System.Attribute attribute in attributes)
            {
                if (attribute is TestSetupAttribute)
                {
                    //Console.WriteLine("Setup Attribute Identification: {0}.", attribute.GetType().Name);
                    testSetupAttributes.Add(attribute as TestSetupAttribute);
                }
            }
            foreach (TestSetupAttribute tsa in testSetupAttributes)
            {
                //Console.WriteLine("Setup Attribute: {0}.", tsa.GetType().Name);
                try
                {
                    tsa.Setup(this);
                }
                catch (Exception ex)
                {
                    this.PrintTestFailureAndAssert(testAdapter.MethodName, "Failed to setup test attribute.", ex);
                }

            }
        }

        [SetUp]
        public virtual void Setup()
        {
            Logger.Info(string.Format("Setup TestCase {0} for test {1}.",
                this.GetType().Name, TestContext.CurrentContext.Test.MethodName));
            try
            {
                // Setup NMS Instances for test.
                ApplyTestSetupAttributes();
            }
            catch(Exception ex)
            {
                this.PrintTestFailureAndAssert(GetTestMethodName(), 
                    "Failure in setup attributes.", ex);
            }
            finally
            {
                // Always Setup common test varibles.
                msgCount = 0;
                asyncEx = null;
                StopOnAsyncFailure = true;
            }
            
        }

        [TearDown]
        public virtual void TearDown()
        {
            Logger.Info(string.Format("Tear Down TestCase {0} for test {1}.", this.GetType().Name, TestContext.CurrentContext.Test.MethodName));
            waiter?.Dispose();
            // restore properties for next test
            properties = Clone(DefaultProperties);
            CleanupInstances();
            Logger.Info(string.Format("Tear Down Finished for TestCase {0} for test {1}.", this.GetType().Name, TestContext.CurrentContext.Test.MethodName));
        }

        protected string GetMethodName()
        {
            StackTrace stackTrace = new StackTrace();
            return stackTrace.GetFrame(1).GetMethod().Name;
        }


        protected string GetTestMethodName()
        {
            TestContext.TestAdapter testAdapter = TestContext.CurrentContext.Test;
            return testAdapter.MethodName;
        }

        internal virtual void PrintTestFailureAndAssert(string methodDescription, string info, Exception ex)
        {
            if (ex is AssertionException || ex is IgnoreException || ex is SuccessException)
            {
                throw ex;
            }
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("@@Test Failed in {0}", methodDescription);
            if (info != null)
            {
                sb.AppendFormat(", where info = {0}", info);
            }
            if (ex != null)
            {
                sb.AppendFormat(", {0}\n", GetTestException(ex));
            }
            
            Logger.Error(sb.ToString());
            Assert.Fail(sb.ToString());
        }

        protected virtual string GetTestException(Exception ex)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("Encountered an exception:\n\tMessage = {0}\n", ex.Message);
            sb.AppendFormat("\tType = {0}\n", ex.GetType());
            sb.AppendFormat("\tStack = {0}\n", ex.StackTrace);
            if(ex is NMSException)
            {
                string errcode = (ex as NMSException).ErrorCode;
                if (errcode != null && errcode.Length > 0)
                {
                    sb.AppendFormat("\tErrorCode = {0}\n", errcode);
                }
            }
            if (null != ex.InnerException )
            {
                sb.AppendFormat("Inner Exception:\n\t{0}", GetTestException(ex.InnerException));
            }
            return sb.ToString();
            
        }

        internal void PrintTestException(Exception ex)
        {
            
            Logger.Error(GetTestException(ex));
        }

        #region Common Test properties and Components

        protected int msgCount = 0;
        protected Exception asyncEx = null;
        protected System.Threading.ManualResetEvent waiter;
        protected bool StopOnAsyncFailure = true;

        protected virtual void DefaultExceptionListener(Exception ex)
        {
            this.PrintTestException(ex);
            asyncEx = ex;
            if(waiter!= null && StopOnAsyncFailure)
                waiter.Set();
        }

        protected virtual MessageListener CreateListener(int expectedMsgs)
        {
            return (m) =>
            {
                DefaultMessageListener(m);
                if (msgCount >= expectedMsgs)
                {
                    if(waiter != null)
                    {
                        Logger.Debug(string.Format("Received all msgs ({0}) on callback.", msgCount));
                        waiter.Set();
                    }
                        
                }
            };
        }

        protected long ExtractMsgId(string nmsMsgId)
        {
            long result = -1;
            int index = nmsMsgId.LastIndexOf(':');
            if (index >= 0)
            {
                try
                {
                    result = Convert.ToInt64(nmsMsgId.Substring(index + 1));
                }
                catch (Exception e)
                {
                    Logger.Warn("Failed to extract Msg Id from nmsMsgId " + nmsMsgId + " Cause: " + e.Message);
                }
            }
            return result;
        }

        protected virtual void DefaultMessageListener(IMessage message)
        {
            msgCount++;
            Logger.Debug(string.Format("Received msg {0} on Async Callback.(Count = {1})", message.NMSMessageId, msgCount));
        }


        #endregion

    }

    #endregion

}