namespace StockSharp.Plaza
{
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Runtime.InteropServices;

	using Ecng.Collections;
	using Ecng.Common;

	using StockSharp.Algo;
	using StockSharp.BusinessEntities;

#if _WIN64
	using P2ClientGateMTA64;
#else
    using P2ClientGateMTA32;
#endif
	
	/// <summary>
	/// Менеджер транзакций.
	/// </summary>
	public class TransactionManager
	{
		/// <summary>
		/// Внутренний класс для обработки Plaza сообщений.
		/// </summary>
		[ComVisible(true)]
		public sealed class MessageDispatcher : IP2AsyncSendEvent2
		{
			private readonly Action<CP2BLMessage, uint, long> _handler;

			internal MessageDispatcher(Action<CP2BLMessage, uint, long> handler)
			{
				if (handler == null)
					throw new ArgumentNullException("handler");

				_handler = handler;
			}

			void IP2AsyncSendEvent2.SendAsync2Reply(CP2BLMessage reply, uint errCode, long eventParam)
			{
				_handler(reply, errCode, eventParam);
			}
		}

		private readonly MessageDispatcher _messageDispatcher;
		private readonly CP2ConnectionClass _connection;

		private readonly SynchronizedMultiDictionary<Order, Transaction> _transactionsByOrders = new SynchronizedMultiDictionary<Order, Transaction>();
		private readonly SynchronizedMultiDictionary<long, Transaction> _transactionsByTransactionIds = new SynchronizedMultiDictionary<long, Transaction>();

		internal TransactionManager(PlazaConnectionPool connectionPool, TransactionIdGenerator idGenerator)
		{
			if (connectionPool == null)
				throw new ArgumentNullException("connectionPool");

			_connection = connectionPool.CreateConnection();
			connectionPool.RunConnection(_connection);

			Factory = new TransactionFactory(connectionPool, idGenerator);
            TransactionTimeOut = TimeSpan.FromSeconds(5);

			_messageDispatcher = new MessageDispatcher((msg, errorCode, transactionId) => ProcessReply(transactionId, msg));

			IsAsync = true;
		}

		/// <summary>
		/// Использовать ли асинхронный режим при отправке транзакций.
		/// </summary>
		/// <remarks>
		/// Значение по умолчанию равно true.
		/// </remarks>
		public bool IsAsync { get; set; }

		/// <summary>
		/// Фабрика транзакций.
		/// </summary>
		public TransactionFactory Factory { get; private set; }

		/// <summary>
		/// Время, в течении которого ожидается ответ для транзакции.
		/// </summary>
		/// <remarks>
		/// По-умолчанию равно 5 секундам.
		/// </remarks>
		public TimeSpan TransactionTimeOut {get; set;}

		/// <summary>
		/// Обработать отправляемую транзакцию до того, как она будет отослана на сервер Plaza.
		/// </summary>
		public event Action<Transaction> ProcessRequest;

		/// <summary>
		/// Обработать полученную транзакцию до того, как она будет обработана <see cref="PlazaTrader"/>.
		/// </summary>
		public event Action<Transaction> ProcessResponse;

		/// <summary>
		/// Отправить транзакцию на сервер Plaza.
		/// </summary>
		/// <param name="transaction">Транзакция.</param>
		public void SendTransaction(Transaction transaction)
		{
			if (transaction == null)
				throw new ArgumentNullException("transaction");

			ProcessRequest.SafeInvoke(transaction);

			AddTransaction(transaction);

			var timeOut = (uint)TransactionTimeOut.TotalMilliseconds;
			var plazaMessage = transaction.PlazaMessage;

			if (IsAsync)
				plazaMessage.SendAsync2(_connection, timeOut, _messageDispatcher, transaction.Id);
			else
			{
				var reply = plazaMessage.Send(_connection, timeOut);
				ProcessReply(transaction, reply);
			}
		}

		/// <summary>
		/// Получить транзакции, связанные с заявкой (например, на регистрацию и снятие).
		/// </summary>
		/// <param name="order">Заявка, для которой необходимо получить ее транзакции.</param>
		/// <returns>Транзакции.</returns>
		public IEnumerable<Transaction> GetTransactions(Order order)
		{
			if (order == null)
				throw new ArgumentNullException("order");

			return _transactionsByOrders.TryGetValue(order) ?? Enumerable.Empty<Transaction>();
		}

		/// <summary>
		/// Получить транзакции (запрос и ответ) по номеру.
		/// </summary>
		/// <param name="transactionId">Номер транзакции.</param>
		/// <returns>Транзакции (запрос и ответ).</returns>
		public IEnumerable<Transaction> GetTransactions(long transactionId)
		{
			return _transactionsByTransactionIds.TryGetValue(transactionId);
		}

		private void AddTransaction(Transaction transaction)
		{
			if (transaction == null)
				throw new ArgumentNullException("transaction");

			_transactionsByTransactionIds.Add(transaction.Id, transaction);

			foreach (var order in transaction.Orders)
				_transactionsByOrders.Add(order, transaction);
		}

		private void ProcessReply(long transactionId, CP2BLMessage reply)
		{
			ProcessReply(GetTransactions(transactionId).Single(), reply);
		}

		private void ProcessReply(Transaction originMessage, CP2BLMessage reply)
		{
			var replyTransaction = new Transaction(originMessage, reply);
			AddTransaction(replyTransaction);

			PlazaException errorInfo;

			if (replyTransaction.GetCategory() == TransactionFactory.MessagesCategory)
			{
				var code = replyTransaction.GetReplyCode();
				errorInfo = code == 0 ? null : new PlazaException(code, replyTransaction.GetMessage());
			}
			else
				errorInfo = new PlazaException(replyTransaction.GetErrorCode(), "Неизвестная ошибка.");

			replyTransaction.ErrorInfo = errorInfo;

			ProcessResponse.SafeInvoke(replyTransaction);
		}
	}
}