namespace QuantConnect
{
	using System.Collections.Generic;

    internal class TradingStrategiesBasedOnGeneticAlgorithmsQCVersion : QCAlgorithm
    {
        private readonly int _indicatorSignalCount = 5;
        
        private System.Collections.Generic.Dictionary<String, TradingRuleQCVersion> _entryradingRules=new Dictionary<String, TradingRuleQCVersion>();
        private Dictionary<String, TradingRuleQCVersion> _exitradingRules=new Dictionary<String, TradingRuleQCVersion>();
        
        private List<Symbol> _pair=new List<Symbol>();

        private readonly Dictionary<string, string> parametersToBacktest = new Dictionary<string, string>
        {
        	
            {"EntryIndicator1", "0"},
            {"EntryIndicator2", "3"},
            {"EntryIndicator3", "3"},
            {"EntryIndicator4", "7"},
            {"EntryIndicator5", "5"},
            {"EntryIndicator1Direction", "0"},
            {"EntryIndicator2Direction", "0"},
            {"EntryIndicator3Direction", "1"},
            {"EntryIndicator4Direction", "1"},
            {"EntryIndicator5Direction", "0"},
            {"ExitIndicator1", "4"},
            {"ExitIndicator2", "3"},
            {"ExitIndicator3", "1"},
            {"ExitIndicator4", "0"},
            {"ExitIndicator5", "7"},
            {"ExitIndicator1Direction", "1"},
            {"ExitIndicator2Direction", "0"},
            {"ExitIndicator3Direction", "0"},
            {"ExitIndicator4Direction", "0"},
            {"ExitIndicator5Direction", "0"}
        };

        public override void Initialize()
        {
            
            SetBrokerageModel(BrokerageName.OandaBrokerage);
            
            SetCash(startingCash: 1000);
            var startDate = new DateTime(year: 2017, month: 9, day: 1);
            SetStartDate(startDate);
            SetEndDate(startDate.AddMonths(months: 3));
            _pair.Add(AddForex("EURAUD", leverage: 50).Symbol);
 			_pair.Add(AddForex("EURCAD", leverage: 50).Symbol);
 			_pair.Add(AddForex("EURCHF", leverage: 50).Symbol);
 			_pair.Add(AddForex("EURGBP", leverage: 50).Symbol);
 			_pair.Add(AddForex("EURJPY", leverage: 50).Symbol);
 			_pair.Add(AddForex("EURNZD", leverage: 50).Symbol);
 			_pair.Add(AddForex("EURUSD", leverage: 50).Symbol);
 			_pair.Add(AddForex("GBPAUD", leverage: 50).Symbol);
 			_pair.Add(AddForex("GBPCAD", leverage: 50).Symbol);
 			_pair.Add(AddForex("GBPCHF", leverage: 50).Symbol);
 			_pair.Add(AddForex("GBPJPY", leverage: 50).Symbol);
 			_pair.Add(AddForex("GBPNZD", leverage: 50).Symbol);
 			_pair.Add(AddForex("GBPUSD", leverage: 50).Symbol);
 			_pair.Add(AddForex("AUDUSD", leverage: 50).Symbol);
 			_pair.Add(AddForex("NZDUSD", leverage: 50).Symbol);
 			_pair.Add(AddForex("USDCAD", leverage: 50).Symbol);
 			_pair.Add(AddForex("USDCHF", leverage: 50).Symbol);
 			_pair.Add(AddForex("USDJPY", leverage: 50).Symbol);
            SetParameters(parametersToBacktest);
            SetUpRules();
           
        }

		private TradingRuleQCVersion GetValue(String symbol,Dictionary<String,TradingRuleQCVersion> tradingRule){

				if(tradingRule.ContainsKey(symbol))
            	{
            		return tradingRule[symbol];
            	}	
				return	null;
		}
		
