//+------------------------------------------------------------------+
//|                                               S5_Direcao1_v0.mq5 |
//|                                                  DESENVOLVIMENTO |
//|                                                           OXFORD |
//|                                             HEDGING HORN CAPITAL |
//|                                     https://www.hhcapital.com.br |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, HEDGING HORN CAPITAL"
#property link      "https://www.hhcapital.com.br"
#property version   "DEV_v0"
#property description "HFT MARKET MAKING BASED ON OXFORD'S STUDIES. MINI 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 CalculaPreco(MqlBookInfo &ArrayBook[], fluido &Fluidos, slot &Slots[])
{
   //Calcula os spreads
   if(Slots[0].ponta == 0) 
   {
      Fluidos.precoMedioC = CalculaSpreadBuy(ArrayBook, Fluidos, Slots);
   }
   else Fluidos.precoMedioV = CalculaSpreadSell(ArrayBook, Fluidos, Slots);
   
   return 0;
}

//+------------------------------------------------------------------+
//| 5.2 - FUNCAO QUE CALCULA SPREAD BUY                              |
//+------------------------------------------------------------------+
double CalculaSpreadBuy(MqlBookInfo &ArrayBook[], fluido &Fluidos, slot &SlotsC[])
{
   double spreadB = 0.0;
   
   
   if(Fluidos.chaveBook == true) Fluidos.KC = CalculaKC(ArrayBook, Fluidos);
   
   //Fluidos.lambdaV = 1;
   //Falta Calcular Fluidos.lambdaV
  
   double spreadCompra = MathRound(100*Fluidos.tickMin*((Fluidos.lambdaV/Fluidos.KC) + Calcula_H_t_q_Compra(Fluidos, Fluidos.q) - Calcula_H_t_q_Compra(Fluidos, Fluidos.q+1)) / Fluidos.tickMin) * Fluidos.tickMin;
   double spreadVenda = MathRound(100*Fluidos.tickMin*((Fluidos.lambdaC/Fluidos.KV) + Calcula_H_t_q_Venda(Fluidos, Fluidos.q) - Calcula_H_t_q_Venda(Fluidos, Fluidos.q-1)) / Fluidos.tickMin) * Fluidos.tickMin;
   double spreadStopAux = MathRound(Fluidos.sigmaHFT / 5) * Fluidos.tickMin * 10;
   double passo = MathRound(Fluidos.sigmaHFT / 5) * 5;
  // Print("Passo: ", passo);
   
   switch(Fluidos.iSlot)
   {
      case 0 : SlotsC[Fluidos.iSlot].precoEnvio = Fluidos.media - Fluidos.tickMin/2 - spreadCompra;
               SlotsC[Fluidos.iSlot].precoAlvo = Fluidos.media + Fluidos.tickMin/2 + spreadVenda;
               SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoEnvio - spreadStopAux;
         break;
      case 1 : SlotsC[Fluidos.iSlot].precoEnvio = Fluidos.media - Fluidos.tickMin/2 - spreadCompra - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoAlvo = Fluidos.media + Fluidos.tickMin/2 + spreadVenda - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoEnvio - spreadStopAux;
         break;
      case 2 : SlotsC[Fluidos.iSlot].precoEnvio = Fluidos.media - Fluidos.tickMin/2 - spreadCompra - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoAlvo = Fluidos.media + Fluidos.tickMin/2 + spreadVenda - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoEnvio - spreadStopAux;
         break;
      case 3 : SlotsC[Fluidos.iSlot].precoEnvio = Fluidos.media - Fluidos.tickMin/2 - spreadCompra - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoAlvo = Fluidos.media + Fluidos.tickMin/2 + spreadVenda - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoEnvio - spreadStopAux;
         break;
      case 4 : SlotsC[Fluidos.iSlot].precoEnvio = Fluidos.media - Fluidos.tickMin/2 - spreadCompra - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoAlvo = Fluidos.media + Fluidos.tickMin/2 + spreadVenda - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoEnvio - spreadStopAux;
         break;
      case 5 : SlotsC[Fluidos.iSlot].precoEnvio = Fluidos.media - Fluidos.tickMin/2 - spreadCompra - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoAlvo = Fluidos.media + Fluidos.tickMin/2 + spreadVenda - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoEnvio - spreadStopAux;
         break;
      case 6 : SlotsC[Fluidos.iSlot].precoEnvio = Fluidos.media - Fluidos.tickMin/2 - spreadCompra - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoAlvo = Fluidos.media + Fluidos.tickMin/2 + spreadVenda - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoEnvio - spreadStopAux;
         break;
      case 7 : SlotsC[Fluidos.iSlot].precoEnvio = Fluidos.media - Fluidos.tickMin/2 - spreadCompra - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoAlvo = Fluidos.media + Fluidos.tickMin/2 + spreadVenda - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoEnvio - spreadStopAux;
         break;
      case 8 : SlotsC[Fluidos.iSlot].precoEnvio = Fluidos.media - Fluidos.tickMin/2 - spreadCompra - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoAlvo = Fluidos.media + Fluidos.tickMin/2 + spreadVenda - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoEnvio - spreadStopAux;
         break;
      case 9 : SlotsC[Fluidos.iSlot].precoEnvio = Fluidos.media - Fluidos.tickMin/2 - spreadCompra - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoAlvo = Fluidos.media + Fluidos.tickMin/2 + spreadVenda - passo*Fluidos.iSlot;
               SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoEnvio - spreadStopAux;
         break;
      default: SlotsC[Fluidos.iSlot].precoEnvio = Fluidos.media - Fluidos.tickMin/2 - spreadCompra;
               SlotsC[Fluidos.iSlot].precoAlvo = Fluidos.media + Fluidos.tickMin/2 + spreadVenda;
               SlotsC[Fluidos.iSlot].precoStop = SlotsC[Fluidos.iSlot].precoEnvio - spreadStopAux;
         break;
   }

   return spreadB;   
}

