using System;
using System.Collections.Generic;
using System.Linq;
using Matriks.Data.Symbol;
using Matriks.Engines;
using System.Windows.Media;
using Matriks.Indicators;
using Matriks.Symbols;
using Matriks.AlgoTrader;
using Matriks.Trader.Core;
using Matriks.Trader.Core.Fields;
using Matriks.Trader.Core.TraderModels;
using Matriks.Lean.Algotrader.AlgoBase;
using Matriks.Lean.Algotrader.Models;
using Matriks.Lean.Algotrader.Trading;
/*

Strateji çalıştığı gibi belirlenen alış ve/veya satış kademelerine emirler gönderilir.
Fiyat hareket ettikçe gönderilen emirlerde aynı mesafede fiyattan uzaklaşması için emirler düzeltilir.

Ani bir harekette emirler son fiyata yakalanıp emir gerçekleştiyse GerceklesenEmirDurumu göre iki seçenek bulunmaktadır.
	GerceklesenIslemdeYeniEmirVer seçildiyse işlem olan yönde en al veya üst kadameye emir gönderilir.
	GerceklesenIslemdePozisyonlarıKapatveStartejiyiDurdur seçildiyse bekleyen diğer emirler iptal edilip strateji duraklatılacaktır.

*/

namespace Matriks.Lean.Algotrader
{
	public class IslemlerdenKacis : MatriksAlgo
	{
		[SymbolParameter("GARAN")]
		public string Symbol;

		[Parameter(3)]
		public int KacKademeAltindanVeUstundenBaslayacak;

		[Parameter(2)]
		public int KacKademe;

		[Parameter(1)]
		public decimal Adet;

		[Parameter(yon.Ikiside)]
		public yon HangiIslemlerKacilacak;

		public enum yon
		{
			Alis, Satis, Ikiside
		}

		[Parameter(GerceklesenEmirDurumu.GerceklesenIslemdePozisyonlarıKapatveStartejiyiDurdur)]
		public GerceklesenEmirDurumu gerceklesenEmirDurumu;

		public enum GerceklesenEmirDurumu
		{
			GerceklesenIslemdeYeniEmirVer, GerceklesenIslemdePozisyonlarıKapatveStartejiyiDurdur
		}

		decimal fiyatAdimi, altSeviye, ustSeviye;

		[Output]
		public decimal AlisFiyat = 0;

		[Output]
		public decimal SatisFiyat = 0;

		Dictionary<string, decimal> buyOrderList = new Dictionary<string, decimal>();
		Dictionary<string, decimal> sellOrderList = new Dictionary<string, decimal>();

		public override void OnInit()
		{
			AddSymbol(Symbol, SymbolPeriod.Min);
			AddSymbolMarketDepth(Symbol);
		}

		public decimal FX_AltSeviyeHesapla()
		{
			return AlisFiyat - (KacKademeAltindanVeUstundenBaslayacak * fiyatAdimi);
		}

		public decimal FX_UstSeviyeHesapla()
		{
			return SatisFiyat + (KacKademeAltindanVeUstundenBaslayacak * fiyatAdimi);
		}

		bool ilkIslem = true;
		[Output]
		public bool aktifMI = true;
		bool ? alisArtiMI = null;
		bool ? satisArtiMI = null;
		string orderID;

