/*================================================================================
 * Стратегия: VK bands 
 * Платформа: TSLab версия 1.1.8.0
 * Дата создания: 31.08.2010
 * Реализовано: Laber
 *================================================================================*/

using System; 
using System.Collections.Generic;
using TSLab.Script;
using TSLab.Script.Handlers;
using TSLab.Script.Optimization;
using TSLab.Script.Helpers;

namespace TSLab.VK_bands
{

	//================================================================================
	public class System_VK_bands : IExternalScript
	{
		// используем переменные-флаги для сигналов
		public bool bBuy; // флаг сигнала открытия длинной позиции
		public bool bSell; // флаг сигнала закрытия длинной позиции
		public bool bShort; // флаг сигнала открытия короткой позиции
		public bool bCover; // флаг сигнала закрытия короткой позиции
		public IPosition LongPos, ShortPos;
		 
		
		//================================================================================
		// функция вычисления VK Low band (последовательность значений)
		public IList<double> Gen_VKL(ISecurity source, int IntervalSize, int IntervalCount)
		{
			int shift = IntervalSize * IntervalCount;
			double vValue = 0;
			double min = 0;
			double price = 0;
			
			// серия значений 
			IList<double> nValue = new List<double>(source.Bars.Count);

			for (int i=0; i<shift; i++) nValue.Add(source.LowPrices[i]);
			for (int bar = shift; bar < source.Bars.Count; bar++)
			{
				vValue = 0;
				for (int i=0; i<IntervalCount; i++)
				{
					min = source.LowPrices[bar-i*IntervalSize];
					for (int k=0; k<IntervalSize; k++)
					{
						price = source.LowPrices[bar-i*IntervalSize-k];
						if (price < min) min = price;
					}
					vValue = vValue + min / IntervalCount;
				}
				//--------------------------------------------------------------------------------
				// добавление нового значения в последовательность
				nValue.Add(vValue);
			}
			return nValue;
		}
		
		//================================================================================
		// функция вычисления VK High band (последовательность значений)
		public IList<double> Gen_VKH(ISecurity source, int IntervalSize, int IntervalCount)
		{
			int shift = IntervalSize * IntervalCount;
			double vValue = 0;
			double max = 0;
			double price = 0;
			
			// серия значений 
			IList<double> nValue = new List<double>(source.Bars.Count);

			for (int i=0; i<shift; i++) nValue.Add(source.HighPrices[i]);
			for (int bar = shift; bar < source.Bars.Count; bar++)
			{
				vValue = 0;
				for (int i=0; i<IntervalCount; i++)
				{
					max = source.HighPrices[bar-i*IntervalSize];
					for (int k=0; k<IntervalSize; k++)
					{
						price = source.HighPrices[bar-i*IntervalSize-k];
						if (price > max) max = price;
					}
					vValue = vValue + max / IntervalCount;
				}
				//--------------------------------------------------------------------------------
				// добавление нового значения в последовательность
				nValue.Add(vValue);
			}
			return nValue;
		}
		
		//================================================================================
		// Параметры оптимизации
		// параметра для длинных позиций
		public OptimProperty LongOpenPeriodParam = new OptimProperty(6, 2, 10, 1);
		public OptimProperty LongOpenIntervalParam = new OptimProperty(12, 2, 20, 2);
		public OptimProperty LongClosePeriodParam = new OptimProperty(9, 2, 10, 1);
		public OptimProperty LongCloseIntervalParam = new OptimProperty(20, 2, 20, 2);
		// параметра для коротких позиций
		//public OptimProperty ShortOpenPeriodParam = new OptimProperty(8, 2, 10, 1);
		//public OptimProperty ShortOpenIntervalParam = new OptimProperty(22, 10, 26, 2);
		//public OptimProperty ShortClosePeriodParam = new OptimProperty(6, 2, 10, 1);
		//public OptimProperty ShortCloseIntervalParam = new OptimProperty(12, 2, 20, 2);