//+------------------------------------------------------------------+
//| 5.3 - FUNCAO QUE CALCULA SPREAD SELL                             |
//+------------------------------------------------------------------+
double CalculaSpreadSell(MqlBookInfo &ArrayBook[], fluido &Fluidos, slot &SlotsV[])
{
   double spread = 0.0;
   
   if(Fluidos.chaveBook == true) Fluidos.KV = CalculaKV(ArrayBook, Fluidos);
   
   //Fluidos.lambdaC = 1;
   //Falta Calcular Fluidos.lambdaC
   
   double spreadVenda = MathRound(100*Fluidos.tickMin*((Fluidos.lambdaC/Fluidos.KV) + Calcula_H_t_q_Venda(Fluidos, Fluidos.q) - Calcula_H_t_q_Venda(Fluidos, Fluidos.q-1)) / Fluidos.tickMin) * Fluidos.tickMin;
   double spreadCompra = MathRound(100*Fluidos.tickMin*((Fluidos.lambdaV/Fluidos.KC) + Calcula_H_t_q_Compra(Fluidos, Fluidos.q) - Calcula_H_t_q_Compra(Fluidos, Fluidos.q+1)) / Fluidos.tickMin) * Fluidos.tickMin;
   double spreadStopAux = MathRound(Fluidos.sigmaHFT / Fluidos.tickMin) * Fluidos.tickMin * 10;
   double passo = MathRound(Fluidos.sigmaHFT / 5) * 5;
     
   switch(Fluidos.iSlot)
   {
      case 0 : SlotsV[Fluidos.iSlot].precoEnvio = Fluidos.media + Fluidos.tickMin/2 + spreadVenda ;
               SlotsV[Fluidos.iSlot].precoAlvo = Fluidos.media - Fluidos.tickMin/2 - spreadCompra;
               SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoEnvio + spreadStopAux;
         break;
      case 1 : SlotsV[Fluidos.iSlot].precoEnvio = Fluidos.media + Fluidos.tickMin/2 + spreadVenda + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoAlvo = Fluidos.media - Fluidos.tickMin/2 - spreadCompra + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoEnvio + spreadStopAux;
         break;
      case 2 : SlotsV[Fluidos.iSlot].precoEnvio = Fluidos.media + Fluidos.tickMin/2 + spreadVenda + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoAlvo = Fluidos.media - Fluidos.tickMin/2 - spreadCompra + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoEnvio + spreadStopAux;
         break;
      case 3 : SlotsV[Fluidos.iSlot].precoEnvio = Fluidos.media + Fluidos.tickMin/2 + spreadVenda + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoAlvo = Fluidos.media - Fluidos.tickMin/2 - spreadCompra + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoEnvio + spreadStopAux;
         break;
      case 4 : SlotsV[Fluidos.iSlot].precoEnvio = Fluidos.media + Fluidos.tickMin/2 + spreadVenda + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoAlvo = Fluidos.media - Fluidos.tickMin/2 - spreadCompra + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoEnvio + spreadStopAux;
         break;
      case 5 : SlotsV[Fluidos.iSlot].precoEnvio = Fluidos.media + Fluidos.tickMin/2 + spreadVenda + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoAlvo = Fluidos.media - Fluidos.tickMin/2 - spreadCompra + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoEnvio + spreadStopAux;
         break;
      case 6 : SlotsV[Fluidos.iSlot].precoEnvio = Fluidos.media + Fluidos.tickMin/2 + spreadVenda + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoAlvo = Fluidos.media - Fluidos.tickMin/2 - spreadCompra + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoEnvio + spreadStopAux;
         break;
      case 7 : SlotsV[Fluidos.iSlot].precoEnvio = Fluidos.media + Fluidos.tickMin/2 + spreadVenda + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoAlvo = Fluidos.media - Fluidos.tickMin/2 - spreadCompra + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoEnvio + spreadStopAux;
         break;
      case 8 : SlotsV[Fluidos.iSlot].precoEnvio = Fluidos.media + Fluidos.tickMin/2 + spreadVenda + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoAlvo = Fluidos.media - Fluidos.tickMin/2 - spreadCompra + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoEnvio + spreadStopAux;
         break;
      case 9 : SlotsV[Fluidos.iSlot].precoEnvio = Fluidos.media + Fluidos.tickMin/2 + spreadVenda + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoAlvo = Fluidos.media - Fluidos.tickMin/2 - spreadCompra + passo*Fluidos.iSlot;
               SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoEnvio + spreadStopAux;
         break;
      default: SlotsV[Fluidos.iSlot].precoEnvio = Fluidos.media + Fluidos.tickMin/2 + spreadVenda;
               SlotsV[Fluidos.iSlot].precoAlvo = Fluidos.media - Fluidos.tickMin/2 - spreadCompra;
               SlotsV[Fluidos.iSlot].precoStop = SlotsV[Fluidos.iSlot].precoEnvio + spreadStopAux;
         break;
   }

   return spread;
}

