namespace SampleHistoryTesting
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Linq;
    using Ecng.Common;

    using StockSharp.Algo;
    using StockSharp.Algo.Candles;
    using StockSharp.Algo.Candles.Compression;
    using StockSharp.Algo.Indicators;
    using StockSharp.Algo.Indicators.Trend;
    using StockSharp.Algo.Strategies;
    //using StockSharp.Logging;
    using StockSharp.Algo.Logging;
    using StockSharp.BusinessEntities;

    class SmaStrategy : Strategy
    {
        private readonly CandleSeries _series;
        private readonly CandleSeries _series1;
        private bool cantrade;
        private Order _order;
        static readonly object Locker = new object();
        private bool realtime;
        private readonly List<Candle> _candles15;
        private readonly List<Candle> _candles30;

        public SmaStrategy(CandleSeries series, CandleSeries series1, SimpleMovingAverage longSma, SimpleMovingAverage shortSma)//
        {
            _series = series;
            _series1 = series1;

            LongSma = longSma;
            ShortSma = shortSma;
            cantrade = true;
            realtime = false;
            _candles15 = new List<Candle>();
            _candles30 = new List<Candle>();
        }

        public SimpleMovingAverage LongSma { get; private set; }
        public SimpleMovingAverage ShortSma { get; private set; }

        protected override void OnStarted()
        {
            _series
                .WhenCandlesFinished()
                .Do(ProcessCandle)
                .Apply(this);

            _series
                .WhenCandlesChanged()
                .Do(ProcessNewTick)
                .Apply(this);

            _series1
                .WhenCandlesFinished()
                .Do(ProcessCandle30)
                .Apply(this);
            // запоминаем текущее положение относительно друг друга
            //_isShortLessThenLong = ShortSma.GetCurrentValue() < LongSma.GetCurrentValue();

            base.OnStarted();
        }

        private void ProcessCandle(Candle candle)
        {
            // если наша стратегия в процессе остановки
            if (ProcessState == ProcessStates.Stopping)
            {
                // отменяем активные заявки
                CancelActiveOrders();
                return;
            }
            //this.AddInfoLog("Новая свеча {0}: {1};{2};{3};{4}; объем {5}".Put(candle.OpenTime, candle.OpenPrice, candle.HighPrice, candle.LowPrice, candle.ClosePrice, candle.TotalVolume));

            //----------------------------------------------------------+
            //                               Рассчитаем индикаторы      |
            //----------------------------------------------------------+

            // добавляем новую свечку
            LongSma.Process((DecimalIndicatorValue)candle.ClosePrice);
            ShortSma.Process((DecimalIndicatorValue)candle.ClosePrice);
            _candles15.Add(candle);
        }
        private void ProcessCandle30(Candle candle)
        {
            _candles30.Add(candle);

        }

        //----------------------------------------------------------+
        //                               Обработаем новые тики      |
        //----------------------------------------------------------+
        private void ProcessNewTick(Candle candle)
        {
            bool _long = false;
            bool _short = false;
            OrderDirections _dir;
            decimal _volume = 0;
            // если наша стратегия в процессе остановки
            if (ProcessState == ProcessStates.Stopping)
            {
                // отменяем активные заявки
                CancelActiveOrders();
                return;
            }
            //if (candle.CloseTime != candle.Security.LastTrade.Time) realtime = false;
            //else 
                realtime = true;
            if (!cantrade) return;

            //----------------------------------------------------------+
            //                                    Проверим сигналы      |
            //----------------------------------------------------------+
            var pos = PositionManager.Position;
            if (ShortSma.LastValue > LongSma.LastValue && pos < 1.0m)
            {
                _long = true;
            }
            else if (ShortSma.LastValue < LongSma.LastValue && pos > -1.0m)
            {
                _short = true;
            }
            if ((_long || _short) && realtime) //открываем позицию
            {
                if (_long) _dir = OrderDirections.Buy;
                else _dir = OrderDirections.Sell;
                if (pos != 0) _volume = 2;
                else _volume = 1;

                lock (Locker)
                {
                    var _strategy = new MarketQuotingStrategy(_dir, _volume);
                    //_strategy.WaitAllTrades = true;
                    _strategy
                        .WhenStarted()
                        .Do(() => cantrade = false)
                        .Once().Apply(this).Name = "WhenStarted";
                    _strategy
                        .WhenStopped()
                        .Do((rule, s) =>
                        {
                            cantrade = true;
                            ChildStrategies.Remove(s);
                            Rules.RemoveRulesByToken(rule.Token, rule);
                        })
                        .Once().Apply(this).Name = "WhenStopped";

                    ChildStrategies.Add(_strategy);
                }
            }

        }

    }

    #region Переопределяем свечи

    public class myTimeFrameCandleBuilder : TimeFrameCandleBuilder
    {
        protected override TimeFrameCandle CreateCandle(CandleSeries series, ICandleBuilderSourceValue value)
        {
            var candle = base.CreateCandle(series, value);
            candle.CloseTime = value.Time;
            return candle;
        }
        protected override bool IsCandleFinishedBeforeChange(CandleSeries series, TimeFrameCandle candle, ICandleBuilderSourceValue value)
        {
            //return (base.Container.GetValues(series, candle).Count<ICandleBuilderSourceValue>() >= candle.TradeCount);
            return (value.Time >= candle.OpenTime.Add((TimeSpan)candle.Arg));
        }

        protected override void UpdateCandle(CandleSeries series, TimeFrameCandle candle, ICandleBuilderSourceValue value)
        {
            base.UpdateCandle(series, candle, value);
            candle.CloseTime = value.Time;
        }
    }
    #endregion

}