using System;
using MoreLinq;
using System.Collections.Generic;
using System.Diagnostics;
using System.Windows;
using System.Windows.Media;
using Ecng.Xaml;
using StockSharp.Algo.Strategies;
using StockSharp.Algo.Candles;
using StockSharp.Algo.Indicators;
using StockSharp.Quik;
using StockSharp.TraderConnection;
using StockSharp.Messages;
using StockSharp.Algo;
using StockSharp.Xaml.Charting;
using StockSharp.Logging;
using StockSharp.Xaml;
using Ecng.Serialization;


namespace CandlesChartProject
{

    // Изменения в коде относительно видеоурока
    // ------------------------------------------------------------------------------------------
    // Теперь отрисовка элементов графика выполняется
    // при помощи метода Chart.Draw. Методы Chart.ProcessValues и Chart.ProcessCandles - устарели.   
    // Метод TimeFrame.GetCandleBounds(Security) больше не используется, нужно использовать одну из новых перегрузок
    // TimeFrame.GetCandleBounds(DateTime), TimeFrame.GetCandleBounds(DateTime, ExchangeBoard), TimeFrame.GetCandleBounds(DateTime, WorkingTime)

    public partial class MainWindow : Window
    {
        private CandleManager _candleManager;
        private CandleSeries _candleSeries;

        private ChartArea _chartArea1;
        private ChartArea _chartArea2;

        private ChartCandleElement _chartCandleElement;
        private ChartIndicatorElement _chartIndicatorSmaElement;
        private ChartIndicatorElement _chartIndicatorMyElement;
        private ChartTradeElement _chartTradeElement;
        private ChartOrderElement _chartOrderElement;

        private SimpleMovingAverage _indicatorSma;
        private MyIndicator _indicatorMy;

        private SmaStrategy _smaStrategy;

        private ChartDrawData _data;

        public MainWindow()
        {
            InitializeComponent();

            ConnectionInterFace.SafeConnection = new SafeConnection(new QuikTrader(QuikTerminal.GetDefaultPath()));

            _logmanager.Listeners.Add(new GuiLogListener(_monitor));
            _logmanager.Listeners.Add(new FileLogListener("log.txt"));
            _logmanager.Sources.Add(ConnectionInterFace.SafeConnection.Trader);
            _monitor.Show();
        }

        MonitorWindow _monitor = new MonitorWindow();
        LogManager _logmanager = new LogManager();


        private void GetCandlesClick(object sender, RoutedEventArgs e)
        {
            _chartCandleElement = new ChartCandleElement();
            _chartArea1.Elements.Add(_chartCandleElement);

            _chartTradeElement = new ChartTradeElement();
            _chartArea1.Elements.Add(_chartTradeElement);

            _chartOrderElement = new ChartOrderElement();
            _chartArea1.Elements.Add(_chartOrderElement);

            InitIndicators();

            RunProcessGetCandles();

            InitStrategy();
        }

        private void RunProcessGetCandles()
        {
            _candleManager = new CandleManager(ConnectionInterFace.SafeConnection.Trader);

            var security = ConnectionInterFace.SelectedSecurity;

            var timeFrame = TimeSpan.FromMinutes(1);

            _candleSeries = new CandleSeries(typeof(TimeFrameCandle), security, timeFrame);

            _candleManager.Processing += Draw;

            _logmanager.Sources.Add(_candleManager);

            _candleManager.Start(_candleSeries);
        }

        private void Draw(CandleSeries series, Candle candle)
        {
            
            //--------------
            var timeFrame = (TimeSpan) candle.Arg;
			var candleBounds = timeFrame.GetCandleBounds(DateTimeOffset.Now);
            //--------------

            var valueSma = _indicatorSma.Process(candle);
            //var chartValueSma = new ChartIndicatorValue(_indicatorSma, valueSma);

            var valueMy = _indicatorMy.Process(candle);
            //var chartValueMy = new ChartIndicatorValue(_indicatorMy, valueMy);

            //lastCandleTime = candle.CloseTime;

 

            if (candle.State == CandleStates.Finished )   //|| candle.OpenTime >= candleBounds.Min
            {
                Debug.Print("Candle: {0}", candle);
                //var data = new 
                var dataItem = _data.Group(candle.OpenTime);
                dataItem.Add(_chartCandleElement, candle);
                dataItem.Add(_chartIndicatorSmaElement, valueSma);
                dataItem.Add(_chartIndicatorMyElement, valueMy);

                this.GuiAsync(() => Chart.Draw(_data));

                //this.GuiAsync(() => Chart.Draw(candle.OpenTime, new Dictionary<IChartElement, object>
                //    {
                //        {_chartCandleElement, candle},
                //        {_chartIndicatorSmaElement, valueSma},
                //        {_chartIndicatorMyElement, valueMy}
                //    }));



            }
        }
        
        private void InitChart()
        {
            _data = new ChartDrawData();

            Chart.IsAutoScroll = true;

            _chartArea1 = new ChartArea();
            Chart.Areas.Add(_chartArea1);

            _chartArea2 = new ChartArea();
            Chart.Areas.Add(_chartArea2);
        }

        private void WindowLoaded(object sender, RoutedEventArgs e)
        {
            InitChart();
        }

        private void InitIndicators()
        {
            _indicatorSma = new SimpleMovingAverage
                {
                    Length = 10
                };

            _chartIndicatorSmaElement = new ChartIndicatorElement
                {
                    Title = "SMA",
                    Color = Colors.BlueViolet,
                    //Indicator = _indicatorSma
                };

            _chartArea1.Elements.Add(_chartIndicatorSmaElement);


            _indicatorMy = new MyIndicator();

            _chartIndicatorMyElement = new ChartIndicatorElement
                {
                    Title = "My Indicator",
                    Color = Colors.Blue,
                    //Indicator = _indicatorMy
                };

            _chartArea2.Elements.Add(_chartIndicatorMyElement);
        }

        private void InitStrategy()
        {
            _smaStrategy = new SmaStrategy(_indicatorSma, _candleSeries)
                {
                    Connector = ConnectionInterFace.SafeConnection.Trader,
                    Security = ConnectionInterFace.SelectedSecurity,
                    Portfolio = ConnectionInterFace.SelectedPortfolio,
                    Volume = 1
                };

            _smaStrategy.SetCandleManager(_candleManager);

            var timeFrame = TimeSpan.FromMinutes(1);

            _smaStrategy.WhenNewMyTrade()                       //WhenNewMyTrades()
                        .Do(mytrade => this.GuiAsync(() =>
                        {
                            var dataItem = _data.Group(timeFrame.GetCandleBounds(mytrade.Trade.Time.DateTime).Min);
                            dataItem.Add(_chartTradeElement, mytrade);
                            //mytrades.ForEach(t => 
                            //{
                            //    var dataItem = _data.Group(timeFrame.GetCandleBounds(t.Trade.Time.DateTime).Min);
                            //    dataItem.Add(_chartTradeElement, t);
                            //});
                            Chart.Draw(_data);
                        }
                        )).Apply();

            _smaStrategy.WhenOrderRegistered()
                        .Do(order => this.GuiAsync(() =>
                            {
                                var dataItem = _data.Group(order.Time);
                                dataItem.Add(_chartOrderElement, order);
                                Chart.Draw(_data);
                            }))
                        .Apply();

            _logmanager.Sources.Add(_smaStrategy);

            _smaStrategy.Start();
        }
    }
}