namespace SampleGUI
{
	using System;
	using System.Collections.Generic;
	using System.ComponentModel;
	using System.IO;
	using System.Linq;
	using System.Net;
	using System.Threading;
	using System.Windows;
	using MessageBox = System.Windows.MessageBox;

	using Ecng.Serialization;
	using Ecng.Common;
	using Ecng.Collections;
	using Ecng.Xaml;

	using StockSharp.BusinessEntities;
	using StockSharp.Plaza;
    using StockSharp.Xaml;
    using StockSharp.Algo.Logging;

	public partial class MainWindow: ILogSource
	{
		private bool _isConnected;
		private const string _revFile = "revisions.xml";

        private LogManager logManager = new LogManager();
        private GuiLogListener guiLogListener;

		private readonly Timer _revisionTimer;
		private readonly Timer _connectionTimer;

		public PlazaTrader Trader;

		private readonly SecuritiesWindow _securitiesWindow = new SecuritiesWindow();
		private readonly TradesWindow _tradesWindow = new TradesWindow();
		private readonly MyTradesWindow _myTradesWindow = new MyTradesWindow();
		private readonly OrdersWindow _ordersWindow = new OrdersWindow();
		private readonly PortfoliosWindow _portfoliosWindow = new PortfoliosWindow();
		private readonly PositionsWindow _positionsWindow = new PositionsWindow();
        private readonly MonitorWindow _logWindow = new MonitorWindow();

		public MainWindow()
		{
			InitializeComponent();
			MainWindow.Instance = this;
            
            Id = Guid.NewGuid();
            guiLogListener = new GuiLogListener(_logWindow);
            logManager.Sources.Add(this);
            logManager.Listeners.Add(guiLogListener);

            
            

			_revisionTimer = ThreadingHelper.Timer(() =>
			{
				if (Trader != null)
					SaveRevisions();
			})
			.Interval(TimeSpan.FromSeconds(10));


			_connectionTimer = ThreadingHelper.Timer(() =>
			{
				try
				{
					if (Trader != null)
						this.GuiAsync(() => ChangeConnectStatus(Trader.IsConnected));
				}
				catch { }
			})
			.Interval(TimeSpan.FromMilliseconds(500));
		}

		private IEnumerable<PlazaStream> RevisionStreams
		{
			get
			{
				return new[]
				{
					Trader.StreamRegistry.CommonFutureStream,
					Trader.StreamRegistry.SessionContentsFutureStream,
					Trader.StreamRegistry.CommonOptionStream,
					Trader.StreamRegistry.SessionContentsOptionStream,
					Trader.StreamRegistry.PortfoliosStream,
					Trader.StreamRegistry.PositionsStream,
					Trader.StreamRegistry.DealFutureStream,
					Trader.StreamRegistry.DealOptionStream,
					Trader.StreamRegistry.OrdersLogFutureStream,
					Trader.StreamRegistry.OrdersLogOptionStream,
					Trader.StreamRegistry.SessionFutureStream
				};
			}
		}

		private void SaveRevisions()
		{
			lock (_revFile)
				new XmlSerializer<IEnumerable<int>>().Serialize(RevisionStreams.Select(s => s.Revision), _revFile);
		}

		private void LoadRevisions()
		{
			if (File.Exists(_revFile))
			{
				try
				{
					int[] revs;

					lock (_revFile)
						revs = new XmlSerializer<IEnumerable<int>>().Deserialize(_revFile).ToArray();

					var index = 0;

					foreach (var stream in RevisionStreams)
					{
						System.Diagnostics.Trace.WriteLine("{0} LoadRevisions {1}".Put(stream.Table.Name, revs[index]));
						stream.Revision = revs[index++];
					}
				}
				catch (Exception ex)
				{
					MessageBox.Show(this, ex.Message, "Ошибка в файле " + _revFile, MessageBoxButton.OK, MessageBoxImage.Error);
					File.Delete(_revFile);
				}
			}
		}

		protected override void OnClosing(CancelEventArgs e)
		{
			_revisionTimer.Dispose();

			_ordersWindow.DeleteHideable();
			_myTradesWindow.DeleteHideable();
			_tradesWindow.DeleteHideable();
			_securitiesWindow.DeleteHideable();
			_portfoliosWindow.DeleteHideable();
			_positionsWindow.DeleteHideable();
            _logWindow.DeleteHideable();
			
			_securitiesWindow.Close();
			_tradesWindow.Close();
			_myTradesWindow.Close();
			_ordersWindow.Close();
			_portfoliosWindow.Close();
			_positionsWindow.Close();
            _logWindow.Close();

			if (this.Trader != null)
				this.Trader.Dispose();

			base.OnClosing(e);
		}

		public static MainWindow Instance { get; private set; }

