//+------------------------------------------------------------------+
//|                                              S1_Ignicao_v4_3.mq5 |
//|                                                           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   "PROD_v4_3"
#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_3.mqh"
#include "S2_Motor_v4_3.mqh"
#include "S3_Freios_v4_3.mqh"
#include "S4_Cambio_v4_3.mqh"
#include "S5_Direcao_v4_3.mqh"
#include "S6_Transmissao_v4_3.mqh"

//+------------------------------------------------------------------+
//| 0.2 - ENTRADAS DE USUARIO                                        |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| 0.2.1 - INPUTS DE GERENCIAMENTO DE RISCOS                        |
//+------------------------------------------------------------------+
input group          "Gerenciamento de Capital------------------|---------------------------------------------------------------"
input double         saldoInicial = 4000;                      //X(0) R$: Saldo inicial do dia; CHescalona = F
input double         alvoFinanceiro = 800.0;                   //sup[X] R$: Alvo financeiro no dia; CHescalona = F
input double         stopFinanceiro = -400.0;                  //inf[X] R$: Stop financeiro no dia; CHescalona = F
input double         alvoPercentual = 0.30;                    //sup[X(t)] %: alvo 0.05 = 5%; CHescalona = T; inf < dX < 0.30
input double         stopPercentual = 0.10;                    //inf[X(t)] %: stop 0.05 = 5%; CHescalona = T; -0.1 < dX < sup

//+------------------------------------------------------------------+
//| 0.2.2 - INPUTS DE GERENCIAMENTO DE INVENTARIO                    |
//+------------------------------------------------------------------+
input group          "Gerenciamento de Inventário---------------|---------------------------------------------------------------"
input int            niveis = 4;                               //η: Níveis máximos η, CHescalona = F; -ηr < q < ηr
input int            rajada = 1;                               //r: Quantidade por ordem r, se Cescalona = F; -ηr < q < ηr

//+------------------------------------------------------------------+
//| 0.2.3 - INPUTS DE GERENCIAMENTO DE TEMPO                         |
//+------------------------------------------------------------------+
input group          "Gerenciamento de Tempo--------------------|---------------------------------------------------------------"
input ushort         horarioShort_inicial = 545;               //inf[t] min: Horário inicial 09:05 = 545; 545 < t < sup[t]
input ushort         horarioShort_final = 980;                 //sup[t] min: Horário final 16:20 = 980; inf[t] < t < 980 
input ushort         horarioShort_fechamento = 983;            //ta min: Horário limite de after 16:23 = 983; sup[t] < ta < 983

//+------------------------------------------------------------------+
//| 0.2.4 - INPUTS DE GERENCIAMENTO DE RISCOS                        |
//+------------------------------------------------------------------+
input group          "Gerenciamento de Riscos-------------------|---------------------------------------------------------------"
input double         limiteSupDesvioCurto = 100;               //sup[σ] pontos: Supremo de VolC;CHRiscoTend = T inf[σ] < σ < 290
input double         fatorStop = 3;                            //fSL: Fator multiplicativo do stoploss da ordem
input double         passoFi = 10;                             //fφ(0); Fator de passo do fi; CHfiAuto = T
input double         fi = 0.0002;                              //φ(0): Running Penalty (aversao a risco); CHfiAuto = F
input double         gama = 1.0;                               //γ: Fator multiplicativo gama, influencia no q * desvio
input double         offsetStartTrailingC = 60.0;              //δATSstartC pontos: Start= #pts para iniciar o trailing
input double         offsetStartTrailingV = 60.0;              //δATSstartV pontos: Start= #pts para iniciar o trailing
input double         offsetStopTrailingC = 20.0;               //inf[δA]TSstopC: pontos entre o precoMax e o sl; inf[δCA]<δCA
input double         offsetStopTrailingV = 20.0;               //inf[δA]TSstopV: pontos entre o precoMax e o sl; inf[δVA]<δVA

