//+------------------------------------------------------------------+
//|                                  SuperCharlie_Aldridge_Dev_v0.mq5|
//|                                             HEDGING HORN CAPITAL |
//|                                     https://www.hhcapital.com.br |
//+------------------------------------------------------------------+
#property copyright "HEDGING HORN CAPITAL"
#property link      "https://www.hhcapital.com.br"
#property version   "DEV_v0"
#property description "INDICE"
//INDICE

//+===================================================================================================================================================================================+
//| 1 - SESSAO DE CABECALHO / ADMISSAO                                                                                                                                                
//+===================================================================================================================================================================================+
//+------------------------------------------------------------------+
//| 1.1 - IMPORTACOES                                                |
//+------------------------------------------------------------------+
#include "MarketBook.mqh"
#include "S1_Admissao1_v0.mqh"

//SLOTS_i,q = -Φ*k*q^2   ,   i=q
//SLOTS_i,q = λc/e       ,   i=q-1
//SLOTS_i,q = λv/e       ,   i=q+1
//SLOTS_i,q = 0          ,   default

//+===================================================================================================================================================================================+
//| 5 - SESSAO DE PRECOS / DIRECAO                                                                                                                                                    
//+===================================================================================================================================================================================+
//+------------------------------------------------------------------+
//| 5.1 - FUNCAO QUE VERIFICA O PRECO NAQUELE INSTANTE               |
//+------------------------------------------------------------------+
int VerificaPreco(double tickMin, int i, fluido &Fluidos, int ponta, slot &Slots[], posicao &SlotPos, bool chavePos)
{
   //Calcula os spreads
   //Ordem (Child Order)
   if(chavePos == false)
   {
      if(ponta == 0) Fluidos.precoMedioC = CalculaSpreadBuy(tickMin, i, Fluidos, Slots);
      else Fluidos.precoMedioV = CalculaSpreadSell(tickMin, i, Fluidos, Slots);
   }
   //Position (Parent Order)
   else if(chavePos == true)
   {
      CalculaAlteraPosicao(tickMin, Fluidos, SlotPos);
   }
   
   return 0;
}