		private void Connect_Click(object sender, RoutedEventArgs e)
		{
			try
			{
				if (!_isConnected)
				{
					if (this.Trader == null)
					{
						// создаем шлюз
                        this.Trader = new PlazaTrader(this.Address.Text.To<IPEndPoint>());
						LoadRevisions();

						if (this.IsAutorization.IsChecked == true)
						{
							this.Trader.Login = this.Login.Text;
							this.Trader.Password = this.Password.Password;
						}

						// инициализируем механизм переподключения (будет автоматически соединяться
						// каждые 10 секунд, если шлюз потеряется связь с сервером)
						this.Trader.ReConnectionSettings.Interval = TimeSpan.FromSeconds(10);
						//this.Trader.ReConnectionSettings.WorkingTime = Exchange.Rts.WorkingTime;
						this.Trader.ReConnectionSettings.ConnectionRestored += () => this.GuiAsync(() =>
						{
							// разблокируем кнопку Экспорт (соединение было восстановлено)
							//ChangeConnectStatus(true);
							MessageBox.Show(this, "Соединение восстановлено.");
						});

						// подписываемся на событие успешного соединения
						this.Trader.Connected += () =>
						{
							// разблокируем кнопку Экспорт
							//this.GuiAsync(() => ChangeConnectStatus(true));

							this.Trader.StartExport();
						};

						// подписываемся на событие разрыва соединения
						this.Trader.ConnectionError += error => this.GuiAsync(() =>
						{
							// заблокируем кнопку Экспорт (так как соединение было потеряно)
							//ChangeConnectStatus(false);

							MessageBox.Show(this, error.ToString(), "Ошибка соединения");
						});

						// подписываемся на событие успешного отключения
						this.Trader.Disconnected += () => this.GuiAsync(() =>
						{
							// заблокируем кнопку Экспорт (так как соединение было потеряно)
							// ChangeConnectStatus(false);                            
						});
                        this.Trader.Disconnected += new Action(Trader_Disconnected);

						this.Trader.ProcessDataError += error => this.GuiAsync(() => MessageBox.Show(this, error.ToString(), "Ошибка обработки данных"));

						this.Trader.NewSecurities += securities => this.GuiAsync(() => _securitiesWindow.AddSecurities(securities));
						this.Trader.NewMyTrades += trades => this.GuiAsync(() => _myTradesWindow.Trades.AddRange(trades));
						this.Trader.NewTrades += trades => this.GuiAsync(() => _tradesWindow.Trades.AddRange(trades));
						this.Trader.NewOrders += orders => this.GuiAsync(() => _ordersWindow.Orders.AddRange(orders));
						this.Trader.NewPortfolios += portfolios => _portfoliosWindow.Portfolios.AddRange(portfolios);
						this.Trader.NewPositions += positions => this.GuiAsync(() => _positionsWindow.Positions.AddRange(positions));

						// подписываемся на событие о неудачной регистрации заявок
						this.Trader.OrdersFailed += OrdersFailed;

						// подписываемся на событие о неудачной регистрации стоп-заявок
						this.Trader.StopOrdersFailed += OrdersFailed;
					}

					this.Trader.Connect();
				}
				else
				{
					this.Trader.Disconnect();
				}
			}
			catch (Exception ex)
			{
				MessageBox.Show(this, ex.Message, "Ошибка");
			}
		}

        void Trader_Disconnected()
        {
            //this.GuiAsync(() => this.Log(new LogMessage(this, DateTime.Now, ErrorTypes.None, "  ")));

            this.Log(new LogMessage(this, DateTime.Now, ErrorTypes.None, "  "));    //Так не работает
        }

		private void OrdersFailed(IEnumerable<OrderFail> fails)
		{
			this.GuiAsync(() =>
			{
				foreach (var fail in fails)
					MessageBox.Show(this, fail.Error.ToString(), "Ошибка регистрации заявки");
			});
		}

		private void ChangeConnectStatus(bool isConnected)
		{
			_isConnected = isConnected;
			this.ConnectBtn.Content = isConnected ? "Отключиться" : "Подключиться";
			this.connectionStatus.Content = isConnected ? "Подключен" : "Не подключен";
            
            this.ShowSecurities.IsEnabled = this.ShowTrades.IsEnabled =
            this.ShowMyTrades.IsEnabled = this.ShowOrders.IsEnabled =
            this.ShowPortfolios.IsEnabled = this.ShowPositions.IsEnabled = isConnected;
		}

		private void ShowSecurities_Click(object sender, RoutedEventArgs e)
		{
			ShowOrHide(_securitiesWindow);
		}

		private void ShowTrades_Click(object sender, RoutedEventArgs e)
		{
			ShowOrHide(_tradesWindow);
		}

		private void ShowMyTrades_Click(object sender, RoutedEventArgs e)
		{
			ShowOrHide(_myTradesWindow);
		}

		private void ShowOrders_Click(object sender, RoutedEventArgs e)
		{
			ShowOrHide(_ordersWindow);
		}

		private void ShowPortfolios_Click(object sender, RoutedEventArgs e)
		{
			ShowOrHide(_portfoliosWindow);
		}

		private void ShowPositions_Click(object sender, RoutedEventArgs e)
		{
			ShowOrHide(_positionsWindow);
		}

		private static void ShowOrHide(Window window)
		{
			if (window == null)
				throw new ArgumentNullException("window");

			if (window.Visibility == Visibility.Visible)
				window.Hide();
			else
				window.Show();
		}


        #region ILogSource Members

        public event Action<LogMessage> Log;

        public string Name
        {
            get
            {
                return "Test";
            }
        }

        public Ecng.Collections.INotifyList<ILogSource> Childs
        {
            //get { throw new NotImplementedException(); }
            get { return null; }
        }

        public Guid Id
        {
            //get { throw new NotImplementedException(); }
            get;
            set;
        }

        public ILogSource Parent
        {
            //get { throw new NotImplementedException(); }
            get { return null; }
        }

        #endregion
	}
}