		public override void OnDataUpdate(BarDataCurrentValues barDataCurrentValues)
		{
			if (aktifMI)
			{
				var derinlik = GetMarketDepth(Symbol);

				if (derinlik? .AskRows == null || derinlik.AskRows.Count < 1 || derinlik? .BidRows == null || derinlik.BidRows.Count < 1)
				{
					Debug(" Derinlik verisi bekleniyor."); return ;
				}

				var dataAlis = derinlik.BidRows[0].Price;
				var dataSatis = derinlik.AskRows[0].Price;

				if (dataAlis > AlisFiyat && AlisFiyat != 0)
				{
					alisArtiMI = true;
				}else if (dataAlis < AlisFiyat && AlisFiyat != 0)
				{
					alisArtiMI = false;
				}else
				{
					alisArtiMI = null;
				}

				AlisFiyat = dataAlis;

				if (dataSatis > SatisFiyat && SatisFiyat != 0)
				{
					satisArtiMI = true;
				}else if (dataSatis < SatisFiyat && SatisFiyat != 0)
				{
					satisArtiMI = false;
				}else
				{
					satisArtiMI = null;
				}
				SatisFiyat = dataSatis;

				if (ilkIslem && dataAlis != 0 && dataSatis != 0)
				{
					Debug("İlk işlem tetiklendi. Alış fiyat: " + AlisFiyat + " Satış fiyatı: " + SatisFiyat);
					fiyatAdimi = GetPriceStepForBistViop(Symbol, dataAlis);

					if (HangiIslemlerKacilacak != yon.Satis)
					{
						// Alış
						for (int i = 0; i<KacKademe; i++)
						{
							orderID = SendLimitOrder(Symbol, Adet, OrderSide.Buy, FX_AltSeviyeHesapla() - (fiyatAdimi * i));
							Debug("Fiyat: " + (FX_AltSeviyeHesapla() - (fiyatAdimi * i)).ToString() + " Adet: " + Adet + " limit alış emir gönderildi");
							buyOrderList[orderID] = FX_AltSeviyeHesapla() - (fiyatAdimi * i);
						}
					}

					if (HangiIslemlerKacilacak != yon.Alis)
					{
						// Satış
						for (int i = 0; i<KacKademe; i++)
						{
							orderID = SendLimitOrder(Symbol, Adet, OrderSide.Sell, FX_UstSeviyeHesapla() + (fiyatAdimi * i));
							Debug("Fiyat: " + (FX_UstSeviyeHesapla() + (fiyatAdimi * i)).ToString() + " Adet: " + Adet + " limit satış emir gönderildi");
							sellOrderList[orderID] = FX_UstSeviyeHesapla() + (fiyatAdimi * i);
						}
					}

					ilkIslem = false;
				}else if (dataAlis == 0)
				{
					Debug("Aktif fiyat sıfır(0) olduğu için strateji durduruldu.");
					aktifMI = false;
				}

				if (satisArtiMI != null)
				{
					if (satisArtiMI == false)
					{
						if (HangiIslemlerKacilacak != yon.Alis)
						{
							var _sellOrderList = sellOrderList.Where(x => x.Value>FX_UstSeviyeHesapla() + ((KacKademe -1) * fiyatAdimi)).ToList();
							var _sellOrderListCount = _sellOrderList.Count();
							var _sellOrderListMinPrice = sellOrderList.Values.Min();

							if (_sellOrderListCount != 0)
							{
								foreach (var _order in _sellOrderList)
								{
									SendReplaceOrder(_order.Key, _sellOrderListMinPrice - (fiyatAdimi * _sellOrderListCount));
									sellOrderList[_order.Key] = _sellOrderListMinPrice - (fiyatAdimi * _sellOrderListCount);
									_sellOrderListCount--;
								}
							}
						}
					}

					if (satisArtiMI == true)
					{
						if (HangiIslemlerKacilacak != yon.Alis)
						{
							var _sellOrderList = sellOrderList.Where(x => x.Value<FX_UstSeviyeHesapla()).ToList();
							var _sellOrderListCount = _sellOrderList.Count();
							var _sellOrderListMaxPrice = sellOrderList.Values.Max();

							if (_sellOrderListCount != 0)
							{
								foreach (var _order in _sellOrderList)
								{
									SendReplaceOrder(_order.Key, _sellOrderListMaxPrice + (fiyatAdimi * _sellOrderListCount));
									sellOrderList[_order.Key] = _sellOrderListMaxPrice + (fiyatAdimi * _sellOrderListCount);
									_sellOrderListCount--;
								}
							}
						}
					}
				}

				if (alisArtiMI != null)
				{
					if (alisArtiMI == false)
					{
						if (HangiIslemlerKacilacak != yon.Satis)
						{
							var _buyOrderList = buyOrderList.Where(x => x.Value>FX_AltSeviyeHesapla()).ToList();
							var _buyOrderListCount = _buyOrderList.Count();
							var _buyOrderListMinPrice = buyOrderList.Values.Min();

							if (_buyOrderListCount != 0)
							{
								foreach (var _order in _buyOrderList)
								{
									SendReplaceOrder(_order.Key, _buyOrderListMinPrice - (fiyatAdimi * _buyOrderListCount));
									buyOrderList[_order.Key] = _buyOrderListMinPrice - (fiyatAdimi * _buyOrderListCount);
									_buyOrderListCount--;
								}
							}
						}
					}

					if (alisArtiMI == true)
					{
						if (HangiIslemlerKacilacak != yon.Satis)
						{
							var _buyOrderList = buyOrderList.Where(x => x.Value<FX_AltSeviyeHesapla() - ((KacKademe -1) * fiyatAdimi)).ToList();
							var _buyOrderListCount = _buyOrderList.Count();
							var _buyOrderListMaxPrice = buyOrderList.Values.Max();
							if (_buyOrderListCount != 0)
							{
								foreach (var _order in _buyOrderList)
								{
									SendReplaceOrder(_order.Key, _buyOrderListMaxPrice + (fiyatAdimi * _buyOrderListCount));
									buyOrderList[_order.Key] = _buyOrderListMaxPrice + (fiyatAdimi * _buyOrderListCount);
									_buyOrderListCount--;
								}
							}
						}
					}
				}
			}
		}