        public override void OnData(Slice slice)
        {
            foreach(Symbol symbol in _pair)
            {
            	TradingRuleQCVersion tradingRule=GetValue(symbol,_entryradingRules);
            	
            	if(_entryradingRules.ContainsKey(symbol))
            	{
            		tradingRule=GetValue(symbol,_entryradingRules);
            		//if (!tradingRule.IsReady) break;
            		//if (!Portfolio.Invested)
    	       		{
        	       		if (tradingRule.TradeRuleSignal) 
        	       			SetHoldings(symbol, percentage: 1m);
            		}
            	}
            	else
            	{
            		tradingRule=GetValue(symbol,_exitradingRules);
            		if (tradingRule.TradeRuleSignal) 
            			Liquidate(symbol);
            	}
            	//if (!_entryradingRule.IsReady) return;
	           //if (!Portfolio.Invested)
    	       //{
        	    //   if (_entryradingRule.TradeRuleSignal) SetHoldings(symbol, percentage: 1m);
            	//}
            	//else
            	//{
                //	if (_exitTradingRule.TradeRuleSignal) Liquidate(symbol);
            	//}
            }
        }

        public ITechnicalIndicatorSignal SetUpIndicatorSignal(Symbol pair, int indicatorN, string ruleAction)
        {
            var oscillatorThresholds = new OscillatorThresholds {Lower = 20, Upper = 80};
            var key = ruleAction + "Indicator" + indicatorN + "Direction";
            var intDirection = GetGeneIntFromKey(key);

            var direction = intDirection == 0
                ? TradeRuleDirection.LongOnly
                : TradeRuleDirection.ShortOnly;

            key = ruleAction + "Indicator" + indicatorN;
            var indicatorId = GetGeneIntFromKey(key);
            var indicator = (TechicalIndicators) indicatorId;
            ITechnicalIndicatorSignal technicalIndicator = null;
            switch (indicator)
            {
                case TechicalIndicators.SimpleMovingAverage:
                    // Canonical cross moving average parameters.
                    var fast = SMA(pair, period: 50);
                    var slow = SMA(pair, period: 200);
                    technicalIndicator = new CrossingMovingAverages(fast, slow, direction);
                    break;

                case TechicalIndicators.MovingAverageConvergenceDivergence:
                    var macd = MACD(pair, fastPeriod: 12, slowPeriod: 26, signalPeriod: 9);
                    technicalIndicator = new CrossingMovingAverages(macd, macd.Signal, direction);
                    break;

                case TechicalIndicators.Stochastic:
                    var sto = STO(pair, period: 14);
                    technicalIndicator = new OscillatorSignal(sto.StochD, oscillatorThresholds, direction);
                    break;

                case TechicalIndicators.RelativeStrengthIndex:
                    var rsi = RSI(pair, period: 14);
                    technicalIndicator = new OscillatorSignal(rsi, oscillatorThresholds, direction);
                    break;

                case TechicalIndicators.CommodityChannelIndex:
                    var cci = CCI(pair, period: 20);
                    oscillatorThresholds.Lower = -100;
                    oscillatorThresholds.Lower = 100;
                    technicalIndicator = new OscillatorSignal(cci, oscillatorThresholds, direction);
                    break;

                case TechicalIndicators.MomentumPercent:
                    var pm = MOMP(pair, period: 60);
                    oscillatorThresholds.Lower = -5;
                    oscillatorThresholds.Lower = 5;
                    technicalIndicator = new OscillatorSignal(pm, oscillatorThresholds, direction);
                    break;

                case TechicalIndicators.WilliamsPercentR:
                    var wr = WILR(pair, period: 14);
                    technicalIndicator = new OscillatorSignal(wr, oscillatorThresholds, direction);
                    break;

                case TechicalIndicators.PercentagePriceOscillator:
                    var ppo = MACD(pair, fastPeriod: 12, slowPeriod: 26, signalPeriod: 9).Over(EMA(pair, period: 26))
                        .Plus(constant: 100m);
                    var signal = new SimpleMovingAverage(period: 9).Of(ppo);
                    technicalIndicator = new CrossingMovingAverages(ppo, signal, direction);
                    break;

                case TechicalIndicators.BollingerBands:
                    throw new NotImplementedException("WIP");
                    break;
            }

            return technicalIndicator;
        }

        
        private int GetGeneIntFromKey(string key)
        {
        	
            var intGene = int.MinValue;
            if (intGene == int.MinValue)
            {
                try
                {
                    intGene = int.Parse(GetParameter(key));
                    Log(string.Format("Parameter {0} set to {1}", key, intGene));
                }
                catch (ArgumentNullException e)
                {
                    throw new ArgumentNullException(key,
                        "The gene " + key + " is not present either as Config or as Parameter");
                }
            }
            return intGene;
        }

