//+------------------------------------------------------------------+
//|                                                S2_Motor_v4_4.mqh |
//|                                                           OXFORD |
//|                                             HEDGING HORN CAPITAL |
//|                                     https://www.hhcapital.com.br |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, HEDGING HORN CAPITAL"
#property link      "https://www.hhcapítal.com.br"
#property version   "DESENV_v4_4"
#property description "HFT MARKET MAKING BASED ON OXFORD'S STUDIES. MINI INDICE."

//+===================================================================================================================================================================================+
//| 0 - SESSAO DE CABECALHO / ADMISSAO                                                                                                                                                
//+===================================================================================================================================================================================+
//+------------------------------------------------------------------+
//| 0.1 - IMPORTACOES                                                |
//+------------------------------------------------------------------+
#include <Expert/Expert.mqh>
#include <Trade/Trade.mqh>
#include <Trade/SymbolInfo.mqh>
#include "MarketBook.mqh"
#include "S0_Admissao_v4_4.mqh"
#include "S3_Freios_v4_4.mqh"
#include "S4_Cambio_v4_4.mqh"
#include "S5_Direcao_v4_4.mqh"
#include "S6_Transmissao_v4_4.mqh"

//+===================================================================================================================================================================================+
//| 2 - SESSAO DE FAZER NEGOCIACOES / MOTOR                                                                                                                            
//+===================================================================================================================================================================================+
//+------------------------------------------------------------------+
//| 2.1 - FUNCAO QUE FAZ NEGOCIACOES                                 |
//+------------------------------------------------------------------+
void FazTrades(gerenciador &Gerenciador, operacao &Operacao, fluido &Fluidos, slot &SlotsC[], slot &SlotsV[], MqlTick &ArrayTick[], MqlBookInfo &ArrayBook[])
{  
   //Verifica os Riscos de Nivel 3 (Condicoes desfavoraveis para a estrategia no dia como: Stop Financeiro do dia ou limite de Tendencia do dia)
   if(VerificaRiscosNivel3(Gerenciador, Operacao, Fluidos) == false)
   {
      //AtualizaPosicoes(Operacao, Fluidos, ArrayTick, ArrayBook);
      //AtualizaOrdens(Operacao, Fluidos);
      //ExecutaSlotsDisponiveis();
      
      
      //== atualiza triggers de entrada
      AtualizaTriggersEntrada ();
      
      ExecutaOrdens();
      
      GerenciaPosicoes(); 
      
      Operacao.countFechaDia == 0;
   }
   else
   {
      if(Operacao.countFechaDia == 0)
      {
         FechaPosicoes(Operacao);
         Print("Mandou fechar todas as posicoes pelo risco.");
         CancelaOrdensAbertas(Operacao);
         Print("Mandou cancelar todas as ordens abertas pelo risco.");
         if((PositionsTotal() + OrdersTotal()) == 0) Operacao.countFechaDia = 1;
      }
   }
   
   //ATUALIZA TELEMETRIA
   Comment(
           "===GERENCIAMENTO P&L===", "\n" +
           "CAPITAL BRUTO FECHADO: ", Gerenciador.capitalFechado, "\n" +
           "CAPITAL BRUTO ABERTO: ", Gerenciador.capitalAberto, "\n" +
           "LUCRO BRUTO FECHADO: ", Gerenciador.lucroBrutoFechado, "\n" +
           "LUCRO BRUTO ABERTO: ", Gerenciador.lucroBrutoAberto, "\n" +
           "LUCRO BRUTO COMPOSTO: ", Gerenciador.lucroBrutoComposto, "\n" +
           "LUCRO LIQUIDO: ", Gerenciador.lucroLiquido, "\n" +        
           "NUMERO DE CONTRATOS (compra+venda): ", Operacao.numeroContratos - (2*(Fluidos.rajada*Fluidos.niveis)), "\n" +
           "CUSTO: ", (Operacao.numeroContratos - (2*Fluidos.rajada*Fluidos.niveis)) * (Fluidos.c*2), "\n" +
           "INVENTARIO: ", Fluidos.q, "\n" +   
           "\n" +
           "===GERENCIAMENTO DA OPERACAO===", "\n" + 
           "LC: ", NormalizeDouble(Fluidos.lambdaC,2), "\n" +
           "LV: ", NormalizeDouble(Fluidos.lambdaV,2), "\n" +
           "KC: ", Fluidos.KC, "\n" +
           "KV: ", Fluidos.KV, "\n" +
           "EC: ", NormalizeDouble(Fluidos.sigmaHFT/Fluidos.lambdaC, 2), "\n" +
           "EV: ", NormalizeDouble(Fluidos.sigmaHFT/Fluidos.lambdaC, 2), "\n" +
           "TC: ", NormalizeDouble((Fluidos.KV/Fluidos.lambdaC), 2), "\n" +
           "TV: ", NormalizeDouble((Fluidos.KC/Fluidos.lambdaV), 2), "\n" +
           "VOL: ", NormalizeDouble(Fluidos.sigmaLFT/600,2), "\n" +
           "A: ", NormalizeDouble(Fluidos.assimetria,2), "\n" +
           "C: ", NormalizeDouble(Fluidos.curtose,2), "\n" +
           "IMBALANCE: ", NormalizeDouble(Fluidos.imbalance,4), "\n" +
           "TENDENCIA: ", Fluidos.tendencia);
           
   
  // Print(Fluidos.midPrice,"/",NormalizeDouble(Fluidos.media,0),"/",SlotsC[0].spreadEnvio,"/",SlotsC[0].spreadAlvo,"/",SlotsV[0].spreadEnvio,"/",SlotsV[0].spreadAlvo,"/",NormalizeDouble(Fluidos.lambdaC,0),"/",NormalizeDouble(Fluidos.lambdaV,0),"/",Fluidos.KC,"/",Fluidos.KV,"/",NormalizeDouble(Fluidos.imbalance,2),"/",Fluidos.tendencia,"/",NormalizeDouble(Fluidos.sigmaHFT,0));
   
   return;
}