		public override void OnOrderUpdate(IOrder order)
		{
			if (order.OrdStatus.Obj == OrdStatus.Filled)
			{
				if (GerceklesenEmirDurumu.GerceklesenIslemdeYeniEmirVer == gerceklesenEmirDurumu)
				{
					if (order.Side.Obj == Side.Buy)
					{
						if (buyOrderList.ContainsKey(order.CliOrdID))
						{
							Debug(order.CliOrdID + " ID'li alış emri gerçekleşti. Fiyat: " + buyOrderList[order.CliOrdID] + " gerçekleşme fiyatı: " + order.Price);
							buyOrderList.Remove(order.CliOrdID);
						}

						var enAlttakiSeviye = buyOrderList.Min(x => x.Value) - (KacKademeAltindanVeUstundenBaslayacak * fiyatAdimi); ;

						orderID = SendLimitOrder(Symbol, Adet, OrderSide.Buy, enAlttakiSeviye);
						Debug("Fiyat: " + enAlttakiSeviye + " Adet: " + Adet + " limit alış emir gönderildi");
						buyOrderList[orderID] = enAlttakiSeviye;
					}

					if (order.Side.Obj == Side.Sell)
					{
						if (sellOrderList.ContainsKey(order.CliOrdID))
						{
							Debug(order.CliOrdID + " ID'li satış emri gerçekleşti. Fiyat: " + sellOrderList[order.CliOrdID] + " gerçekleşme fiyatı: " + order.Price);
							sellOrderList.Remove(order.CliOrdID);
						}

						var enUstekiSeviye = sellOrderList.Max(x => x.Value) + (KacKademeAltindanVeUstundenBaslayacak * fiyatAdimi); ;

						orderID = SendLimitOrder(Symbol, Adet, OrderSide.Sell, enUstekiSeviye);
						Debug("Fiyat: " + enUstekiSeviye + " Adet: " + Adet + " limit alış emir gönderildi");
						buyOrderList[orderID] = enUstekiSeviye;
					}

				}

				if (GerceklesenEmirDurumu.GerceklesenIslemdePozisyonlarıKapatveStartejiyiDurdur == gerceklesenEmirDurumu)
				{
					FX_StopLoss();
				}
			}
		}

		public override void OnStopped()
		{
			FX_StopLoss();
		}

		public void FX_StopLoss()
		{
			aktifMI = false;
			Debug("Strateji durduruldu.");

			var tut = Orders.Where(x => x.Value.OrdStatus.Obj == OrdStatus.New);

			foreach (var order in tut)
			{
				SendCancelOrder(order.Key);
			}

			Debug("Tüm Emirler iptal edildi.");
		}
	}
}