        private void SetUpRules()
        {
            bool[] bools = {true, false};

			TradingRuleQCVersion _entryradingRule;
        	TradingRuleQCVersion _exitTradingRule;
        
            foreach (var isEntryRule in bools)
            {
                var technicalIndicatorSignals = new List<ITechnicalIndicatorSignal>();
                var ruleAction = isEntryRule ? "Entry" : "Exit";
                foreach(Symbol symbol in _pair)
                {
                	for (var i = 1; i <= _indicatorSignalCount; i++)
                	{
                    	var indicatorSignal = SetUpIndicatorSignal(symbol, i, ruleAction);
                    	technicalIndicatorSignals.Add(indicatorSignal);
                	}

                	if (isEntryRule)
                	{
                    	_entryradingRule = new TradingRuleQCVersion(technicalIndicatorSignals.ToArray(), isEntryRule);
                    	_entryradingRules.Add(symbol,_entryradingRule);
                	}
                	else
                	{
                    	_exitTradingRule = new TradingRuleQCVersion(technicalIndicatorSignals.ToArray(), isEntryRule);
                		_exitradingRules.Add(symbol,_exitTradingRule);
                		
                	}	
                }
                
            }
        }
    }
}

namespace QuantConnect
{
    /// <summary>
    ///     Interface used by the <see cref="TradingRule" /> class to flag technical indicator signals as crossing moving
    ///     averages or oscillators crossing its thresholds.
    /// </summary>
    public interface ITechnicalIndicatorSignal
    {
        /// <summary>
        ///     Gets a value indicating whether this instance is ready.
        /// </summary>
        /// <value>
        ///     <c>true</c> if this instance is ready; otherwise, <c>false</c>.
        /// </value>
        bool IsReady { get; }

        /// <summary>
        ///     Gets the signal. Only used if the instance will be part of a <see cref="TradingRule" /> class.
        /// </summary>
        /// <returns>
        ///     <c>true</c> if the actual <see cref="Signal" /> correspond with the instance <see cref="TradeRuleDirection" />.
        ///     <c>false</c>
        ///     otherwise.
        /// </returns>
        bool GetSignal();
    }

    /// <summary>
    ///     The <see cref="TradingStrategiesBasedOnGeneticAlgorithms" /> implementation requires a direction for every
    ///     technical indicator.
    /// </summary>
    public enum TradeRuleDirection
    {
        LongOnly = 1,
        ShortOnly = -1
    }

    /// <summary>
    ///     List of the technical indicator implemented... well not really, Bollinger bands wasn't implemented.
    /// </summary>
    public enum TechicalIndicators
    {
        SimpleMovingAverage = 0,
        MovingAverageConvergenceDivergence = 1,
        Stochastic = 2,
        RelativeStrengthIndex = 3,
        CommodityChannelIndex = 4,
        MomentumPercent = 5,
        WilliamsPercentR = 6,
        PercentagePriceOscillator = 7,
        BollingerBands = 8
    }
}

namespace QuantConnect
{
    /// <summary>
    ///     Possibles states of two moving averages.
    /// </summary>
    public enum CrossingMovingAveragesSignals
    {
        Bullish = 1,
        FastCrossSlowFromAbove = -2,
        Bearish = -1,
        FastCrossSlowFromBelow = 2
    }

    /// <summary>
    ///     This class keeps track of two crossing moving averages and updates a <see cref="CrossingMovingAveragesSignals" />
    ///     for each given state.
    /// </summary>
    /// <seealso cref="QuantConnect.Algorithm.CSharp.ITechnicalIndicatorSignal" />
    public class CrossingMovingAverages : ITechnicalIndicatorSignal
    {
        private readonly CompositeIndicator<IndicatorDataPoint> _moving_average_difference;
        private readonly TradeRuleDirection _tradeRuleDirection;
        private int _lastSignal;