//+------------------------------------------------------------------+
//| 0.2.5 - INPUTS DE GERENCIAMENTO DE ESTRATEGIA                    |
//+------------------------------------------------------------------+
input group          "Gerenciamento de Estratégia---------------|---------------------------------------------------------------"
input double         custoOperacao = 1.24;                     //ζ R$: Custo por operacao ζ {1.20} [0.0, 2.0[
input int            intervaloTicks = 1000;                    //i: Intervalo de ticks i do ArrayTick
input int            periodoSTDDEVLongo = 100;                 //nσ: Periodo do Desvio Padrao Longo {100}
input int            periodoSTDDEVCurto = 10;                  //nσ: Periodo do Desvio Padrao Curto {100}
input int            profundidadeBook = 5;                     //β: Profundidade do book a calcular o k {5}[1, +inf[
input int            n = 5;                                    //n: Índice da potencia do spread
input int            fatorHedge = 10;                          //fH: Fator de spread alvo do hedge
input int            refreshOrdem = 60;                        //τOr seg: Tempo em seg da duracao de uma ordem pendente
input int            refreshPosicao = 60;                      //τPr seg: Tempo em seg do refresh de uma posicao
input int            expiraOrdem = 60;                         //TOe seg: Tempo em seg de expiracao de uma ordem pendente
input int            expiraPosicao = 500;                      //TPe seg: Tempo em seg de expiracao de uma posicao
input int            spreadOffsetEnvioLado = 15;               //δEo pontos: Spread Offset do Envio da tendencia de lado
input int            spreadOffsetEnvioLeve = 25;               //δEo pontos: Spread Offset do Envio da tendencia leve
input int            spreadOffsetAlvoLado = 15;                //δAo pontos: Spread Offset do Alvo da tendencia de lado
input int            spreadOffsetAlvoLeve = 25;                //δAo pontos: Spread Offset do Alvo da tendencia leve
input double         corteImbalance = 0.40;                    //fZ: Offset do corte do regime Z do imbalance p
input int            fatorLambdaBacktest = 1;                  //fλ: Fator de multiplicacao Lambda
input double         fatorTempo = 1;                           //fator de tempo do expira posicao
//+------------------------------------------------------------------+
//| 0.2.6 - INPUTS DE GERENCIAMENTO DE OPERACOES                     |
//+------------------------------------------------------------------+
input group          "Gerenciamento de Operações----------------|---------------------------------------------------------------"
input bool           chaveEscalonador = true;                  //Chave on/off do escalonador de saldo, alvo, stop do dia {true}
input bool           chaveRiscoSaldo = true;                   //Chave on/off do risco saldo {true}
input bool           chaveRiscoVolCurto = true;                //Chave on/off do risco de volatilidade curta {true}
input bool           chaveTrailing = true;                     //Chave on/off do trailing stop {true}
input bool           chaveTempoExpiraAutomatico = true;        //Chave on/off do tempo expira posicao automatico {true} 
input bool           chaveLambda = false;                      //Chave on/off do lambda {false}
input bool           chaveLambdaBacktest = true;               //Chave on/off do lambda backtest {true}
input bool           chaveBook = false;                        //Chave on/off do book {false}
input bool           chaveBookBacktest = false;                //Chave on/off do book backtest {false}
input bool           chaveFiAutomatico = false;                //Chave on/off do fi Automatico {false}
input bool           chaveGama = true;                         //Chave on/off do gama {true}
input bool           chaveDeinitOrdens = false;                //Chave on/off do cancelamento de ordens no Deinit {false}
input bool           chaveDeinitPosicoes = false;              //Chave on/off do fechamento de posicoes no Deinit {false}

//+------------------------------------------------------------------+
//| 0.3 - VARIAVEIS GLOBAIS                                          |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| 0.3.1 - OBJETOS   OPERACIONAIS                                   |
//+------------------------------------------------------------------+
operacao             Operacao;
fluido               Fluidos;
slot                 SlotsC[];
slot                 SlotsV[];
MqlTick              ArrayTick[];
MqlBookInfo          ArrayBook[];
CMarketBook          Book(_Symbol);