//+------------------------------------------------------------------+
//| 2.2 - FUNCAO QUE ATUALIZA POSICOES                               |
//+------------------------------------------------------------------+
void AtualizaTriggersEntrada(operacao &Operacao)

   TimeToStruct(TimeCurrent(), Operacao.horarioMQL_atual);
   ushort minutoAtual = (Operacao.horarioMQL_atual.hour * 60) + Operacao.horarioMQL_atual.min;
   if(minutoAtual == (horarioCorteFimAnalise){
   {
      Operacao.horarioMQL_inicio.year = Operacao.horarioMQL_atual.year;
      Operacao.horarioMQL_inicio.month = Operacao.horarioMQL_atual.month;
      Operacao.horarioMQL_inicio.day = Operacao.horarioMQL_atual.day;
      Operacao.horarioMQL_inicio.hour = (horarioCorteInicioAnalise - MathMod(horarioCorteInicioAnalise,60))/60;
      Operacao.horarioMQL_inicio.min = MathMod(horarioCorteInicioAnalise,60);
      Operacao.horarioMQL_inicio.sec = Operacao.horarioMQL_atual.sec;
      Operacao.horarioMQL_inicio.day_of_week = Operacao.horarioMQL_atual.day_of_week;
      Operacao.horarioMQL_inicio.day_of_year = Operacao.horarioMQL_atual.day_of_year;
      
      Operacao.horarioMQL_final.year = Operacao.horarioMQL_atual.year;
      Operacao.horarioMQL_final.month = Operacao.horarioMQL_atual.month;
      Operacao.horarioMQL_final.day = Operacao.horarioMQL_atual.day;
      Operacao.horarioMQL_final.hour = (horarioCorteFimAnalise - MathMod(horarioCorteFimAnalise,60))/60;
      Operacao.horarioMQL_final.min = MathMod(horarioCorteFimAnalise,60);
      Operacao.horarioMQL_final.sec = Operacao.horarioMQL_atual.sec;
      Operacao.horarioMQL_final.day_of_week = Operacao.horarioMQL_atual.day_of_week;
      Operacao.horarioMQL_final.day_of_year = Operacao.horarioMQL_atual.day_of_year;
      
      
      int numeroBarras = Bars(_Symbol,PERIOD_M1, StructToTime(Operacao.horarioMQL_inicio) , StructToTime(Operacao.horarioMQL_final));
      
      double faixaSuperior = 0.0;
      double faixaInferior = 0.0;
      for(int i = 0; i<numeroBarras ; i++)
      {
         if(faixaSuperior < iHigh(_Symbol, PERIOD_M1, i) faixaSuperior = iHigh(_Symbol, PERIOD_M1, i);
         if(faixaInferior > iLow(_Symbol, PERIOD_M1, i) faixaInferior = iLow(_Symbol, PERIOD_M1, i);
      }
   }
   else 
   {
      //espera até as 10h
   }
   




















//+------------------------------------------------------------------+
//| 2.2 - FUNCAO QUE ATUALIZA POSICOES                               |
//+------------------------------------------------------------------+
void AtualizaPosicoes(operacao &Operacao, fluido &Fluidos, MqlTick &ArrayTick[], MqlBookInfo &ArrayBook[])
{
   Fluidos.tendencia = GetTendencia(Fluidos, ArrayTick, ArrayBook);
   
   for(int i=0; i<PositionsTotal(); i++)
   {
      ulong ticket = PositionGetTicket(i);
      string symbol = PositionGetString(POSITION_SYMBOL);
      ulong magicEA = PositionGetInteger(POSITION_MAGIC);
      
      TimeToStruct(PositionGetInteger(POSITION_TIME),Operacao.cronometroPosicao);
      TimeToStruct(TimeCurrent(), Operacao.horarioMQL_atual);
      int duracaoPosicao = (Operacao.horarioMQL_atual.hour*60*60 + Operacao.horarioMQL_atual.min*60 + Operacao.horarioMQL_atual.sec) - (Operacao.cronometroPosicao.hour*60*60 + Operacao.cronometroPosicao.min*60 + Operacao.cronometroPosicao.sec);
      
      TimeToStruct(PositionGetInteger(POSITION_TIME_UPDATE), Operacao.cronometroRefreshPosicao);
      int refreshPosicao = (Operacao.horarioMQL_atual.hour*60*60 + Operacao.horarioMQL_atual.min*60 + Operacao.horarioMQL_atual.sec) - (Operacao.cronometroRefreshPosicao.hour*60*60 + Operacao.cronometroRefreshPosicao.min*60 + Operacao.cronometroRefreshPosicao.sec);
      
      Operacao.tipoPosicao = PositionGetInteger(POSITION_TYPE);
      double precoAlvoAnt = PositionGetDouble(POSITION_TP);
      double precoStopAnt = PositionGetDouble(POSITION_SL);
      Operacao.precoAlvo = PositionGetDouble(POSITION_TP);
      Operacao.precoStop = PositionGetDouble(POSITION_SL);
      Operacao.precoEnvio = PositionGetDouble(POSITION_PRICE_OPEN);  
      double spread = 0.0;
      int depth = 0;
      
      if(Operacao.chaveTheta == true) 
      {
         if(Operacao.tipoPosicao == POSITION_TYPE_BUY)
         {
            spread = precoAlvoAnt - Operacao.precoEnvio;
            depth = spread / Fluidos.tickMin;
            Operacao.expiraPosicao = CalculaTempoExpiraPosicaoCompra(Operacao, Fluidos, depth);
         }
         else
         {
            spread = Operacao.precoEnvio - precoAlvoAnt;
            depth = spread / Fluidos.tickMin;
            Operacao.expiraPosicao = CalculaTempoExpiraPosicaoVenda(Operacao, Fluidos, depth);
         }
      }
      
      if(symbol == _Symbol)
      {     
         
         if(duracaoPosicao > Operacao.expiraPosicao)
         {  
            //cancela posicao
            FechaPosicao(Operacao, ticket);
            Print("Mandou fechar a posicao por expiracao de tempo.");
         }
         else
         {
            CalculaPrecoTrailing(Operacao, Fluidos);
            if(precoStopAnt != Operacao.precoStop)
            {
               if(Operacao.tipoPosicao == POSITION_TYPE_BUY)
               {
                  if(precoStopAnt < Operacao.precoStop) ModificaStopPosicaoAberta(Operacao, ticket);
               }
               else
               {
                  if(precoStopAnt > Operacao.precoStop) ModificaStopPosicaoAberta(Operacao, ticket);
               }       
            }
            
            if( MathMod(refreshPosicao, Fluidos.TPr) >= (Fluidos.TPr -2) )   
            {
               //atualiza posicao
               CalculaPrecoPosicao(Operacao, Fluidos);
               if((Operacao.precoAlvo != precoAlvoAnt) || (Operacao.precoStop != precoStopAnt))
               {
                  if(Operacao.tipoPosicao == POSITION_TYPE_BUY)
                  {
                     if(Operacao.precoAlvo < Operacao.precoStop) Operacao.precoAlvo = precoAlvoAnt;
                     
                     ModificaPosicaoAberta(Operacao, ticket);

                  }
                  else if(Operacao.tipoPosicao == POSITION_TYPE_SELL)
                  {
                     if(Operacao.precoAlvo > Operacao.precoStop) Operacao.precoAlvo = precoAlvoAnt;
                     
                     ModificaPosicaoAberta(Operacao, ticket);
                  }
               }
            }
         }
      }
   
   }

}

//+------------------------------------------------------------------+
//| 2.3 - FUNCAO QUE ATUALIZA ORDENS                                 |
//+------------------------------------------------------------------+
void AtualizaOrdens(operacao &Operacao, fluido &Fluidos)
{
   ulong ticket = 0;
   MqlDateTime horarioMQL_ordem;
   string tendencia = "";
   tendencia = GetTendencia(Fluidos, ArrayTick, ArrayBook);
   
   for(int i=OrdersTotal()-1;i>=0;i--)
   {
      ticket = OrderGetTicket(i);
      
      ushort horarioOrdem = 0;
      ushort horarioShortAtual = 0;
      
      OrderSelect(ticket);
      double tamanho = OrderGetDouble(ORDER_VOLUME_INITIAL); 
      
      TimeToStruct(TimeCurrent(), Operacao.horarioMQL_atual);
      TimeToStruct(OrderGetInteger(ORDER_TIME_SETUP), horarioMQL_ordem);
      horarioOrdem = horarioMQL_ordem.hour*60*60 + horarioMQL_ordem.min*60 + horarioMQL_ordem.sec;
      horarioShortAtual = Operacao.horarioMQL_atual.hour*60*60 + Operacao.horarioMQL_atual.min*60 + Operacao.horarioMQL_atual.sec;
   //   Print("horarioAtual: ", horarioShortAtual, "  horarioOrdem: ", horarioOrdem, "  Fluidos.lifetime: ", Fluidos.lifetimeOrdem);
      if((horarioShortAtual - horarioOrdem) > Fluidos.TOr) 
      {
         bool retCancelou = Operacao.negocio.OrderDelete(ticket);   
         if(retCancelou == true) Operacao.numeroContratos = Operacao.numeroContratos - tamanho; 
       //  Print("Cancelou ordem aberta por expiração.");
      }
      else
      
      {
         //SE FOR COMPRA
         if(OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_BUY_LIMIT)
         {
            //SE FOR BAIXA
            if(tendencia == "BAIXA FORTE")
            {
               bool retCancelou = Operacao.negocio.OrderDelete(ticket);   
               if(retCancelou == true) Operacao.numeroContratos = Operacao.numeroContratos - tamanho; 
             //  Print("Cancelou ordem de compra aberta por tendência de baixa.");
            }
         }
         else
         {
            //SE FOR ALTA
            if(tendencia == "ALTA FORTE")
            {
               bool retCancelou = Operacao.negocio.OrderDelete(ticket);   
               if(retCancelou == true) Operacao.numeroContratos = Operacao.numeroContratos - tamanho; 
             //  Print("Cancelou ordem de venda aberta por tendência de alta.");
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 2.4 - FUNCAO QUE ATUALIZA E EXECUTA OS SLOTS DISPONVEIS DE ORDENS|
//+------------------------------------------------------------------+
void ExecutaSlotsDisponiveis()
{
   //Avanca os status dos slots
   for(int i=0; i<Fluidos.niveis; i++)
   {
      Fluidos.iSlot = i;
      
      //C
      TrocaMarcha(Operacao, Fluidos, SlotsC);
      
      if(SlotsC[i].statusCambio == 1)
      {
         CalculaPrecoOrdem(Operacao, Fluidos, SlotsC, ArrayTick, ArrayBook);
         CalculaQuantidade(Fluidos, SlotsC);
      }
      
      if(Fluidos.LC == true) ExecutaSlotsCompra(Operacao, Fluidos, SlotsC, ArrayTick, i);
      
      //V
      TrocaMarcha(Operacao, Fluidos, SlotsV); 
      
      if(SlotsV[i].statusCambio == 1)
      {
         CalculaPrecoOrdem(Operacao, Fluidos, SlotsV, ArrayTick, ArrayBook);
         CalculaQuantidade(Fluidos, SlotsV); 
      }
      
      if(Fluidos.LV == true) ExecutaSlotsVenda(Operacao, Fluidos, SlotsV, ArrayTick, i);
   }
}

//+------------------------------------------------------------------+
//| 2.5 - FUNCAO QUE VARRE SLOTS DE COMPRA E ENVIA ORDENS            |
//+------------------------------------------------------------------+
void ExecutaSlotsCompra(operacao &Operacao, fluido &Fluidos, slot &SlotsC[], MqlTick &ArrayTick[], int i)
{    
   //Print("status motor: ",SlotsC[i].statusMotor);
   switch(SlotsC[i].statusMotor)
   {
      case 1 : 
         if(VerificaRiscosNivel2C(Operacao, Fluidos) == true) break;
          
         if(SlotsC[i].precoEnvio < ArrayTick[0].last)
         {
            CompraLimite(Operacao, SlotsC, i);
           // Print("Mandou ordem de compra limite.");
           
            if(Operacao.result.retcode == 10009)
            {
               //SlotsC[i].idOrdem = Operacao.result.order;
               OrderSelect(SlotsC[i].idOrdem);
               TimeToStruct(TimeCurrent(),SlotsC[i].cronometro);
            }
            else 
            {
               SlotsC[i].statusCambio = 0;
               SlotsC[i].statusMotor = 0;
            }
         }
         break;
      case 3 :
         CancelaOrdemAberta(Operacao, SlotsC[i].idOrdem);
        // Print("Cancelou ordem de compra limite.");
         break;        
      default : 
         break;
   }  
}

//+------------------------------------------------------------------+
//| 2.6 - FUNCAO QUE VARRE SLOTS DE VENDA E ENVIA ORDENS             |
//+------------------------------------------------------------------+
void ExecutaSlotsVenda(operacao &Operacao, fluido &Fluidos, slot &SlotsV[], MqlTick &ArrayTick[], int i)
{  
   //Print("status motor: ",SlotsV[i].statusMotor);
   switch(SlotsV[i].statusMotor)
   {
      case 1 : 
         if(VerificaRiscosNivel2V(Operacao, Fluidos) == true)  break;
         
         if(SlotsV[i].precoEnvio > ArrayTick[0].last)
         {
            VendaLimite(Operacao, SlotsV, i);
          //  Print("Mandou ordem de venda limite.");
            
            if(Operacao.result.retcode == 10009)
            {
               //Avanca o status do slot para enviado
               //SlotsV[i].idOrdem = Operacao.result.order;
               OrderSelect(SlotsV[i].idOrdem);
               TimeToStruct(TimeCurrent(), SlotsV[i].cronometro);
            }
            else
            {
               SlotsV[i].statusCambio = 0;
               SlotsV[i].statusMotor = 0;
            }
         }
         break;
      case 3 :
         CancelaOrdemAberta(Operacao, SlotsV[i].idOrdem);
       //  Print("Cancelou ordem de compra limite.");
         break;       
      default : 
         break;
   }  
}

//+------------------------------------------------------------------+
//| 2.7 - FUNCAO QUE CALCULA O TEMPO LIMITE DE EXPIRACAO DE POSICAO C|
//+------------------------------------------------------------------+
int CalculaTempoExpiraPosicaoCompra(operacao &Operacao, fluido &Fluidos, int depth)
{
   int tempo = 0;
   //int c = 1;
   
   tempo = Fluidos.ft * (depth * Fluidos.KV) / Fluidos.lambdaC;
   
   return tempo;
}

//+------------------------------------------------------------------+
//| 2.8 - FUNCAO QUE CALCULA O TEMPO LIMITE DE EXPIRACAO DE POSICAO V|
//+------------------------------------------------------------------+
int CalculaTempoExpiraPosicaoVenda(operacao &Operacao, fluido &Fluidos, int depth)
{
   int tempo = 0;
   //int c = 1;
   
   tempo = Fluidos.ft * (depth * Fluidos.KC) / Fluidos.lambdaV;
   
   return tempo;
}

//+------------------------------------------------------------------+
//| 2.9 - FUNCAO QUE CALCULA O TEMPO LIMITE DE EXPIRACAO DE ORDEM C  |
//+------------------------------------------------------------------+
int CalculaTempoExpiraOrdemCompra(operacao &Operacao, fluido &Fluidos, int depth)
{
   int tempo = 0;
   int c = 1;
   
   //tempo = c * (depth * Fluidos.KC) / Fluidos.lambdaV;
   tempo = 60;
   return tempo;
}

//+------------------------------------------------------------------+
//| 2.10 - FUNCAO QUE CALCULA O TEMPO LIMITE DE EXPIRACAO DE ORDEM V |
//+------------------------------------------------------------------+
int CalculaTempoExpiraOrdemVenda(operacao &Operacao, fluido &Fluidos, int depth)
{
   int tempo = 0;
   int c = 1;
   
   tempo = c * (depth * Fluidos.KV) / Fluidos.lambdaC;
   tempo = 60;
   return tempo;
}

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