        /// <summary>
        ///     Initializes a new instance of the <see cref="CrossingMovingAverages" /> class.
        /// </summary>
        /// <param name="fast_moving_average">The fast moving average.</param>
        /// <param name="slow_moving_average">The slow moving average.</param>
        /// <param name="tradeRuleDirection">
        ///     The trade rule direction. Only used if the instance will be part of a
        ///     <see cref="TradingRule" /> class
        /// </param>
        /// <remarks>
        ///     Both Moving Averages must be registered BEFORE being used by this constructor.
        /// </remarks>
        public CrossingMovingAverages(IndicatorBase<IndicatorDataPoint> fast_moving_average,
            IndicatorBase<IndicatorDataPoint> slow_moving_average, TradeRuleDirection? tradeRuleDirection = null)
        {
            _moving_average_difference = fast_moving_average.Minus(slow_moving_average);
            _moving_average_difference.Updated += ma_Updated;
            if (tradeRuleDirection != null) _tradeRuleDirection = (TradeRuleDirection)tradeRuleDirection;
        }

        /// <summary>
        ///     Gets a value indicating whether this instance is ready.
        /// </summary>
        /// <value>
        ///     <c>true</c> if this instance is ready; otherwise, <c>false</c>.
        /// </value>
        public bool IsReady
        {
            get { return _moving_average_difference.IsReady; }
        }

        /// <summary>
        ///     Gets the actual state of both moving averages.
        /// </summary>
        public CrossingMovingAveragesSignals Signal { get; private set; }

        /// <summary>
        ///     Gets the signal. Only used if the instance will be part of a <see cref="TradingRule" /> class.
        /// </summary>
        /// <returns>
        ///     <c>true</c> if the actual <see cref="Signal" /> correspond with the instance <see cref="TradeRuleDirection" />.
        ///     <c>false</c>
        ///     otherwise.
        /// </returns>
        public bool GetSignal()
        {
            var signal = false;
            if (IsReady)
            {
                switch (_tradeRuleDirection)
                {
                    case TradeRuleDirection.LongOnly:
                        signal = Signal == CrossingMovingAveragesSignals.FastCrossSlowFromBelow;
                        break;

                    case TradeRuleDirection.ShortOnly:
                        signal = Signal == CrossingMovingAveragesSignals.FastCrossSlowFromAbove;
                        break;
                }
            }
            return signal;
        }

        private void ma_Updated(object sender, IndicatorDataPoint updated)
        {
            if (!IsReady)
            {
                return;
            }
            var actualSignal = Math.Sign(_moving_average_difference);
            if (actualSignal == _lastSignal || _lastSignal == 0)
            {
                Signal = (CrossingMovingAveragesSignals)actualSignal;
            }
            else if (_lastSignal == -1 && actualSignal == 1)
            {
                Signal = CrossingMovingAveragesSignals.FastCrossSlowFromBelow;
            }
            else if (_lastSignal == 1 && actualSignal == -1)
            {
                Signal = CrossingMovingAveragesSignals.FastCrossSlowFromAbove;
            }

            _lastSignal = actualSignal;
        }
    }
}

namespace QuantConnect
{
    /// <summary>
    ///     Possibles states of an oscillator respect to its thresholds.
    /// </summary>
    public enum OscillatorSignals
    {
        CrossLowerThresholdFromAbove = -3,
        BellowLowerThreshold = -2,
        CrossLowerThresholdFromBelow = -1,
        BetweenThresholds = 0,
        CrossUpperThresholdFromBelow = 3,
        AboveUpperThreshold = 2,
        CrossUpperThresholdFromAbove = 1
    }

    public struct OscillatorThresholds
    {
        public decimal Lower;
        public decimal Upper;
    }

    /// <summary>
    ///     This class keeps track of an oscillator respect to its thresholds and updates an <see cref="OscillatorSignal" />
    ///     for each given state.
    /// </summary>
    /// <seealso cref="QuantConnect.Algorithm.CSharp.ITechnicalIndicatorSignal" />
    public class OscillatorSignal : ITechnicalIndicatorSignal
    {
        private decimal _previousIndicatorValue;
        private OscillatorSignals _previousSignal;
        private OscillatorThresholds _thresholds;
        private TradeRuleDirection _tradeRuleDirection;