//+------------------------------------------------------------------+
//| 5.2 - FUNCAO QUE CALCULA SPREAD BUY                              |
//+------------------------------------------------------------------+
double CalculaSpreadBuy(double tickMin, int i, fluido &Fluidos, slot &SlotsC[])
{
   double spreadB = 0.0;
      
   switch(i)
   {
      case 0 : SlotsC[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend - (2.5 - 0.25*5)*Fluidos.sigmaLFT - tickMin/2;
               SlotsC[i].precoAlvo = SlotsC[i].precoEnvio + tickMin*10;
               SlotsC[i].precoStop = Fluidos.media - 5*Fluidos.sigmaLFT;
             //  Print("Envio preenchido: ", SlotsC[i].precoEnvio,"TP preenchido:  ", SlotsC[i].precoAlvo,"SL:  ", SlotsC[i].precoStop);
               
         break;
      case 1 : SlotsC[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend - (2.5 + 0.25*5)*Fluidos.sigmaLFT - tickMin/2;
               SlotsC[i].precoAlvo = SlotsC[i].precoEnvio + tickMin*10;
               SlotsC[i].precoStop = Fluidos.media - 5*Fluidos.sigmaLFT;
         break;
      case 2 : SlotsC[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend - (2.5 - 0.25*3)*Fluidos.sigmaLFT - tickMin/2;
               SlotsC[i].precoAlvo = SlotsC[i].precoEnvio + tickMin*10;
               SlotsC[i].precoStop = Fluidos.media - 5*Fluidos.sigmaLFT;
         break;
      case 3 : SlotsC[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend - (2.5 - 0.25*2)*Fluidos.sigmaLFT - tickMin/2;
               SlotsC[i].precoAlvo = SlotsC[i].precoEnvio + tickMin*10;
               SlotsC[i].precoStop = Fluidos.media - 5*Fluidos.sigmaLFT;
         break;
      case 4 : SlotsC[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend - (2.5 - 0.25*1)*Fluidos.sigmaLFT - tickMin/2;
               SlotsC[i].precoAlvo = SlotsC[i].precoEnvio + tickMin*10;
               SlotsC[i].precoStop = Fluidos.media - 5*Fluidos.sigmaLFT;
         break;
      case 5 : SlotsC[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend - (2.5)*Fluidos.sigmaLFT - tickMin/2;
               SlotsC[i].precoAlvo = SlotsC[i].precoEnvio + tickMin*10;
               SlotsC[i].precoStop = Fluidos.media - 5*Fluidos.sigmaLFT;
         break;
      case 6 : SlotsC[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend - (2.5 + 0.25*1)*Fluidos.sigmaLFT - tickMin/2;
               SlotsC[i].precoAlvo = SlotsC[i].precoEnvio + tickMin*10;
               SlotsC[i].precoStop = Fluidos.media - 5*Fluidos.sigmaLFT;
         break;
      case 7 : SlotsC[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend - (2.5 + 0.25*2)*Fluidos.sigmaLFT - tickMin/2;
               SlotsC[i].precoAlvo = SlotsC[i].precoEnvio + tickMin*10;
               SlotsC[i].precoStop = Fluidos.media - 5*Fluidos.sigmaLFT;
         break;
      case 8 : SlotsC[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend - (2.5 + 0.25*3)*Fluidos.sigmaLFT - tickMin/2;
               SlotsC[i].precoAlvo = SlotsC[i].precoEnvio + tickMin*10;
               SlotsC[i].precoStop = Fluidos.media - 5*Fluidos.sigmaLFT;
         break;
      case 9 : SlotsC[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend - (2.5 + 0.25*4)*Fluidos.sigmaLFT - tickMin/2;
               SlotsC[i].precoAlvo = SlotsC[i].precoEnvio + tickMin*10;
               SlotsC[i].precoStop = Fluidos.media - 5*Fluidos.sigmaLFT;
         break;
      default: SlotsC[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend - (2.5)*Fluidos.sigmaLFT - tickMin/2;
               SlotsC[i].precoAlvo = SlotsC[i].precoEnvio + tickMin*10;
               SlotsC[i].precoStop = Fluidos.media - 5*Fluidos.sigmaLFT;
         break;
   }

   return spreadB;   
}

//+------------------------------------------------------------------+
//| 5.3 - FUNCAO QUE CALCULA SPREAD SELL                             |
//+------------------------------------------------------------------+
double CalculaSpreadSell(double tickMin, int i, fluido &Fluidos, slot &SlotsV[])
{
   double spread = 0.0;
   
   switch(i)
   {
      case 0 : SlotsV[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend + (2.5 - 0.25*5)*Fluidos.sigmaLFT + tickMin/2;
               SlotsV[i].precoAlvo = SlotsV[i].precoEnvio - tickMin*10;
               SlotsV[i].precoStop = Fluidos.media + 5*Fluidos.sigmaLFT;
         break;
      case 1 : SlotsV[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend + (2.5 + 0.25*5)*Fluidos.sigmaLFT + tickMin/2;
               SlotsV[i].precoAlvo = SlotsV[i].precoEnvio - tickMin*10;
               SlotsV[i].precoStop = Fluidos.media + 5*Fluidos.sigmaLFT;
         break;
      case 2 : SlotsV[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend + (2.5 - 0.25*3)*Fluidos.sigmaLFT + tickMin/2;
               SlotsV[i].precoAlvo = SlotsV[i].precoEnvio - tickMin*10;
               SlotsV[i].precoStop = Fluidos.media + 5*Fluidos.sigmaLFT;
         break;
      case 3 : SlotsV[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend + (2.5 - 0.25*2)*Fluidos.sigmaLFT + tickMin/2;
               SlotsV[i].precoAlvo = SlotsV[i].precoEnvio - tickMin*10;
               SlotsV[i].precoStop = Fluidos.media + 5*Fluidos.sigmaLFT;
         break;
      case 4 : SlotsV[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend + (2.5 - 0.25*1)*Fluidos.sigmaLFT + tickMin/2;
               SlotsV[i].precoAlvo = SlotsV[i].precoEnvio - tickMin*10;
               SlotsV[i].precoStop = Fluidos.media + 5*Fluidos.sigmaLFT;
         break;
      case 5 : SlotsV[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend + (2.5)*Fluidos.sigmaLFT + tickMin/2;
               SlotsV[i].precoAlvo = SlotsV[i].precoEnvio - tickMin*10;
               SlotsV[i].precoStop = Fluidos.media + 5*Fluidos.sigmaLFT;
         break;
      case 6 : SlotsV[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend + (2.5 + 0.25*1)*Fluidos.sigmaLFT + tickMin/2;
               SlotsV[i].precoAlvo = SlotsV[i].precoEnvio - tickMin*10;
               SlotsV[i].precoStop = Fluidos.media + 5*Fluidos.sigmaLFT;
         break;
      case 7 : SlotsV[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend + (2.5 + 0.25*2)*Fluidos.sigmaLFT + tickMin/2;
               SlotsV[i].precoAlvo = SlotsV[i].precoEnvio - tickMin*10;
               SlotsV[i].precoStop = Fluidos.media + 5*Fluidos.sigmaLFT;
         break;
      case 8 : SlotsV[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend + (2.5 + 0.25*3)*Fluidos.sigmaLFT + tickMin/2;
               SlotsV[i].precoAlvo = SlotsV[i].precoEnvio - tickMin*10;
               SlotsV[i].precoStop = Fluidos.media + 5*Fluidos.sigmaLFT;
         break;
      case 9 : SlotsV[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend + (2.5 + 0.25*4)*Fluidos.sigmaLFT + tickMin/2;
               SlotsV[i].precoAlvo = SlotsV[i].precoEnvio - tickMin*10;
               SlotsV[i].precoStop = Fluidos.media + 5*Fluidos.sigmaLFT;
         break;
      default: SlotsV[i].precoEnvio = Fluidos.media + Fluidos.driftLFTTend + (2.5)*Fluidos.sigmaLFT + tickMin/2;
               SlotsV[i].precoAlvo = SlotsV[i].precoEnvio - tickMin*10;
               SlotsV[i].precoStop = Fluidos.media + 5*Fluidos.sigmaLFT;
         break;
   }

   return spread;
}

//+------------------------------------------------------------------+
//| 5.4 - FUNCAO QUE CALCULA ALTERACAO DE PRECOS DA POSICAO          |
//+------------------------------------------------------------------+
void CalculaAlteraPosicao(double tickMin, fluido &Fluidos, posicao &SlotPos)
{
   Print("Entrou no Altera Posicao");
   //Se for posicao de compra
   if(SlotPos.ponta == POSITION_TYPE_BUY)
   {
      SlotPos.precoAlvo = SlotPos.precoMedio + 0.4*Fluidos.sigmaLFT;
      SlotPos.precoStop = Fluidos.media - 5*Fluidos.sigmaLFT;
   }
   else if(SlotPos.ponta == POSITION_TYPE_SELL)//Senao eh posicao de venda
   {
      SlotPos.precoAlvo = SlotPos.precoMedio - 0.4*Fluidos.sigmaLFT;
      SlotPos.precoStop = Fluidos.media + 5*Fluidos.sigmaLFT;
   }
   
   return;
}

//+------------------------------------------------------------------+
//| 5.5 - FUNCAO QUE CALCULA A MEDIA DE PRECOS                       |
//+------------------------------------------------------------------+
void GetPrecosPassados(MqlTick &ArrayTick[], double &precos[], int T)
{
   if(CopyTicks(Symbol(),ArrayTick,COPY_TICKS_TRADE,0,T) != -1)
   {
      ArraySetAsSeries(ArrayTick,true);
      for(int i=0;i<ArraySize(ArrayTick);i++)
      {
         precos[i] = ArrayTick[i].last;
      }
   }
   else
   {
      Print("Falha ao obter o ArrayTick, falha para GetPrecosPassados");
   }
   
   return;
}

//+------------------------------------------------------------------+
//| 5.6 - FUNCAO QUE CALCULA OS VETORES DE TENDENCIA E VOLATILIDADE  |
//+------------------------------------------------------------------+
void CalculaVetores(MqlTick &ArrayTick[], double &precos[], int T)
{
   //Declara variaveis
   double lambdaC = 0.0;
   double lambdaV = 0.0;
   double LOBC = 0.0;
   double LOBV = 0.0;
   
   //Calcula lambdas
   //lambdaC = CalculaLambdaCompra(ArrayTick, T);
   //lambdaC = CalculaLambdaCompra(ArrayTick, T);
   //LOBC = CalculaLobCompra(ArrayTick, T);
   //LOBV = CalculaLobVenda(ArrayTick, T);
   
   //Calcula vetor compra
   //vetorCompra = potencia(lambdaC, 2) / LOBV;
   
   //Calcula vetor venda
   //vetorVenda = potencia(lambdaV, 2) / LOBC;
   
   //Calcula vetor tendencia
   //vetorTend = raizQuadrada(potencia(vetorCompra, 2) + potencia(vetorVenda, 2));
   
   //Calcula vetor volatilidade
   //vetorVol = raizQuadrada(potencia((vetorCompra - vetorVenda), 2)/2);
   
   
   if(CopyTicks(Symbol(),ArrayTick,COPY_TICKS_TRADE,0,T) != -1)
   {
      ArraySetAsSeries(ArrayTick,true);
      for(int i=0;i<ArraySize(ArrayTick);i++)
      {
         precos[i] = ArrayTick[i].last;
      }
   }
   else
   {
      Print("Falha ao obter o ArrayTick, falha para GetPrecosPassados");
   }
   
   return;
}


//+------------------------------------------------------------------+
//| 5.7 - FUNCAO QUE CALCULA O LAMBDA COMPRA                         |
//+------------------------------------------------------------------+
int CalculaLambdaCompra(MqlTick &ArrayTick[], int T)
{
   int lambda = 0;
   int t = 0;
   
   for(int i=0;i<ArraySize(ArrayTick);i++)
   {
      while(t<T)
      {
         t = ArrayTick[0].time_msc - ArrayTick[i].time_msc;
         Print("Tempo em milisegundos: ", ArrayTick[0].time_msc);
         if(ArrayTick[i].flags == 1)
            lambda += ArrayTick[i].volume;
      }
      break;
   }
   
   return lambda;
}

//+------------------------------------------------------------------+
//| 5.8 - FUNCAO QUE CALCULA O LAMBDA VENDA                          |
//+------------------------------------------------------------------+
int CalculaLambdaVenda(MqlTick &ArrayTick[], int T)
{
   int lambda = 0;
   int t = 0;
   
   for(int i=0;i<ArraySize(ArrayTick);i++)
   {
      while(t<T)
      {
         t = ArrayTick[0].time_msc - ArrayTick[i].time_msc;
         if(ArrayTick[i].flags == 2)
            lambda += ArrayTick[i].volume;
      }
   }
   
   return lambda;
}

//+------------------------------------------------------------------+
//| 5.9 - FUNCAO QUE CALCULA O LOB COMPRA                            |
//+------------------------------------------------------------------+
int CalculaLobCompra(MqlBookInfo &ArrayBook[], int iBid, int T, int spreadBuy)
{
   int lobC = 0;
   
   lobC = ArrayBook[iBid].volume;
   
   return lobC;
}

//+------------------------------------------------------------------+
//| 5.10 - FUNCAO QUE CALCULA O LOB VENDA                            |
//+------------------------------------------------------------------+
int CalculaLobVenda(MqlBookInfo &ArrayBook[], int iAsk, int T, int spreadSell)
{
   int lobV = 0;
   
   lobV = ArrayBook[iAsk].volume;
   
   return lobV;
}


//+===================================================================================================================================================================================+
//| FIM DO PROGRAMA                                                                                                   
//+===================================================================================================================================================================================+