//+------------------------------------------------------------------+
//| 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.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;
         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[], fluido &Fluidos)
{
   int lobC = 0;
   for(int i=0; i<Fluidos.nBook;i++)
   {
      lobC = ArrayBook[Fluidos.iBid0 - i].volume;
   }
   return lobC;
}

//+------------------------------------------------------------------+
//| 5.10 - FUNCAO QUE CALCULA O LOB VENDA                            |
//+------------------------------------------------------------------+
int CalculaLobVenda(MqlBookInfo &ArrayBook[], fluido &Fluidos)
{
   int lobV = 0;
   for(int i=0; i<Fluidos.nBook;i++)
   {
      lobV = ArrayBook[Fluidos.iAsk0 + i].volume;
   }
   return lobV;
}

//+------------------------------------------------------------------+
//| 5.11 - FUNCAO QUE CALCULA O KC                                   |
//+------------------------------------------------------------------+
int CalculaKC(MqlBookInfo &ArrayBook[], fluido &Fluidos)
{
   int KC = 0;
   
   KC = CalculaLobCompra(ArrayBook, Fluidos) / Fluidos.nBook;
   
   return KC;
}

//+------------------------------------------------------------------+
//| 5.12 - FUNCAO QUE CALCULA O KV                                   |
//+------------------------------------------------------------------+
int CalculaKV(MqlBookInfo &ArrayBook[], fluido &Fluidos)
{
   int KV = 0;
   
   KV = CalculaLobCompra(ArrayBook, Fluidos) / Fluidos.nBook;
   
   return KV;
}

//+------------------------------------------------------------------+
//| 5.13 - FUNCAO QUE CALCULA O h(t,q) do SpreadBuy                  |
//+------------------------------------------------------------------+
double Calcula_H_t_q_Compra(fluido &Fluidos, int q)
{
   double h = 0.0;
   
   h = (Fluidos.lambdaV * log( exp( -Fluidos.fi*Fluidos.KC*pow( q,2 )*( Fluidos.T-Fluidos.t ) ) * exp( -Fluidos.alpha*Fluidos.KC*pow( q,2 ) ) ) ) / Fluidos.KC;
   
   return h;
}

//+------------------------------------------------------------------+
//| 5.14 - FUNCAO QUE CALCULA O h(t,q) do SpreadSell                 |
//+------------------------------------------------------------------+
double Calcula_H_t_q_Venda(fluido &Fluidos, int q)
{
   double h = 0.0;
   
   h = (Fluidos.lambdaC * log( exp( -Fluidos.fi*Fluidos.KV*pow( q,2 )*( Fluidos.T-Fluidos.t ) ) * exp( -Fluidos.alpha*Fluidos.KV*pow( q,2 ) ) ) ) / Fluidos.KV;
   
   return h;
}

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