        /// <summary>
        ///     Initializes a new instance of the <see cref="OscillatorSignal" /> class.
        /// </summary>
        /// <param name="indicator">The indicator.</param>
        /// <param name="thresholds">The thresholds.</param>
        /// <param name="tradeRuleDirection">
        ///     The trade rule direction. Only used if the instance will be part of a
        ///     <see cref="TradingRule" /> class
        /// </param>
        /// <remarks>The oscillator must be registered BEFORE being used by this constructor.</remarks>
        public OscillatorSignal(dynamic indicator, OscillatorThresholds thresholds,
            TradeRuleDirection tradeRuleDirection)
        {
            SetUpClass(ref indicator, ref thresholds, tradeRuleDirection);
        }

        /// <summary>
        ///     Initializes a new instance of the <see cref="OscillatorSignal" /> class.
        /// </summary>
        /// <param name="indicator">The indicator.</param>
        /// <param name="thresholds">The thresholds.</param>
        /// <remarks>The oscillator must be registered BEFORE being used by this constructor.</remarks>
        public OscillatorSignal(dynamic indicator, OscillatorThresholds thresholds)
        {
            SetUpClass(ref indicator, ref thresholds);
        }

        /// <summary>
        ///     Initializes a new instance of the <see cref="OscillatorSignal" /> class.
        /// </summary>
        /// <param name="indicator">The indicator.</param>
        /// <remarks>The oscillator must be registered BEFORE being used by this constructor.</remarks>
        public OscillatorSignal(dynamic indicator)
        {
            var defaultThresholds = new OscillatorThresholds {Lower = 20, Upper = 80};
            SetUpClass(ref indicator, ref defaultThresholds);
        }

        /// <summary>
        ///     The underlying indicator, must be an oscillator.
        /// </summary>
        public dynamic Indicator { get; private set; }

        /// <summary>
        ///     Gets the actual state of the oscillator.
        /// </summary>
        public OscillatorSignals Signal { get; private set; }

        /// <summary>
        ///     Gets a value indicating whether this instance is ready.
        /// </summary>
        /// <value>
        ///     <c>true</c> if this instance is ready; otherwise, <c>false</c>.
        /// </value>
        public bool IsReady
        {
            get { return Indicator.IsReady; }
        }

        /// <summary>
        ///     Gets the signal. Only used if the instance will be part of a <see cref="TradingRule" /> class.
        /// </summary>
        /// <returns>
        ///     <c>true</c> if the actual <see cref="Signal" /> correspond with the instance <see cref="TradeRuleDirection" />.
        ///     <c>false</c>
        ///     otherwise.
        /// </returns>
        public bool GetSignal()
        {
            var signal = false;
            if (IsReady)
            {
                switch (_tradeRuleDirection)
                {
                    case TradeRuleDirection.LongOnly:
                        signal = Signal == OscillatorSignals.CrossLowerThresholdFromBelow;
                        break;

                    case TradeRuleDirection.ShortOnly:
                        signal = Signal == OscillatorSignals.CrossUpperThresholdFromAbove;
                        break;
                }
            }
            return signal;
        }

        /// <summary>
        ///     Updates the <see cref="Signal" /> status.
        /// </summary>
        private void Indicator_Updated(object sender, IndicatorDataPoint updated)
        {
            var actualPositionSignal = GetActualPositionSignal(updated);
            if (!Indicator.IsReady)
            {
                _previousIndicatorValue = updated.Value;
                _previousSignal = actualPositionSignal;
                Signal = _previousSignal;
                return;
            }

            var actualSignal = GetActualSignal(_previousSignal, actualPositionSignal);

            Signal = actualSignal;
            _previousIndicatorValue = updated.Value;
            _previousSignal = actualSignal;
        }

        /// <summary>
        ///     Gets the actual position respect to the thresholds.
        /// </summary>
        /// <param name="indicatorCurrentValue">The indicator current value.</param>
        /// <returns></returns>
        private OscillatorSignals GetActualPositionSignal(decimal indicatorCurrentValue)
        {
            var positionSignal = OscillatorSignals.BetweenThresholds;
            if (indicatorCurrentValue > _thresholds.Upper)
            {
                positionSignal = OscillatorSignals.AboveUpperThreshold;
            }
            else if (indicatorCurrentValue < _thresholds.Lower)
            {
                positionSignal = OscillatorSignals.BellowLowerThreshold;
            }
            return positionSignal;
        }