		//================================================================================
		public virtual void Execute(IContext ctx, ISecurity source)
		{
			int StartBar = 0;

			#region Variables
			// для длинных позиций
			// открытие позиций
			int LongOpenPeriod; // период расчета
			int LongOpenInterval; // интервал расчета 
			// закрытие позиций
			int LongClosePeriod; // период расчета 
			int LongCloseInterval; // интервал расчета 
			
			// для коротких позиций
			// открытие позиций
			//int ShortOpenPeriod; // период расчета 
			//int ShortOpenInterval; // интервал расчета 
			// закрытие позиций
			//int ShortClosePeriod; // период расчета 
			//int ShortCloseInterval; // интервал расчета 
			
			#endregion
			//--------------------------------------------------------------------------------
			#region Obtain parameters
			LongOpenPeriod = LongOpenPeriodParam;
			LongOpenInterval = LongOpenIntervalParam;
			LongClosePeriod = LongClosePeriodParam;
			LongCloseInterval = LongCloseIntervalParam;
			
			//ShortOpenPeriod = ShortOpenPeriodParam;
			//ShortOpenInterval = ShortOpenIntervalParam;
			//ShortClosePeriod = ShortClosePeriodParam;
			//ShortCloseInterval = ShortCloseIntervalParam;

			StartBar = LongOpenPeriod * LongOpenInterval;
			if (LongClosePeriod*LongCloseInterval > StartBar) StartBar = LongClosePeriod*LongCloseInterval;
			//if (ShortOpenPeriod*ShortOpenInterval > StartBar) StartBar = ShortOpenPeriod*ShortOpenInterval;
			//if (ShortClosePeriod*ShortCloseInterval > StartBar) StartBar = ShortClosePeriod*ShortCloseInterval;

			// Используем GetData для кеширования данных и ускорения оптимизации.
			// для длинных позиций
			// серия для простой скользящей средней SMA для минимумов
			IList<double> nLongVKL = ctx.GetData("LongVKL", new[] {LongOpenPeriod.ToString()+"_"+LongOpenInterval.ToString()},
			delegate { return Gen_VKL(source, LongOpenPeriod, LongOpenInterval); });
			IList<double> nLongVKH = ctx.GetData("LongVKH", new[] {LongClosePeriod.ToString()+"_"+LongCloseInterval.ToString()},
			delegate { return Gen_VKH(source, LongClosePeriod, LongCloseInterval); });

			// для коротких позиций
			// серия для простой скользящей средней SMA для максимумов
			//IList<double> nShortVKH = ctx.GetData("ShortVKH", new[] {ShortOpenPeriod.ToString()+"_"+ShortOpenInterval.ToString()},
			//delegate { return Gen_VKH(source, ShortOpenPeriod, ShortOpenInterval); });
			//IList<double> nShortVKL = ctx.GetData("ShortVKL", new[] {ShortClosePeriod.ToString()+"_"+ShortCloseInterval.ToString()},
			//delegate { return Gen_VKL(source, ShortClosePeriod, ShortCloseInterval); });
			
			#endregion
			//================================================================================
			#region основной цикл - проход по барам
			int barsCount = source.Bars.Count;
			for (int bar = StartBar; bar < barsCount-1; bar++)
			{
				//--------------------------------------------------------------------------------
				#region calculate values

				
				#endregion
				//--------------------------------------------------------------------------------
				#region generate signals
				// сброс значений сигналов
				bBuy = false;
				bSell = false;
				bShort = false;
				bCover = false;
				
				// установка сигналов по условиям
				// для длинных позиций
				if ((source.ClosePrices[bar-1] >= nLongVKL[bar-1]) && (source.ClosePrices[bar] < nLongVKL[bar])) bBuy = true;
				if ((source.ClosePrices[bar-1] <= nLongVKH[bar-1]) && (source.ClosePrices[bar] > nLongVKH[bar])) bSell = true;
				// для коротких позиций
				//if ((source.ClosePrices[bar-1] <= nShortVKH[bar-1]) && (source.ClosePrices[bar] > nShortVKH[bar])) bShort = true;
				//if ((source.ClosePrices[bar-1] >= nShortVKL[bar-1]) && (source.ClosePrices[bar] < nShortVKL[bar])) bCover = true;

				#endregion
				//================================================================================
				#region execute signals
				//--------------------------------------------------------------------------------
				// выполнение сигналов для длинной позиции
				LongPos = source.Positions.GetLastActiveForSignal("LN");
				if (LongPos == null)
				{
					// Если нет активной длинной позиции
					if (bBuy)
					{
						// Если есть сигнал Buy, 
						// выдаем ордер на открыте новой длинной позиции.
						source.Positions.BuyAtMarket(bar+1, 1, "LN");
					}
				}
				else
				{
					// Если есть активная длинная позиция 
					if (bSell)
					{
						// Если есть сигнал Sell, 
						// выдаем ордер на закрыте длинной позиции.
						LongPos.CloseAtMarket(bar+1, "LX");
					}
				}
				//--------------------------------------------------------------------------------
				// выполнение сигналов для короткой позиции
				ShortPos = source.Positions.GetLastActiveForSignal("SN");
				if (ShortPos == null)
				{
					// Если нет активной короткой позиции
					if (bShort)
					{
						// Если есть сигнал Short
						// выдаем ордер на открыте новой короткой позиции.
						source.Positions.SellAtMarket(bar+1, 1, "SN");
			
					}
				}
				else
				{
					// Если есть активная короткая позиция, 
					if (bCover)
					{
						// Если есть сигнал Cover
						// выдаем ордер на закрыте короткой позиции.
						ShortPos.CloseAtMarket(bar+1, "SX");
					}
				}
				#endregion
			}
			#endregion
			//================================================================================
			#region прорисовка графиков
			// Берем основную панель (Pane)
			IPane mainPane = ctx.First;
 
			// для длинных позиций
			mainPane.AddList("LongVKL", nLongVKL, ListStyles.LINE, 0x0000a0, LineStyles.DOT, PaneSides.RIGHT);
			mainPane.AddList("LongVKH", nLongVKH, ListStyles.LINE, 0x00a0a0, LineStyles.DOT, PaneSides.RIGHT);
			
			// для коротких позиций
			//mainPane.AddList("ShortVKH", nShortVKH, ListStyles.LINE, 0xa00000, LineStyles.DOT, PaneSides.RIGHT);
			//mainPane.AddList("ShortVKL", nShortVKL, ListStyles.LINE, 0xa000a0, LineStyles.DOT, PaneSides.RIGHT);

			#endregion
			//--------------------------------------------------------------------------------
		}
	}
}