/// <summary>
    /// Пример тактики, использующей специфичные для конкретной биржи функциональные
    /// возможности.
    /// </summary>
    public class SimpleTradingTactic : TradingTacticBase<SimpleTradingTacticContext>,
        ISimpleTradingTactic
    {
        private readonly IAdviserProvider _adviserProvider;
        private readonly IIndicatorProvider _indicatorProvider;
        private IOpenedOrderCrudAppService _openedOrderCrudService;
        private IOrderCrudAppService _orderCrudService;
        private IExchangeProvider _exchangeProvider;
        private readonly ITimer _timer;
        private readonly IPairCrudAppService _pairCrudAppService;
        private IIndicatorRemoteEventHandler _indicatorRemoteEventHandler;
        public override float LogicRiskDegree { get; set; } = 12;

        public SimpleTradingTactic(
            IOpenedOrderCrudAppService openedOrderCrudService,
            [NotNull] IAdviserProvider adviserProvider,
            [NotNull] IExchangeProvider exchangeProvider,
            [NotNull] IRemoteEventBus remoteEventBus,
            [NotNull] IIndicatorProvider indicatorProvider,
            [NotNull] IIndicatorRemoteEventHandler indicatorRemoteEventHandler,
            [NotNull] ITimer timer,
            [NotNull] IOrderCrudAppService orderCrudService,
            [NotNull] ITradingStrategyContextProvider tradingStrategyContextProvider,
            [NotNull] IRiskManagerClient riskManagerClient,
            [NotNull] IPairCrudAppService pairCrudAppService,
            IAccountManagerClient accountManagerClient) :
            base(tradingStrategyContextProvider, timer, openedOrderCrudService, orderCrudService, remoteEventBus,
                pairCrudAppService, riskManagerClient, accountManagerClient)
        {
            if (riskManagerClient == null) throw new ArgumentNullException(nameof(riskManagerClient));
            _adviserProvider = adviserProvider ?? throw new ArgumentNullException(nameof(adviserProvider));
            this._exchangeProvider = exchangeProvider ?? throw new ArgumentNullException(nameof(exchangeProvider));
            this._indicatorProvider = indicatorProvider ?? throw new ArgumentNullException(nameof(indicatorProvider));
            _indicatorRemoteEventHandler = indicatorRemoteEventHandler;
            _timer = timer ?? throw new ArgumentNullException(nameof(timer));
            _orderCrudService = orderCrudService ?? throw new ArgumentNullException(nameof(orderCrudService));
            _pairCrudAppService = pairCrudAppService ?? throw new ArgumentNullException(nameof(pairCrudAppService));
            _openedOrderCrudService = openedOrderCrudService ?? throw new ArgumentNullException(nameof(openedOrderCrudService));

            indicatorRemoteEventHandler.IndicatorHandler += HandleEvent;
        }
        public override string Name => "Тактика торговли с простейшим алгоритмом";

        public override Action Execute => Trading;

        /// <summary>
        /// Корректирует экстримальные значения в контексте тактики в процессе работы бота
        /// </summary>
        /// <param name="upperLevel"></param>
        /// <param name="lowerLevel"></param>
        public void CorrectExtpemeValues(decimal upperLevel, decimal lowerLevel)
        { }

        private async void  Trading()
        {
            //Для тестирования
            var timeFrames = new TimeSpan[] { TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(15), TimeSpan.FromMinutes(30) };
            var rnd = new Random(0);

            //Подписаться на индикаторы, публикующие сигналы в Кафку
            await _remoteEventBus.SubscribeAsync(KafkaTopics.GetEventBusTopicForTradingTactic());

            //Для теста
            await _remoteEventBus.SubscribeAsync(KafkaTopics.GetEventBusTopicForHeartBeat());

            while (true)
            {


                var exchange = _exchangeProvider.Get(Context.ExchangeId);

                // var opendOrderList = await exchange.ExchangeDriver.OpenOrdersAsync();


                var processingSignalResult = SignalsProsessing(Context.Signals.Count);

                var parametrs = new Dictionary<string, object>();
                //TODO Этот параметр определять на основе приятой стратегии
                parametrs.Add("TradingType", TradingTypes.ShortTime);

                var advisers = _adviserProvider.GetAdvisers(parametrs);

                if (false) //advisers.Any()
                {

                    IList<TradeExpertAdvice> advices = new List<TradeExpertAdvice>();

                    //Опрашивется каждый советник и от него получаем совет
                    foreach (var adviser in advisers)
                    {
                        var advice = await adviser.GetAdviceAsync(new AdviserContext
                        {
                            ExchangeId = Context.ExchangeId,
                            PairId = Context.PairId,
                            TimeFrame = TimeSpan.FromMinutes(1)
                        });

                        advices.Add(advice);
                    }

                    IDictionary<Advices, int> groupedAdvices = new Dictionary<Advices, int>();

                    groupedAdvices.Add(Advices.Growin, advices.Count(a => a.Advice == Advices.Growin));
                    groupedAdvices.Add(Advices.Falls, advices.Count(a => a.Advice == Advices.Falls));
                    groupedAdvices.Add(Advices.Stable, advices.Count(a => a.Advice == Advices.Stable));

                    //Выявляем наибольшее количество советов по трендам
                    var bestAdvice = groupedAdvices.OrderByDescending(p => p.Value).First();

                    if (bestAdvice.Key == Advices.Stable)
                    {
                        //TODO Обращаемся к рискменеджеру за характеристик ордера
                        //Пока ничего не делаем
                    }
                    else if (bestAdvice.Key == Advices.Falls)
                    {
                        //TODO Обращаемся к рискменеджеру за характеристик ордера
                        //Что делаем здесь?
                    }
                    else if (bestAdvice.Key == Advices.Growin)
                    {
                        //TODO Обращаемся к рискменеджеру за характеристик ордера
                        //Что делаем здесь?
                    }
                }
                //TODO прежде чем отдавать ордер на рассчет, нужно уточнить количество уже
                //выставленных оредров, которое не должно превышать лимитного значения
                //Это можно сделать и внутри метода SetOrderAsync()
                await SetOrderAsync(processingSignalResult);

                Thread.Sleep(_timer.SpeedUpInSeconds(60));

                //Ведется контроль за статусом бота и в случае необходимости
                //прекращает работу
                if (Context.CancellationTokenSource.Token.IsCancellationRequested)
                {
                    //TODO Организовать корректную остановку работы торговой тактики
                    //Context.CancellationTokenSource.Token.ThrowIfCancellationRequested();
                }
            };
        }


        /// <summary>
        /// Обрабатываются все полученные сигналы от индикаторов, на онове чего  выявлвяется тренд и таймфрейм
        /// для последующей постановки ордера
        /// </summary>
        /// <param name="signalsCount"></param>
        /// <returns></returns>
        private ProcessingSignalsResult SignalsProsessing(int signalsCount)
        {
            //TODO логика обработки сигналов

            return new ProcessingSignalsResult
            {
                TimeFrame = new TimeSpan(0, 1, 0),
                TradeType = TradeTypes.Sell,
                Price = 23,
                StopLoss = 25,
                TakeProfit = 17
            };
        }

        /// <summary>
        /// Обрабатывает сигналы поступающие от индикаторов
        /// </summary>
        /// <param name="eventArgs"></param>
        private void HandleEvent(object sendet, IRemoteEventData eventData)
        {
            //Debug.WriteLine($"Обрабатывает сигнал торговая тактика Id: {Context.Id}");

            if (eventData.Type == "not_signal")
            {
                foreach (var data in eventData.Data)
                {
                    Console.WriteLine($"{data.Key} : {data.Value}");
                }
            }
            else if (eventData.Type == "signal")
            {
                if (Context.ExchangeId.Equals((string)eventData.Data["exchange"])
                    && Context.PairId.ToString().Equals((string)eventData.Data["pair"]))
                // TODO && (int)eventArgs.EventData.Data["timeframe"] == Context.
                {
                    SignalCounterForTest.CountSignals++;

                    JObject jSignal = (JObject)eventData.Data["signal"];

                    SignalDto signal = jSignal.ToObject<SignalDto>();

                    Context.Signals.Enqueue(signal);
                }
            }
        }

        public override void ChangeCurrencyValue(Currency currency, decimal value, string purpose)
        {
            throw new NotImplementedException();
        }

        public override void Dispose()
        {
            _indicatorRemoteEventHandler.IndicatorHandler -= HandleEvent;
        }
    }