        /// <summary>
        ///     Gets the actual signal from the actual position respect to the thresholds and the last signal.
        /// </summary>
        /// <param name="previousSignal">The previous signal.</param>
        /// <param name="actualPositionSignal">The actual position signal.</param>
        /// <returns></returns>
        private OscillatorSignals GetActualSignal(OscillatorSignals previousSignal,
            OscillatorSignals actualPositionSignal)
        {
            OscillatorSignals actualSignal;
            var previousSignalInt = (int) previousSignal;
            var actualPositionSignalInt = (int) actualPositionSignal;

            if (actualPositionSignalInt == 0)
            {
                if (Math.Abs(previousSignalInt) > 1)
                {
                    actualSignal = (OscillatorSignals) Math.Sign(previousSignalInt);
                }
                else
                {
                    actualSignal = OscillatorSignals.BetweenThresholds;
                }
            }
            else
            {
                if (previousSignalInt * actualPositionSignalInt <= 0 ||
                    Math.Abs(previousSignalInt + actualPositionSignalInt) == 3)
                {
                    actualSignal = (OscillatorSignals) (Math.Sign(actualPositionSignalInt) * 3);
                }
                else
                {
                    actualSignal = (OscillatorSignals) (Math.Sign(actualPositionSignalInt) * 2);
                }
            }
            return actualSignal;
        }

        /// <summary>
        ///     Sets up class.
        /// </summary>
        /// <param name="indicator">The indicator.</param>
        /// <param name="thresholds">The thresholds.</param>
        /// <param name="tradeRuleDirection">The trade rule direction.</param>
        private void SetUpClass(ref dynamic indicator, ref OscillatorThresholds thresholds,
            TradeRuleDirection? tradeRuleDirection = null)
        {
            _thresholds = thresholds;
            Indicator = indicator;
            indicator.Updated += new IndicatorUpdatedHandler(Indicator_Updated);
            if (tradeRuleDirection != null) _tradeRuleDirection = (TradeRuleDirection) tradeRuleDirection;
        }
    }
}

namespace QuantConnect
{
    internal class TradingRuleQCVersion
    {
        private readonly ITechnicalIndicatorSignal[] _technicalIndicatorSignals;
        private readonly bool _isEntryRule;

        public TradingRuleQCVersion(ITechnicalIndicatorSignal[] technicalIndicatorSignals, bool isEntryRule)
        {
            _technicalIndicatorSignals = technicalIndicatorSignals;
            _isEntryRule = isEntryRule;
        }

        public bool IsReady
        {
            get
            {
                var isReady = true;
                foreach (var indicator in _technicalIndicatorSignals)
                {
                    isReady = indicator.IsReady && isReady;
                }
                return isReady;
            }
        }

        public bool TradeRuleSignal
        {
            get { return GetTradeRuleSignal(); }
        }

        /// <summary>
        /// Gets the trade rule signal for the best in-sample performance individual.
        /// </summary>
        /// <returns></returns>
        private bool GetTradeRuleSignal()
        {
            var signal = false;
            if (_isEntryRule)
            {
                signal = _technicalIndicatorSignals[0].GetSignal() &&   //  Long SimpleMovingAverage
                         _technicalIndicatorSignals[1].GetSignal() ||   //  Long Stochastic
                         _technicalIndicatorSignals[2].GetSignal() &&   //  Long RelativeStrengthIndex
                         _technicalIndicatorSignals[3].GetSignal() ||   //  Short MovingAverageConvergenceDivergence
                         _technicalIndicatorSignals[4].GetSignal();     //  Short MomentumPercent
            }
            else
            {
                signal = _technicalIndicatorSignals[0].GetSignal() ||   //  Short CommodityChannelIndex
                         _technicalIndicatorSignals[1].GetSignal() &&	//  Long RelativeStrengthIndex
                         _technicalIndicatorSignals[2].GetSignal() ||	//  Short Stochastic
                         _technicalIndicatorSignals[3].GetSignal() &&	//  Long MovingAverageConvergenceDivergence
                         _technicalIndicatorSignals[4].GetSignal();		//  Long Stochastic

            }
            return signal;
        }
    }
}