//+===================================================================================================================================================================================+
//| 1 - SESSAO DE DAR A PARTIDA E CONTROLA EVENTOS / IGNICAO                                                                                                                            
//+===================================================================================================================================================================================+
//+------------------------------------------------------------------+
//| 1.1 - FUNCAO DE INICIALIZACAO                                    |
//+------------------------------------------------------------------+
int OnInit()
{
   Print("DESENVOLVIMENTO v4.3 melhorado");
   
   //Inicializao basica
   Fluidos.q = 0;
   Fluidos.t = 0;
   Fluidos.TOr = refreshOrdem;
   Fluidos.TPr = refreshPosicao;
   Fluidos.TOe = expiraOrdem;
   Fluidos.TPe = expiraPosicao;
   Fluidos.t0d = horarioShort_inicial;
   Fluidos.td = 0;
   Fluidos.Td = horarioShort_final;
   Fluidos.nBook = profundidadeBook;
   Fluidos.iBid0 = -1;
   Fluidos.iAsk0 = -1;
   Fluidos.iSlot = 0;
   Fluidos.niveis = niveis;
   Fluidos.rajada = rajada;
   Fluidos.handlerMA = -1;
   Fluidos.handlerSTDDEVLongo = -1;
   Fluidos.handlerSTDDEVCurto = -1;
   Fluidos.handlerVolumeReal = -1;
   Fluidos.handlerVolumeNegocios = -1;
   Fluidos.periodoMA = 2;
   Fluidos.periodoSTDDEVLongo = periodoSTDDEVLongo;  
   Fluidos.periodoSTDDEVCurto = periodoSTDDEVCurto; 
   Fluidos.periodoVolume = 10;   
   Fluidos.intervaloTicks = intervaloTicks;
   Fluidos.media = -1;
   Fluidos.midPrice = -1;
   Fluidos.sigmaHFT = -1;
   Fluidos.sigmaLFT = -1;
   Fluidos.assimetria = 0.0;
   Fluidos.curtose = 0.0;
   Fluidos.driftLFTTend = 0.0;
   Fluidos.driftLFTVol = 0.0;
   Fluidos.driftHFTVol = 0.0;
   Fluidos.driftHFTTend = 0.0;
   Fluidos.spreadLFTC = 0.0;
   Fluidos.spreadLFTV = 0.0;
   Fluidos.spreadHFTC = 0.0;
   Fluidos.spreadHFTV = 0.0;
   Fluidos.KC = 100;
   Fluidos.KV = 100;
   Fluidos.lambdaC = 10;
   Fluidos.lambdaV = 10;
   Fluidos.lobC = 0.0;
   Fluidos.lobV = 0.0;
   Fluidos.fi = fi;
   Fluidos.fiInicial = fi;
   Fluidos.passoFi = passoFi;
   Fluidos.c = custoOperacao;
 //  Fluidos.desvioDiario = desvioDiario;
   Fluidos.precoMedioC = 0.0;
   Fluidos.precoMedioV = 0.0;
   Fluidos.tickMin = 5;
   Fluidos.precoAbertura = -1;
   Fluidos.precoOpen = -1;
   Fluidos.precoClose = -1;
   Fluidos.limiteInfTend = -1;
   Fluidos.limiteSupTend = -1;
   Fluidos.limiteInfDesvio = -1;
   Fluidos.limiteSupDesvioCurto = limiteSupDesvioCurto;
   Fluidos.imbalance = 0.0;
   Fluidos.corteImbalance = corteImbalance;
   Fluidos.LC = true;
   Fluidos.LV = true;
   Fluidos.fatorHedge = fatorHedge;
   Fluidos.tendencia = "";
   Fluidos.spreadOffsetEnvioLado = spreadOffsetEnvioLado;
   Fluidos.spreadOffsetEnvioLeve = spreadOffsetEnvioLeve;
   Fluidos.spreadOffsetAlvoLado = spreadOffsetAlvoLado;
   Fluidos.spreadOffsetAlvoLeve = spreadOffsetAlvoLeve;
   Fluidos.gama = 0;
   if(chaveEscalonador == true) Fluidos.rajada = floor(AccountInfoDouble(ACCOUNT_BALANCE)/10000) + 1;
   if(chaveEscalonador == true) Fluidos.niveis = floor(AccountInfoDouble(ACCOUNT_BALANCE)/(Fluidos.rajada*1000));
   if(chaveGama == true) Fluidos.gama = gama;
   Fluidos.Q = Fluidos.rajada * Fluidos.niveis;
   Fluidos.n = n;
   Fluidos.eC = 0.0;
   Fluidos.eV = 0.0;
   Fluidos.fatorLambdaBacktest = fatorLambdaBacktest;
   Fluidos.fatorStop = fatorStop;
   Fluidos.ft = fatorTempo;

   Operacao.chaveEscalonador = chaveEscalonador;
   Operacao.chaveRiscoSaldo = chaveRiscoSaldo;
   Operacao.chaveRiscoVolCurto = chaveRiscoVolCurto;
   Operacao.chaveTrailing = chaveTrailing;
   Operacao.chaveLambda = chaveLambda;
   Operacao.chaveLambdaBacktest = chaveLambdaBacktest;
   Operacao.chaveBook = chaveBook;
   Operacao.chaveBookBacktest = chaveBookBacktest;
   Operacao.chaveFiAutomatico = chaveFiAutomatico;
   Operacao.chaveTempoExpiraVariavel = chaveTempoExpiraAutomatico;
   Operacao.magic = 11111;
   Operacao.diaAtual = 0;
   Operacao.diaAnt = 0;
   Operacao.posicoes_total_prev = 0;
   Operacao.posicoes_total = 0;
   Operacao.normalizeDoubleSize = 0;
   Operacao.horarioShort_atual =0;
   Operacao.horarioShort_inicial = horarioShort_inicial;
   Operacao.horarioShort_final = horarioShort_final;
   Operacao.horarioShort_fechamento = horarioShort_fechamento;
   Operacao.countSaldo = 0;
   Operacao.countFechaDia = 0;
   Operacao.saldoInicialDia = saldoInicial; 
   Operacao.saldoAtualDia = 0.0;
   Operacao.diferencaSaldo = 0.0;
   Operacao.alvoFinanceiro = alvoFinanceiro;
   if(stopFinanceiro > 0) Operacao.stopFinanceiro = -1*stopFinanceiro;
   else Operacao.stopFinanceiro = stopFinanceiro;
   Operacao.alvoPercentual = alvoPercentual;
   Operacao.stopPercentual = stopPercentual;
   Operacao.stopFinanceiro = stopFinanceiro;
   Operacao.handlerNormalizeDoubleSize = "";
   Operacao.expiraPosicao = expiraPosicao;
   Operacao.saldoInicialDia = saldoInicial;
   Operacao.numeroContratos = 0;
   Operacao.offsetStartTrailingC = offsetStartTrailingC;
   Operacao.offsetStopTrailingC = offsetStopTrailingC;
   Operacao.offsetStartTrailingV = offsetStartTrailingC;
   Operacao.offsetStopTrailingV = offsetStopTrailingC;
   
   //Inicializa a contagem de dias
   TimeToStruct(TimeCurrent(), Operacao.horarioMQL_atual);
   Operacao.diaAtual = Operacao.horarioMQL_atual.day;
   
   //Inicializa o MarketBook
   if(Operacao.chaveBook == true) if(!MarketBookAdd(_Symbol)) Print("Falha para inicializar o book");
   
   ArrayResize(ArrayTick, Fluidos.intervaloTicks, 0);
   
   //Inicializa o ArrayTick
   if(CopyTicks(_Symbol, ArrayTick, COPY_TICKS_ALL, 0, Fluidos.intervaloTicks) != -1) 
   {
      ArraySetAsSeries(ArrayTick, true);
   }
   else Print("Falha para inicializar o ArrayTicks: ", GetLastError());

   //NormalizeDouble
   Operacao.handlerNormalizeDoubleSize = DoubleToString(Fluidos.tickMin);
   Operacao.handlerNormalizeDoubleSize = StringReplace(Operacao.handlerNormalizeDoubleSize,".","");
   Operacao.normalizeDoubleSize = (StringLen(Operacao.handlerNormalizeDoubleSize))-1;
   
   //Ajusta o tamanho dos arrays de slots de compra e venda
   ArrayResize(SlotsC, Fluidos.niveis);
   ArrayResize(SlotsV, Fluidos.niveis);
   
   //Inicializa os slots de compra e venda
   for(int i=0; i<Fluidos.niveis ;i++)
   {
      SlotsC[i].statusCambio = 0;
      SlotsC[i].statusMotor = 0;
      SlotsV[i].statusCambio = 0;
      SlotsV[i].statusMotor = 0;
      SlotsC[i].ponta = 0;
      SlotsV[i].ponta = 2;
   }
   
   //Cria os buffers dos indicadores de media e desvio padrao
   Fluidos.handlerMA = iMA(_Symbol, PERIOD_M1, Fluidos.periodoMA, 0, MODE_EMA, PRICE_MEDIAN);
   Fluidos.handlerSTDDEVLongo = iStdDev(_Symbol, PERIOD_M1, Fluidos.periodoSTDDEVLongo, 0, MODE_EMA, PRICE_MEDIAN);
   Fluidos.handlerSTDDEVCurto = iStdDev(_Symbol, PERIOD_M1, Fluidos.periodoSTDDEVCurto, 0, MODE_EMA, PRICE_MEDIAN);
   Fluidos.handlerVolumeReal = iVolumes(_Symbol, PERIOD_M1, VOLUME_REAL);
   Fluidos.handlerVolumeNegocios = iVolumes(_Symbol, PERIOD_M1, VOLUME_TICK);
   ArraySetAsSeries(Fluidos.MA, true);
   ArraySetAsSeries(Fluidos.STDDEVLONGO, true);
   ArraySetAsSeries(Fluidos.STDDEVCURTO, true);
   ArraySetAsSeries(Fluidos.VOLUMEREAL, true);
   ArraySetAsSeries(Fluidos.VOLUMENEGOCIOS, true);
   CopyBuffer(Fluidos.handlerMA, 0, 1, 2, Fluidos.MA);
   CopyBuffer(Fluidos.handlerSTDDEVLongo, 0, 1, 2, Fluidos.STDDEVLONGO);
   CopyBuffer(Fluidos.handlerSTDDEVCurto, 0, 1, 2, Fluidos.STDDEVCURTO);
   CopyBuffer(Fluidos.handlerVolumeReal, 0, 1, 2, Fluidos.VOLUMEREAL);
   CopyBuffer(Fluidos.handlerVolumeNegocios, 0, 1, 2, Fluidos.VOLUMENEGOCIOS);
   Fluidos.precoOpen = iOpen(_Symbol, PERIOD_M1, 0);
   Fluidos.precoClose = iClose(_Symbol, PERIOD_M1, 0);
   Fluidos.media = Fluidos.MA[0];
   Fluidos.sigmaLFT = MathAbs(Fluidos.STDDEVLONGO[0]);
   Fluidos.sigmaHFT = MathAbs(Fluidos.STDDEVCURTO[0]);
   Fluidos.volumeReal = Fluidos.VOLUMEREAL[0];
   Fluidos.volumeNegocios = Fluidos.VOLUMENEGOCIOS[0];
   Fluidos.driftLFTTend = Fluidos.MA[0] - Fluidos.MA[1];
   Fluidos.driftLFTVol = Fluidos.STDDEVLONGO[0] - Fluidos.STDDEVLONGO[1];
     
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| 1.2 - FUNCAO EVENTO TICK / CORACAO                               |
//+------------------------------------------------------------------+
void OnTick()
{  
   //Atualiza os ticks e variaveis
   AtualizaVariaveis();
   
   //Chamar o motor
   if(VerificaHorarioOrdens(Operacao)) FazTrades(Operacao, Fluidos, SlotsC, SlotsV, ArrayTick, ArrayBook);
   else if(VerificaHorarioFechamento(Operacao))
   {
      if(Operacao.countFechaDia == 0)
      {
         FechaPosicoes(Operacao);
         Print("Mandou fechar todas as posicoes por fechamento de dia.");
         CancelaOrdensAbertas(Operacao);
         Print("Mandou cancelar todas as ordens abertas por fechamento de dia.");
         ArrayFree(SlotsC);
         ArrayFree(SlotsV);
         ArrayResize(SlotsC, Fluidos.niveis);
         ArrayResize(SlotsV, Fluidos.niveis);
      
         for(int i=0;i<ArraySize(SlotsC);i++)
         {
            SlotsC[i].statusCambio = 0;
            SlotsC[i].statusMotor = 0;
            SlotsV[i].statusCambio = 0;
            SlotsV[i].statusMotor = 0;
         }
      
         if((PositionsTotal() + OrdersTotal()) == 0) Operacao.countFechaDia = 1;
      }
   }
   else return;
   
   return;
}

//+------------------------------------------------------------------+
//| 1.3 - FUNCAO QUE ATUALIZA AS VARIAVEIS IMPORTANTES               |
//+------------------------------------------------------------------+
void AtualizaVariaveis()
{
   Operacao.diaAtual = Operacao.horarioMQL_atual.day;
   //PRIMEIRO TICK DO DIA
   if(Operacao.diaAtual != Operacao.diaAnt)
   {
      Operacao.countSaldo = 0;
      Operacao.diaAnt = Operacao.diaAtual;

      if(Operacao.countSaldo == 0)
      {
         Operacao.saldoInicialDia = AccountInfoDouble(ACCOUNT_BALANCE);
         Operacao.alvoFinanceiro = Operacao.saldoInicialDia * Operacao.alvoPercentual;
         
         if(stopPercentual > 0) Operacao.stopFinanceiro = Operacao.saldoInicialDia * -1 * Operacao.stopPercentual;
         else Operacao.stopFinanceiro = Operacao.saldoInicialDia * Operacao.stopPercentual;
         
         Operacao.countSaldo = 1;
         Operacao.countFechaDia = 0;
      }
      
      //ZERA OS SLOTS DE COMPRA E VENDA
      for(int i=0;i<Fluidos.niveis;i++)
      {
         SlotsC[i].statusCambio = 0;
         SlotsC[i].statusMotor = 0;
         SlotsV[i].statusCambio = 0;
         SlotsV[i].statusMotor = 0;
      }
   }
   
   //Atualiza saldoInicialDia no backtest
   if(Operacao.chaveEscalonador == true)
   {
      //Atualiza as rajadas e niveis de acordo com o novo saldo
      Fluidos.rajada = floor(AccountInfoDouble(ACCOUNT_BALANCE)/10000) + 1;
      Fluidos.niveis = floor(AccountInfoDouble(ACCOUNT_BALANCE)/(Fluidos.rajada*1000));
      Fluidos.Q = Fluidos.rajada * Fluidos.niveis;
      ArrayResize(SlotsC, Fluidos.niveis);
      ArrayResize(SlotsV, Fluidos.niveis);
   }
   
   Fluidos.precoAbertura = iOpen(_Symbol, PERIOD_D1, 0);
   Fluidos.precoOpen = iOpen(_Symbol, PERIOD_M1, 0);
   Fluidos.precoClose = iClose(_Symbol, PERIOD_M1, 0);
   
   //Atualiza o horario
   TimeToStruct(TimeCurrent(), Operacao.horarioMQL_atual);
   
   //Atualiza o book
   if(!Operacao.simbolo.RefreshRates()) return;

   if(Operacao.chaveBook == true)
   {
      if(MarketBookGet(_Symbol, ArrayBook))
      {
         //Atualiza os indices do topo do book
         Fluidos.iBid0 = Book.InfoGetInteger(MBOOK_BEST_BID_INDEX);
         Fluidos.iAsk0 = Book.InfoGetInteger(MBOOK_BEST_ASK_INDEX);
      }
      else
      {
         Print("Falha ao atualizar o Book");
      }
   }
   
   ArrayResize(ArrayTick, Fluidos.intervaloTicks, 0);
   //Atualiza os ticks
   if(CopyTicks(Symbol(), ArrayTick,COPY_TICKS_ALL, 0, Fluidos.intervaloTicks) != -1) ArraySetAsSeries(ArrayTick, true);
   else Print("Falha para inicializar o ArrayTicks: ", GetLastError());   

   
   //Atualiza os buffers de media e desvio padrao
   CopyBuffer(Fluidos.handlerMA, 0 ,1, 2, Fluidos.MA);
   CopyBuffer(Fluidos.handlerSTDDEVLongo, 0, 1, 2, Fluidos.STDDEVLONGO);
   CopyBuffer(Fluidos.handlerSTDDEVCurto, 0, 1, 2, Fluidos.STDDEVCURTO);
   CopyBuffer(Fluidos.handlerVolumeReal, 0, 1, 2, Fluidos.VOLUMEREAL);
   CopyBuffer(Fluidos.handlerVolumeNegocios, 0, 1, 2, Fluidos.VOLUMENEGOCIOS);
   Fluidos.midPrice = (Operacao.simbolo.Ask() + Operacao.simbolo.Bid())/2;
   Fluidos.media = Fluidos.MA[0];
   Fluidos.sigmaHFT = MathAbs(Fluidos.STDDEVCURTO[0]);
   Fluidos.sigmaLFT = MathAbs(Fluidos.STDDEVLONGO[0]);
   Fluidos.volumeReal = Fluidos.VOLUMEREAL[0];
   Fluidos.volumeNegocios = Fluidos.VOLUMENEGOCIOS[0];
   Fluidos.driftLFTTend = Fluidos.MA[0] - Fluidos.MA[1];
   Fluidos.driftLFTVol = Fluidos.STDDEVLONGO[0] - Fluidos.STDDEVLONGO[1];
   Fluidos.q = AtualizaQuantidade(Operacao, Fluidos);
   Fluidos.td = Operacao.horarioMQL_atual.hour*60 + Operacao.horarioMQL_atual.min;
   
   for(int i=0; i<Fluidos.niveis ;i++)
   {
      SlotsC[i].ponta = 0;
      SlotsV[i].ponta = 2;
   }
   
   return;
}

//+------------------------------------------------------------------+
//| 1.4 - FUNCAO EVENTO BOOK                                         |
//+------------------------------------------------------------------+
void OnBookEvent(const string &symbol)
{
   if(Operacao.chaveBook == true)
   {
     //Atualiza os melhores indices de bid e ask do book
      if(MarketBookGet(_Symbol, ArrayBook))
      {
         Fluidos.iBid0 = Book.InfoGetInteger(MBOOK_BEST_BID_INDEX);
         Fluidos.iAsk0 = Book.InfoGetInteger(MBOOK_BEST_ASK_INDEX);
      }
      else
      {
         Print("Falha ao obter o Book");
      } 
   }
   
   return;
}

//+------------------------------------------------------------------+
//| 1.5 - FUNCAO EVENTO TRADE                                        |
//+------------------------------------------------------------------+
void OnTrade()
{

}

//+------------------------------------------------------------------+
//| 1.6 - FUNCAO DE DESLIGAMENTO                                     |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   //Da release nos indicadores
   IndicatorRelease(Fluidos.handlerMA);
   IndicatorRelease(Fluidos.handlerSTDDEVLongo);
   IndicatorRelease(Fluidos.handlerSTDDEVCurto);
   if(chaveDeinitOrdens == true)
   {
      CancelaOrdensAbertas(Operacao);
   }
   if(chaveDeinitPosicoes == true)
   {
      FechaPosicoes(Operacao);
   }
   Print("Numero de contratos executados: ", Operacao.numeroContratos);
   Print("OUTPUT PATH=",TerminalInfoString(TERMINAL_DATA_PATH));
   
   //Falha na desinicializacao
   printf("Deinit reason: %d", reason);
}

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