public MainWindowViewModel(
            Func <string> getTradeCommentsFunc,
            Action <string> showMessageAction,
            Action <Cursor> setCursorAction,
            Func <IDisposable> suspendChartUpdatesAction,
            Action updateWindowAction)
        {
            DependencyContainer.ComposeParts(this);

            _directory = _dataDirectoryService.MainDirectoryWithApplicationName;
            if (!Directory.Exists(_directory))
            {
                Directory.CreateDirectory(_directory);
            }

            _candlesService = new CandlesService();

            /* // Create candles
             * Task.Run(() =>
             * {
             *  Log.Info("Creating candles");
             *  _candlesService.ConvertCandles(_brokerCandlesService, _fxcm, _marketsService.GetAllMarketDetails().Select(m => m.Name).ToList());
             *  Log.Info("Candles created");
             * });
             * return;*/

            TimeFrameItems = new List <Timeframe> {
                Timeframe.D1, Timeframe.H4, Timeframe.H2, Timeframe.H1, Timeframe.M1
            };

            LargeChartTimeframeOptions.Clear();
            LargeChartTimeframeOptions.Add(Timeframe.H4);
            LargeChartTimeframeOptions.Add(Timeframe.H2);

            // Setup available indicators
            AddAvailableIndicator(new ExponentialMovingAverage(8), Colors.DarkBlue, false, true);
            AddAvailableIndicator(new ExponentialMovingAverage(20), Colors.Blue, false, false);
            AddAvailableIndicator(new ExponentialMovingAverage(25), Colors.Blue, false, true);
            AddAvailableIndicator(new ExponentialMovingAverage(50), Colors.LightBlue, false, true);
            AddAvailableIndicator(new SimpleMovingAverage(50), Colors.Green, false, false);
            AddAvailableIndicator(new SimpleMovingAverage(200), Colors.LightGreen, false, false);
            AddAvailableIndicator(new AverageTrueRange(), Colors.Red, true, false);
            AddAvailableIndicator(new CommodityChannelIndex(), Colors.Red, true, false);
            AddAvailableIndicator(new T3CommodityChannelIndex(), Colors.Red, true, false);

            NewChartCommand        = new DelegateCommand(o => NewChartMarket(), o => !Running);
            NextCandleCommand      = new DelegateCommand(o => ProgressTime());
            ClearTradesCommand     = new DelegateCommand(o => ClearTrades());
            CloseTradeCommand      = new DelegateCommand(o => CloseTrade());
            DeleteTradeCommand     = new DelegateCommand(o => DeleteTrade());
            StartLongTradeCommand  = new DelegateCommand(o => StartTrade(TradeDirection.Long));
            StartShortTradeCommand = new DelegateCommand(o => StartTrade(TradeDirection.Short));

            _getTradeCommentsFunc      = getTradeCommentsFunc;
            _showMessageAction         = showMessageAction;
            _setCursorAction           = setCursorAction;
            _suspendChartUpdatesAction = suspendChartUpdatesAction;
            _updateWindowAction        = updateWindowAction;
            DependencyContainer.ComposeParts(this);
            _dispatcher = Dispatcher.CurrentDispatcher;

            _chartModeDisposable = ChartingService.ChartModeObservable.Subscribe(ChartModeChanged);

            TradeListDisplayOptions = TradeListDisplayOptionsFlag.ClosePrice
                                      | TradeListDisplayOptionsFlag.Comments
                                      | TradeListDisplayOptionsFlag.OrderPrice
                                      | TradeListDisplayOptionsFlag.Limit
                                      | TradeListDisplayOptionsFlag.OrderDate
                                      | TradeListDisplayOptionsFlag.ResultR
                                      | TradeListDisplayOptionsFlag.Status
                                      | TradeListDisplayOptionsFlag.Stop
                                      | TradeListDisplayOptionsFlag.Strategies;

            _markets = new List <string>();
            foreach (var m in _marketsService.GetAllMarketDetails().Select(m => m.Name))
            {
                if (File.Exists(_candlesService.GetCandlesPath(m, Timeframe.M5)) &&
                    File.Exists(_candlesService.GetCandlesPath(m, Timeframe.H2)) &&
                    File.Exists(_candlesService.GetCandlesPath(m, Timeframe.H4)) &&
                    File.Exists(_candlesService.GetCandlesPath(m, Timeframe.D1)))
                {
                    _markets.Add(m);
                }
            }

            IsTradeEnabled = false;

            var path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "TraderSimulator");

            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }

            _orderExpiryCandlesIndex = 0;

            ResultsViewModel = new TradesResultsViewModel(() => Trades.ToList())
            {
                ShowOptions = true, ShowSubOptions = false, AdvStrategyNaming = true
            };
            ResultsViewModel.ResultOptions.Remove("Timeframe");
            ResultsViewModel.ShowOptions = false;
            ResultsViewModel.ShowIncludeOpenClosedTradesOptions = false;

            LoadTrades();
            RemoveIncompleteTrades();
            NewChartMarket();

            _chartClickedDisposable = ChartingService.ChartClickObservable.Subscribe(ChartClicked);
        }
        public StrategyRunResultsViewModel()
        {
            _dispatcher    = Dispatcher.CurrentDispatcher;
            ChartViewModel = new ChartViewModel();
            ((INotifyPropertyChanged)ChartViewModel).PropertyChanged += ChartViewModelPropertyChanged;
            TradesViewModel = new TradeListViewModel();
            ChartViewModel.ChartTimeframe = Timeframe.H4;

            DependencyContainer.ComposeParts(this);

            _uiService.ViewTradeObservable.Subscribe(o =>
            {
                if (TradesViewModel.SelectedTrade == null)
                {
                    return;
                }

                if (TradesViewModel.SelectedTrade.Timeframe != null)
                {
                    ChartViewModel.ChartTimeframe = TradesViewModel.SelectedTrade.Timeframe.Value;
                }

                ChartViewModel.ShowTrade(TradesViewModel.SelectedTrade,
                                         ChartViewModel.ChartTimeframeOptions[ChartViewModel.SelectedChartTimeframeIndex], false,
                                         s => { },
                                         new List <(IIndicator Indicator, Color Color, bool ShowInLegend)>()
                {
                    (new ExponentialMovingAverage(8), Colors.DarkBlue, true),
                    (new ExponentialMovingAverage(25), Colors.Blue, true),
                    (new ExponentialMovingAverage(50), Colors.Blue, true),
                    (new BollingerBand(1.5F, 20), Colors.Green, true),
                    (new BollingerBand(-1.5F, 20), Colors.Green, false)
                },
                                         _uiService.UseHeikenAshi);
            });

            ResultsViewModel = new TradesResultsViewModel(() =>
            {
                lock (_results.Results)
                {
                    return(_results.Results.ToList());
                }
            });

            _testResultsStartedObserver = _results.TestRunStarted.Subscribe(newResults =>
            {
                UpdateTrades();
                ResultsViewModel.UpdateResults();
            });

            _testResultsUpdatedObserver = _results.TestRunCompleted.Subscribe(newResults =>
            {
                UpdateTrades();
                ResultsViewModel.UpdateResults();
            });

            Task.Run(() =>
            {
                Log.Info("Updating strategy run results");
                UpdateTrades();
                ResultsViewModel.UpdateResults();
                Log.Info("Updated strategy run results");
            });

            TradesViewModel.ShowClosedTrades = true;
            TradesViewModel.ShowOpenTrades   = true;
            TradesViewModel.ShowOrders       = true;
        }