WebSVN - Integrator Subversion - Diff - Rev 767 and 771 - /projeto-trade/stocklifepro/src/main/java/br/com/kronus/core/DetectorGatilhos.java

 package br.com.kronus.core;
-import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.List;
 import br.com.sl.domain.model.Candle;
 import br.com.sl.domain.util.BigDecimalUtils;
 /**
  * Detector de padrões de gatilhos (GR, G1, G2, G3, G4)
  * trabalhando tanto em modo backtest quanto em modo tempo real.
+ *
- * Regras resumidas:
+ * Regras implementadas (texto alinhado):
+ *
- * GR comprador (A):
- *   - Candle comprador.
- *   - Último candle da tendência compradora.
- *   - Maior topo da pernada compradora.
- *   - Após ele, tendência muda para vendedora.
- *   - Um vendedor subsequente rompe o fundo de A => G1 vendedor, A vira GR.
+ * COMPRADOR
+ * ---------
+ * 1) Candle A comprador, candidato à referência.
+ *    - Após A deve haver mudança de tendência (B).
+ *    - A deve ser o último da tendência compradora:
+ *      o primeiro candle direcional após A (ignorando inside/neutros)
+ *      deve ser vendedor (B). Se for comprador, descarta A.
+ *
- * GR vendedor (B):
- *   - Candle vendedor.
- *   - Último candle da tendência vendedora.
- *   - Menor fundo da pernada vendedora.
- *   - Após ele, tendência muda para compradora.
- *   - Um comprador subsequente rompe o topo de B => G1 comprador, B vira GR.
+ * 2) Ajuste da referência com B:
+ *    - Se B (vendedor) tiver TOPO maior que o topo de A,
+ *      B passa a ser o candidato à referência.
+ *      Senão, A permanece como candidato.
+ *
- * G2 comprador (a partir de GR comprador):
- *   - Após G1 (vendedor), surge nova tendência compradora.
- *   - O ÚLTIMO candle dessa tendência compradora tem fechamento dentro da região do GR.
- *   - Se nessa tendência compradora alguma barra romper o topo do GR, o padrão é descartado.
- *   - Se a tendência terminar sem que o último comprador feche dentro da região do GR, descarta.
+ * 3) G1:
+ *    - A partir do candidato à referência, o primeiro candle vendedor
+ *      subsequente que romper o FUNDO do candidato (mínima < mínima do candidato)
+ *      será o G1. O candidato torna-se o GR.
+ *
- * G3 comprador:
- *   - Após G2, o próximo candle deve ser vendedor.
- *   - Em uma sequência vendedora, algum vendedor:
- *       * rompe o fundo de G2 (mínima < mínima de G2) e
- *       * tem topo <= topo do GR
- *     => esse candle é G3.
+ * 4) G2:
+ *    - Após o G1, assim que houver nova mudança de tendência para compradora:
+ *      * encontrar o primeiro comprador após G1 (ignorando inside/neutros);
+ *      * seguir a sequência compradora até aparecer vendedor.
+ *      * durante essa sequência:
+ *          - se houver OUTSIDE (atual rompe topo e fundo do anterior) => descarta.
+ *          - se ALGUM candle romper o TOPO do GR (máxima > máxima GR) => descarta.
+ *      * o ÚLTIMO candle dessa tendência compradora deve ter o fechamento
+ *        dentro da região total do GR (mínimaGR <= fechamento <= máximaGR).
+ *      * se virar vendedor sem atingir a região do GR => descarta.
+ *      * caso válido, esse último comprador é o G2.
+ *
- * G4 comprador:
- *   - Próximo candle após G3.
- *   - Se romper o topo do GR (máxima > máxima do GR) => G4.
- *   - Desarma a operação, padrão é encerrado, nova análise começa após esse candle.
+ * 5) G3:
+ *    - Após o G2, o PRÓXIMO candle direcional deve ser vendedor.
+ *      se for comprador => padrão apenas até G2 (parcial).
+ *    - numa sequência vendedora:
+ *      * se houver OUTSIDE => descarta.
+ *      * se algum candle vendedor romper o fundo de G2 (mínima < mínima G2)
+ *        e tiver topo <= topo do GR => G3.
+ *      * se surgir candle que rompa o TOPO do GR (máxima > máximaGR) ANTES do G3,
+ *        o padrão é descartado.
+ *
- * G2 vendedor (a partir de GR vendedor):
- *   - Após G1 (comprador), surge nova tendência vendedora.
- *   - O ÚLTIMO candle dessa tendência vendedora tem fechamento dentro da região do GR.
- *   - Se nessa tendência vendedora alguma barra romper o fundo do GR, o padrão é descartado.
+ * 6) G4:
+ *    - Após o G3, se o PRÓXIMO candle romper o topo do GR (máxima > máximaGR),
+ *      será o G4. Depois disso, o padrão é encerrado e um novo padrão é buscado.
+ *
- * G3 vendedor:
- *   - Após G2, o próximo candle deve ser comprador.
- *   - Em uma sequência compradora, algum comprador:
- *       * rompe o topo de G2 (máxima > máxima de G2) e
- *       * tem fundo >= fundo do GR
- *     => esse candle é G3.
+ * VENDEDOR
+ * --------
+ * 1) Candle A vendedor, candidato à referência.
+ *    - Após A deve haver mudança de tendência (B).
+ *    - A deve ser o último da tendência vendedora:
+ *      o primeiro candle direcional após A (ignorando inside/neutros)
+ *      deve ser comprador (B). Se for vendedor, descarta A.
+ *
- * G4 vendedor:
- *   - Próximo candle após G3.
- *   - Se romper o fundo do GR (mínima < mínima do GR) => G4.
+ * 2) Ajuste da referência com B:
+ *    - Se B (comprador) tiver FUNDO mais baixo (mínima menor) que o fundo de A,
+ *      B passa a ser candidato à referência.
+ *      Senão, A permanece como candidato.
+ *
- * Outside em relação ao GR:
- *   - Qualquer candle C após o GR que:
- *       * C.maxima > GR.maxima E
- *       * C.minima < GR.minima
- *     => padrão atual é descartado, nova análise começa após C.
+ * 3) G1:
+ *    - A partir do candidato à referência, o primeiro candle comprador
+ *      subsequente que romper o TOPO do candidato (máxima > máxima do candidato)
+ *      será o G1. O candidato torna-se o GR.
+ *
- * Obs.: Quando um ciclo termina (padrão encontrado ou descartado),
- * a próxima análise SEMPRE começa após o último candle usado.
+ * 4) G2:
+ *    - Após o G1, nova mudança para tendência vendedora:
+ *      * encontrar o primeiro vendedor após G1 (ignorando inside/neutros);
+ *      * seguir a sequência vendedora até aparecer comprador.
+ *      * durante essa sequência:
+ *          - se houver OUTSIDE => descarta.
+ *          - se algum candle romper o FUNDO do GR (mínima < mínimaGR) => descarta.
+ *      * o ÚLTIMO candle dessa tendência vendedora deve ter o fechamento
+ *        dentro da região total do GR (mínimaGR <= fechamento <= máximaGR).
+ *      * se virar comprador sem atingir a região do GR => descarta.
+ *      * caso válido, esse último vendedor é o G2.
+ *
+ * 5) G3:
+ *    - Após o G2, o PRÓXIMO candle direcional deve ser comprador.
+ *      se for vendedor => padrão apenas até G2 (parcial).
+ *    - numa sequência compradora:
+ *      * se houver OUTSIDE => descarta.
+ *      * se algum candle comprador romper o topo de G2 (máxima > máxima G2)
+ *        e tiver fundo >= fundo do GR => G3.
+ *      * se algum candle romper o FUNDO do GR (mínima < mínimaGR)
+ *        ANTES do G3 => descarta.
+ *
+ * 6) G4:
+ *    - Após o G3, se o PRÓXIMO candle romper o fundo do GR (mínima < mínimaGR),
+ *      será o G4. Depois disso, o padrão é encerrado e um novo padrão é buscado.
+ *
+ * OUTSIDE (ambos os lados):
+ *    - Candle cuja máxima > máxima do candle anterior E mínima < mínima do candle anterior.
+ *    - Se houver um outside antes de identificar o G3, o padrão é descartado.
  */
 public class DetectorGatilhos {
     private final boolean logAtivo;
-    // Estado apenas para o modo tempo real
     private int idxProximaAnaliseTempoReal = 0;
     public DetectorGatilhos() {
         this(false);
+    }
             System.out.println(msg);
+        }
+    }
     private static class ResultadoPadrao {
-        PadraoGatilho padrao; // pode ser null (quando não houve padrão válido)
-        int lastIndex;        // último índice de candle usado no ciclo
+        PadraoGatilho padrao;
+        int lastIndex;
         ResultadoPadrao(PadraoGatilho padrao, int lastIndex) {
             this.padrao = padrao;
             this.lastIndex = lastIndex;
+        }
+    }
-    /**
-     * Cria um resultado com padrão PARCIAL (até G2).
-     * Usado quando GR, G1 e G2 são válidos, mas G3 não se forma.
-     */
     private ResultadoPadrao criarResultadoParcialComG2(Candle ref,
                                                        Candle g1,
                                                        Candle g2,
                                                        int lastIndex) {
         PadraoGatilho padrao = new PadraoGatilho();
         padrao.setGatilho4(null);
         return new ResultadoPadrao(padrao, lastIndex);
+    }
     // =====================================================================
-    // API PRINCIPAL – BACKTEST (lista completa de candles)
+    // API PRINCIPAL – BACKTEST
     // =====================================================================
     public List<PadraoGatilho> identificarPadroes(List<Candle> candles) {
         List<PadraoGatilho> padroes = new ArrayList<>();
         int n = candles.size();
-        if (n < 4) {
-            return padroes;
-        }
+        if (n < 4) return padroes;
         int idxRef = 0;
         while (idxRef < n - 3) {
             ResultadoPadrao resultado = detectarPadraoAPartir(candles, idxRef);
             if (resultado == null) {
                 idxRef++;
             if (resultado.padrao != null) {
                 padroes.add(resultado.padrao);
+            }
-            // Próxima análise sempre começa após o último candle usado no ciclo
             idxRef = Math.max(resultado.lastIndex + 1, idxRef + 1);
+        }
         return padroes;
+    }
     private ResultadoPadrao detectarPadraoAPartir(List<Candle> candles, int idxRef) {
         Candle ref = candles.get(idxRef);
         if (ref.isCandleComprador()) {
             return detectarPadraoComprador(candles, idxRef);
         } else if (ref.isCandleVendedor()) {
             return detectarPadraoVendedor(candles, idxRef);
         } else {
-            // candle sem tendência não serve como GR
             return new ResultadoPadrao(null, idxRef);
+        }
+    }
     // =====================================================================
-    // CASO 1 – GR COMPRADOR (candle A)
+    // HELPERS
     // =====================================================================
-    private ResultadoPadrao detectarPadraoComprador(List<Candle> candles, int idxRef) {
-        int n = candles.size();
-        Candle ref = candles.get(idxRef); // candidato a GR
-        int lastIndex = idxRef;
+    private boolean isInside(List<Candle> candles, int idx) {
+        if (idx <= 0) return false;
+        Candle atual = candles.get(idx);
+        Candle anterior = candles.get(idx - 1);
+        return BigDecimalUtils.ehMenorOuIgualQue(atual.getMaxima(), anterior.getMaxima())
+                && BigDecimalUtils.ehMaiorOuIgualQue(atual.getMinima(), anterior.getMinima());
+    }
-        // 0) Validar se idxRef pode ser GR comprador (A)
-        if (!ref.isCandleComprador()) {
-            return new ResultadoPadrao(null, idxRef);
-        }
+    private boolean isOutside(List<Candle> candles, int idx) {
+        if (idx <= 0) return false;
+        Candle atual = candles.get(idx);
+        Candle anterior = candles.get(idx - 1);
+        return BigDecimalUtils.ehMaiorQue(atual.getMaxima(), anterior.getMaxima())
+                && BigDecimalUtils.ehMenorQue(atual.getMinima(), anterior.getMinima());
+    }
-        // 0.1 – início da pernada compradora que termina em A
-        int inicioTrendCompra = idxRef;
-        for (int i = idxRef - 1; i >= 0; i--) {
-            Candle c = candles.get(i);
-            if (!c.isCandleComprador()) {
-                break;
-            }
-            inicioTrendCompra = i;
+    // =====================================================================
+    // CASO 1 – PADRÃO A PARTIR DE CANDLE COMPRADOR
+    // =====================================================================
+    private ResultadoPadrao detectarPadraoComprador(List<Candle> candles, int idxA) {
+        int n = candles.size();
+        int lastIndex = idxA;
+        Candle candleA = candles.get(idxA);
+        if (!candleA.isCandleComprador()) {
+            return new ResultadoPadrao(null, idxA);
+        }
-        // 0.2 – primeiro candle direcional após A
-        int idxPrimeiroDirecionalAposRef = -1;
-        for (int i = idxRef + 1; i < n; i++) {
+        // 1) A deve ser último da tendência compradora -> achar B vendedor
+        int idxB = -1;
+        for (int i = idxA + 1; i < n; i++) {
             Candle c = candles.get(i);
-            if (!c.isCandleComprador() && !c.isCandleVendedor()) {
+            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor())) {
                 continue;
+            }
-            // OUTSIDE em relação ao GR (até G3)
-            if (isOutsideReferencia(ref, c)) {
-                lastIndex = i;
-                log(String.format(
-                        "RefC[%d]: OUTSIDE em [%d] antes da mudança de tendência. Padrão descartado.",
-                        idxRef, i));
-                return new ResultadoPadrao(null, lastIndex);
+            if (c.isCandleComprador()) {
+                // A não é o último comprador
+                return new ResultadoPadrao(null, idxA);
+            }
+            if (c.isCandleVendedor()) {
+                idxB = i;
+                break;
+            }
-            idxPrimeiroDirecionalAposRef = i;
-            break;
+        }
+        if (idxB == -1) return new ResultadoPadrao(null, idxA);
-        if (idxPrimeiroDirecionalAposRef == -1) {
-            return new ResultadoPadrao(null, lastIndex);
-        }
+        Candle candleB = candles.get(idxB);
-        Candle primeiroDirecional = candles.get(idxPrimeiroDirecionalAposRef);
-        if (!primeiroDirecional.isCandleVendedor()) {
-            // primeiro direcional após A ainda é comprador → A não é último da pernada
-            return new ResultadoPadrao(null, idxRef);
+        // 2) Candidato à referência: A ou B (conforme topo)
+        Candle candidatoRef = candleA;
+        int idxCandidatoRef = idxA;
+        if (BigDecimalUtils.ehMaiorQue(candleB.getMaxima(), candleA.getMaxima())) {
+            candidatoRef = candleB;
+            idxCandidatoRef = idxB;
+        }
-        // 0.3 – A tem o maior topo da pernada compradora
-        BigDecimal topoRef = ref.getMaxima();
-        for (int i = inicioTrendCompra; i <= idxRef; i++) {
-            Candle c = candles.get(i);
-            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), topoRef)) {
-                return new ResultadoPadrao(null, idxRef);
-            }
-        }
-        int idxPrimeiroVendedor = idxPrimeiroDirecionalAposRef;
-        // 1) Encontrar G1 (vendedor que rompe o fundo do GR)
+        // 3) G1 – primeiro vendedor que rompe fundo do candidatoRef
+        Candle g1 = null;
         int idxG1 = -1;
-        Candle g1 = null;
-        for (int i = idxPrimeiroVendedor; i < n; i++) {
+        for (int i = idxCandidatoRef + 1; i < n; i++) {
             Candle c = candles.get(i);
-            // OUTSIDE em relação ao GR (até G3)
-            if (isOutsideReferencia(ref, c)) {
-                lastIndex = i;
-                log(String.format(
-                        "RefC[%d]: OUTSIDE em [%d] durante busca de G1. Padrão descartado.",
-                        idxRef, i));
-                return new ResultadoPadrao(null, lastIndex);
+            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor())) {
+                continue;
+            }
             if (!c.isCandleVendedor()) {
-                // tendência vendedora terminou antes do rompimento
                 lastIndex = i - 1;
                 return new ResultadoPadrao(null, lastIndex);
+            }
             lastIndex = i;
-            if (BigDecimalUtils.ehMenorQue(c.getMinima(), ref.getMinima())) {
+            if (BigDecimalUtils.ehMenorQue(c.getMinima(), candidatoRef.getMinima())) {
+                g1 = c;
                 idxG1 = i;
-                g1 = c;
                 break;
+            }
+        }
-        if (idxG1 == -1) {
-            return new ResultadoPadrao(null, lastIndex);
-        }
+        if (g1 == null) return new ResultadoPadrao(null, lastIndex);
+        Candle gr = candidatoRef;
+        int idxGR = idxCandidatoRef;
+        log(String.format("GR comprador em [%d], G1 (vendedor) em [%d]", idxGR, idxG1));
-        log(String.format("RefC[%d] (GR) => G1 (vendedor) em [%d]", idxRef, idxG1));
+        // 4) G2 – nova tendência compradora com fechamento dentro da região do GR
+        Candle g2 = null;
+        int idxG2 = -1;
-        // 2) Encontrar G2 (retorno comprador à região do GR)
         int idxPrimeiroComprador = -1;
         for (int i = idxG1 + 1; i < n; i++) {
             Candle c = candles.get(i);
+            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
+                continue;
-            // OUTSIDE em relação ao GR (até G3)
-            if (isOutsideReferencia(ref, c)) {
-                lastIndex = i;
-                log(String.format(
-                        "RefC[%d]: OUTSIDE em [%d] antes da tendência de G2. Padrão descartado.",
-                        idxRef, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
-            if (!c.isCandleComprador() && !c.isCandleVendedor()) {
-                continue;
-            }
             if (c.isCandleComprador()) {
                 idxPrimeiroComprador = i;
                 break;
             } else {
+                // ainda vendedor
                 lastIndex = i;
+            }
+        }
-        if (idxPrimeiroComprador == -1) {
-            return new ResultadoPadrao(null, lastIndex);
-        }
+        if (idxPrimeiroComprador == -1) return new ResultadoPadrao(null, lastIndex);
-        boolean rompeuTopoRef = false;
-        Candle ultimoCompradorTrend = null;
-        int idxUltimoCompradorTrend = -1;
+        Candle ultimoComprador = null;
+        int idxUltimoComprador = -1;
         for (int i = idxPrimeiroComprador; i < n; i++) {
             Candle c = candles.get(i);
-            // OUTSIDE em relação ao GR (até G3)
-            if (isOutsideReferencia(ref, c)) {
+            // outside antes de G3 descarta
+            if (isOutside(candles, i)) {
                 lastIndex = i;
-                log(String.format(
-                        "RefC[%d]: OUTSIDE em [%d] durante formação de G2. Padrão descartado.",
-                        idxRef, i));
+                log(String.format("GR[%d]: OUTSIDE em [%d] durante formação de G2 (comprador).", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
-            if (!c.isCandleComprador()) {
-                break;
-            }
+            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
+                continue;
-            ultimoCompradorTrend = c;
-            idxUltimoCompradorTrend = i;
-            lastIndex = i;
-            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), ref.getMaxima())) {
-                rompeuTopoRef = true;
+            if (c.isCandleComprador()) {
+                // se romper topo do GR, descarta
+                if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), gr.getMaxima())) {
+                    lastIndex = i;
+                    log(String.format("GR[%d]: candle [%d] rompeu topo do GR durante G2.", idxGR, i));
+                    return new ResultadoPadrao(null, lastIndex);
+                }
+                ultimoComprador = c;
+                idxUltimoComprador = i;
+                lastIndex = i;
+            } else if (c.isCandleVendedor()) {
+                // terminou tendência compradora
+                lastIndex = i - 1;
                 break;
+            }
+        }
-        if (rompeuTopoRef || idxUltimoCompradorTrend == -1) {
-            return new ResultadoPadrao(null, lastIndex);
-        }
+        if (ultimoComprador == null) return new ResultadoPadrao(null, lastIndex);
-        boolean fechamentoDentroRegiaoRef =
-                BigDecimalUtils.ehMaiorOuIgualQue(ultimoCompradorTrend.getFechamento(), ref.getMinima()) &&
-                BigDecimalUtils.ehMenorOuIgualQue(ultimoCompradorTrend.getFechamento(), ref.getMaxima());
+        boolean fechamentoDentroRegiaoGR =
+                BigDecimalUtils.ehMaiorOuIgualQue(ultimoComprador.getFechamento(), gr.getMinima()) &&
+                BigDecimalUtils.ehMenorOuIgualQue(ultimoComprador.getFechamento(), gr.getMaxima());
-        if (!fechamentoDentroRegiaoRef) {
+        if (!fechamentoDentroRegiaoGR) {
             return new ResultadoPadrao(null, lastIndex);
+        }
-        Candle g2 = ultimoCompradorTrend;
-        int idxG2 = idxUltimoCompradorTrend;
-        log(String.format("RefC[%d], G1[%d] => G2 (comprador) em [%d]", idxRef, idxG1, idxG2));
+        g2 = ultimoComprador;
+        idxG2 = idxUltimoComprador;
+        log(String.format("GR[%d], G1[%d] => G2 (comprador) em [%d]", idxGR, idxG1, idxG2));
+        // 5) G3 – próximo direcional vendedor; vendedor que rompe fundo de G2 com topo <= topo GR
+        Candle g3 = null;
+        int idxG3 = -1;
-        // 3) Encontrar G3 (vendedor rompendo fundo de G2, topo <= topo do GR)
         int idxPrimeiroVendedorAposG2 = -1;
         for (int i = idxG2 + 1; i < n; i++) {
             Candle c = candles.get(i);
-            // OUTSIDE em relação ao GR (até G3)
-            if (isOutsideReferencia(ref, c)) {
-                lastIndex = i;
-                log(String.format(
-                        "RefC[%d]: OUTSIDE em [%d] antes da sequência vendedora de G3. Padrão descartado.",
-                        idxRef, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
-            if (!c.isCandleComprador() && !c.isCandleVendedor()) {
+            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
                 continue;
-            }
             if (c.isCandleVendedor()) {
                 idxPrimeiroVendedorAposG2 = i;
                 break;
             } else {
+                // primeiro direcional não é vendedor => padrão só até G2
                 lastIndex = i;
-                // pela sua regra, o próximo após G2 deveria ser vendedor
-                // => padrão chegou até G2, mas não evoluiu corretamente para G3
-                return criarResultadoParcialComG2(ref, g1, g2, lastIndex);
+                return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
+            }
+        }
-        if (idxPrimeiroVendedorAposG2 == -1) {
-            // padrão com GR, G1, G2, mas sem sequência adequada para G3
-            return criarResultadoParcialComG2(ref, g1, g2, lastIndex);
-        }
-        int idxG3 = -1;
-        Candle g3 = null;
+        if (idxPrimeiroVendedorAposG2 == -1)
+            return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
         for (int i = idxPrimeiroVendedorAposG2; i < n; i++) {
             Candle c = candles.get(i);
-            // OUTSIDE em relação ao GR (ATÉ IDENTIFICAR G3)
-            if (isOutsideReferencia(ref, c)) {
+            // outside antes de G3 descarta
+            if (isOutside(candles, i)) {
                 lastIndex = i;
-                log(String.format(
-                        "RefC[%d]: OUTSIDE em [%d] durante formação de G3. Padrão descartado.",
-                        idxRef, i));
+                log(String.format("GR[%d]: OUTSIDE em [%d] durante formação de G3 (vendedor).", idxGR, i));
+                return new ResultadoPadrao(null, lastIndex);
+            }
+            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
+                continue;
+            // se romper topo do GR antes de G3 => descarta
+            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), gr.getMaxima())) {
+                lastIndex = i;
+                log(String.format("GR[%d]: candle [%d] rompeu topo do GR antes de G3.", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
             if (!c.isCandleVendedor()) {
                 lastIndex = i - 1;
                 break;
+            }
             lastIndex = i;
             boolean rompeFundoG2 = BigDecimalUtils.ehMenorQue(c.getMinima(), g2.getMinima());
-            boolean topoMenorOuIgualRef = BigDecimalUtils.ehMenorOuIgualQue(c.getMaxima(), ref.getMaxima());
-            if (rompeFundoG2 && topoMenorOuIgualRef) {
+            boolean topoMenorOuIgualGR = BigDecimalUtils.ehMenorOuIgualQue(c.getMaxima(), gr.getMaxima());
+            if (rompeFundoG2 && topoMenorOuIgualGR) {
+                g3 = c;
                 idxG3 = i;
-                g3 = c;
                 break;
+            }
+        }
-        if (idxG3 == -1 || g3 == null) {
-            // Chegou até G2 mas não encontrou G3
-            return criarResultadoParcialComG2(ref, g1, g2, lastIndex);
-        }
+        if (g3 == null)
+            return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
-        log(String.format("RefC[%d], G1[%d], G2[%d] => G3 (vendedor) em [%d]",
-                idxRef, idxG1, idxG2, idxG3));
+        log(String.format("GR[%d], G1[%d], G2[%d] => G3 (vendedor) em [%d]",
+                idxGR, idxG1, idxG2, idxG3));
-        // 4) G4 – próximo candle rompe topo do GR (aqui já não precisamos mais checar outside)
+        // 6) G4 – próximo candle rompe topo do GR
         Candle g4 = null;
         int proxIdx = idxG3 + 1;
         if (proxIdx < n) {
             Candle c = candles.get(proxIdx);
             lastIndex = proxIdx;
-            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), ref.getMaxima())) {
+            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), gr.getMaxima())) {
                 g4 = c;
-                log(String.format("RefC[%d], G1[%d], G2[%d], G3[%d] => G4 em [%d]",
-                        idxRef, idxG1, idxG2, idxG3, proxIdx));
+                log(String.format("GR[%d], G1[%d], G2[%d], G3[%d] => G4 em [%d]",
+                        idxGR, idxG1, idxG2, idxG3, proxIdx));
             } else {
-                log(String.format("RefC[%d], G1[%d], G2[%d], G3[%d]: próximo candle [%d] não é G4.",
-                        idxRef, idxG1, idxG2, idxG3, proxIdx));
+                log(String.format("GR[%d], G1[%d], G2[%d], G3[%d]: próximo candle [%d] não é G4.",
+                        idxGR, idxG1, idxG2, idxG3, proxIdx));
+            }
+        }
         PadraoGatilho padrao = new PadraoGatilho();
-        padrao.setReferencia(ref);
+        padrao.setReferencia(gr);
         padrao.setGatilho1(g1);
         padrao.setGatilho2(g2);
         padrao.setGatilho3(g3);
         padrao.setGatilho4(g4);
         return new ResultadoPadrao(padrao, lastIndex);
+    }
     // =====================================================================
-    // CASO 2 – GR VENDEDOR (candle B)
+    // CASO 2 – PADRÃO A PARTIR DE CANDLE VENDEDOR
     // =====================================================================
-    private ResultadoPadrao detectarPadraoVendedor(List<Candle> candles, int idxRef) {
+    private ResultadoPadrao detectarPadraoVendedor(List<Candle> candles, int idxA) {
         int n = candles.size();
-        Candle ref = candles.get(idxRef); // candidato a GR vendedor
-        int lastIndex = idxRef;
-        // 0) Validar se idxRef pode ser GR vendedor (B)
-        if (!ref.isCandleVendedor()) {
-            return new ResultadoPadrao(null, idxRef);
+        int lastIndex = idxA;
+        Candle candleA = candles.get(idxA);
+        if (!candleA.isCandleVendedor()) {
+            return new ResultadoPadrao(null, idxA);
+        }
-        // 0.1 – início da pernada vendedora que termina em B
-        int inicioTrendVenda = idxRef;
-        for (int i = idxRef - 1; i >= 0; i--) {
+        // 1) A deve ser último da tendência vendedora -> achar B comprador
+        int idxB = -1;
+        for (int i = idxA + 1; i < n; i++) {
             Candle c = candles.get(i);
-            if (!c.isCandleVendedor()) {
-                break;
-            }
-            inicioTrendVenda = i;
-        }
-        // 0.2 – primeiro candle direcional após B
-        int idxPrimeiroDirecionalAposRef = -1;
-        for (int i = idxRef + 1; i < n; i++) {
-            Candle c = candles.get(i);
-            if (!c.isCandleComprador() && !c.isCandleVendedor()) {
+            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
                 continue;
-            }
-            // OUTSIDE em relação ao GR (até G3)
-            if (isOutsideReferencia(ref, c)) {
-                lastIndex = i;
-                log(String.format(
-                        "RefV[%d]: OUTSIDE em [%d] antes da mudança de tendência. Padrão descartado.",
-                        idxRef, i));
-                return new ResultadoPadrao(null, lastIndex);
+            if (c.isCandleVendedor()) {
+                return new ResultadoPadrao(null, idxA);
+            }
+            if (c.isCandleComprador()) {
+                idxB = i;
+                break;
+            }
-            idxPrimeiroDirecionalAposRef = i;
-            break;
+        }
+        if (idxB == -1) return new ResultadoPadrao(null, idxA);
-        if (idxPrimeiroDirecionalAposRef == -1) {
-            return new ResultadoPadrao(null, lastIndex);
-        }
+        Candle candleB = candles.get(idxB);
-        Candle primeiroDirecional = candles.get(idxPrimeiroDirecionalAposRef);
-        if (!primeiroDirecional.isCandleComprador()) {
-            // primeiro direcional após B ainda é vendedor
-            return new ResultadoPadrao(null, idxRef);
+        // 2) Candidato à referência: A ou B (conforme fundo)
+        Candle candidatoRef = candleA;
+        int idxCandidatoRef = idxA;
+        if (BigDecimalUtils.ehMenorQue(candleB.getMinima(), candleA.getMinima())) {
+            candidatoRef = candleB;
+            idxCandidatoRef = idxB;
+        }
-        // 0.3 – B tem o MENOR fundo da pernada vendedora
-        BigDecimal fundoRef = ref.getMinima();
-        for (int i = inicioTrendVenda; i <= idxRef; i++) {
-            Candle c = candles.get(i);
-            if (BigDecimalUtils.ehMenorQue(c.getMinima(), fundoRef)) {
-                return new ResultadoPadrao(null, idxRef);
-            }
-        }
-        int idxPrimeiroComprador = idxPrimeiroDirecionalAposRef;
-        // 1) Encontrar G1 (comprador que rompe topo do GR)
+        // 3) G1 – primeiro comprador que rompe topo do candidatoRef
+        Candle g1 = null;
         int idxG1 = -1;
-        Candle g1 = null;
-        for (int i = idxPrimeiroComprador; i < n; i++) {
+        for (int i = idxCandidatoRef + 1; i < n; i++) {
             Candle c = candles.get(i);
-            // OUTSIDE em relação ao GR (até G3)
-            if (isOutsideReferencia(ref, c)) {
-                lastIndex = i;
-                log(String.format(
-                        "RefV[%d]: OUTSIDE em [%d] durante busca de G1. Padrão descartado.",
-                        idxRef, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
+            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
+                continue;
             if (!c.isCandleComprador()) {
                 lastIndex = i - 1;
                 return new ResultadoPadrao(null, lastIndex);
+            }
             lastIndex = i;
-            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), ref.getMaxima())) {
+            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), candidatoRef.getMaxima())) {
+                g1 = c;
                 idxG1 = i;
-                g1 = c;
                 break;
+            }
+        }
+        if (g1 == null) return new ResultadoPadrao(null, lastIndex);
-        if (idxG1 == -1) {
-            return new ResultadoPadrao(null, lastIndex);
-        }
+        Candle gr = candidatoRef;
+        int idxGR = idxCandidatoRef;
+        log(String.format("GR vendedor em [%d], G1 (comprador) em [%d]", idxGR, idxG1));
-        log(String.format("RefV[%d] (GR) => G1 (comprador) em [%d]", idxRef, idxG1));
+        // 4) G2 – nova tendência vendedora com fechamento dentro da região do GR
+        Candle g2 = null;
+        int idxG2 = -1;
-        // 2) Encontrar G2 (retorno vendedor à região do GR)
         int idxPrimeiroVendedor = -1;
         for (int i = idxG1 + 1; i < n; i++) {
             Candle c = candles.get(i);
-            // OUTSIDE em relação ao GR (até G3)
-            if (isOutsideReferencia(ref, c)) {
-                lastIndex = i;
-                log(String.format(
-                        "RefV[%d]: OUTSIDE em [%d] antes da tendência de G2. Padrão descartado.",
-                        idxRef, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
-            if (!c.isCandleComprador() && !c.isCandleVendedor()) {
+            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
                 continue;
-            }
             if (c.isCandleVendedor()) {
                 idxPrimeiroVendedor = i;
                 break;
             } else {
                 lastIndex = i;
+            }
+        }
+        if (idxPrimeiroVendedor == -1) return new ResultadoPadrao(null, lastIndex);
-        if (idxPrimeiroVendedor == -1) {
-            return new ResultadoPadrao(null, lastIndex);
-        }
-        boolean rompeuFundoRef = false;
-        Candle ultimoVendedorTrend = null;
-        int idxUltimoVendedorTrend = -1;
+        Candle ultimoVendedor = null;
+        int idxUltimoVendedor = -1;
+        boolean rompeuFundoGR = false;
         for (int i = idxPrimeiroVendedor; i < n; i++) {
             Candle c = candles.get(i);
-            // OUTSIDE em relação ao GR (até G3)
-            if (isOutsideReferencia(ref, c)) {
+            if (isOutside(candles, i)) {
                 lastIndex = i;
-                log(String.format(
-                        "RefV[%d]: OUTSIDE em [%d] durante formação de G2. Padrão descartado.",
-                        idxRef, i));
+                log(String.format("GR[%d]: OUTSIDE em [%d] durante formação de G2 (vendedor).", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
-            if (!c.isCandleVendedor()) {
-                break;
-            }
+            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
+                continue;
-            ultimoVendedorTrend = c;
-            idxUltimoVendedorTrend = i;
-            lastIndex = i;
-            if (BigDecimalUtils.ehMenorQue(c.getMinima(), ref.getMinima())) {
-                rompeuFundoRef = true;
+            if (c.isCandleVendedor()) {
+                // se romper fundo do GR, descarta
+                if (BigDecimalUtils.ehMenorQue(c.getMinima(), gr.getMinima())) {
+                    rompeuFundoGR = true;
+                    lastIndex = i;
+                    break;
+                }
+                ultimoVendedor = c;
+                idxUltimoVendedor = i;
+                lastIndex = i;
+            } else if (c.isCandleComprador()) {
+                lastIndex = i - 1;
                 break;
+            }
+        }
-        if (rompeuFundoRef || idxUltimoVendedorTrend == -1) {
+        if (rompeuFundoGR || ultimoVendedor == null)
             return new ResultadoPadrao(null, lastIndex);
-        }
-        boolean fechamentoDentroRegiaoRef =
-                BigDecimalUtils.ehMaiorOuIgualQue(ultimoVendedorTrend.getFechamento(), ref.getMinima()) &&
-                BigDecimalUtils.ehMenorOuIgualQue(ultimoVendedorTrend.getFechamento(), ref.getMaxima());
+        boolean fechamentoDentroRegiaoGR =
+                BigDecimalUtils.ehMaiorOuIgualQue(ultimoVendedor.getFechamento(), gr.getMinima()) &&
+                BigDecimalUtils.ehMenorOuIgualQue(ultimoVendedor.getFechamento(), gr.getMaxima());
-        if (!fechamentoDentroRegiaoRef) {
+        if (!fechamentoDentroRegiaoGR)
             return new ResultadoPadrao(null, lastIndex);
-        }
-        Candle g2 = ultimoVendedorTrend;
-        int idxG2 = idxUltimoVendedorTrend;
-        log(String.format("RefV[%d], G1[%d] => G2 (vendedor) em [%d]", idxRef, idxG1, idxG2));
+        g2 = ultimoVendedor;
+        idxG2 = idxUltimoVendedor;
+        log(String.format("GR[%d], G1[%d] => G2 (vendedor) em [%d]", idxGR, idxG1, idxG2));
+        // 5) G3 – próximo direcional comprador; comprador que rompe topo de G2 com fundo >= fundo GR
+        Candle g3 = null;
+        int idxG3 = -1;
-        // 3) Encontrar G3 (comprador rompendo topo de G2, fundo >= fundo do GR)
         int idxPrimeiroCompradorAposG2 = -1;
         for (int i = idxG2 + 1; i < n; i++) {
             Candle c = candles.get(i);
-            // OUTSIDE em relação ao GR (até G3)
-            if (isOutsideReferencia(ref, c)) {
-                lastIndex = i;
-                log(String.format(
-                        "RefV[%d]: OUTSIDE em [%d] antes da sequência compradora de G3. Padrão descartado.",
-                        idxRef, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
-            if (!c.isCandleComprador() && !c.isCandleVendedor()) {
+            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
                 continue;
-            }
             if (c.isCandleComprador()) {
                 idxPrimeiroCompradorAposG2 = i;
                 break;
             } else {
                 lastIndex = i;
-                // esperado comprador; padrão segue apenas até G2
-                return criarResultadoParcialComG2(ref, g1, g2, lastIndex);
+                return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
+            }
+        }
-        if (idxPrimeiroCompradorAposG2 == -1) {
-            // não teve sequência adequada após G2
-            return criarResultadoParcialComG2(ref, g1, g2, lastIndex);
-        }
-        int idxG3 = -1;
-        Candle g3 = null;
+        if (idxPrimeiroCompradorAposG2 == -1)
+            return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
         for (int i = idxPrimeiroCompradorAposG2; i < n; i++) {
             Candle c = candles.get(i);
-            // OUTSIDE em relação ao GR (ATÉ IDENTIFICAR G3)
-            if (isOutsideReferencia(ref, c)) {
+            if (isOutside(candles, i)) {
                 lastIndex = i;
-                log(String.format(
-                        "RefV[%d]: OUTSIDE em [%d] durante formação de G3. Padrão descartado.",
-                        idxRef, i));
+                log(String.format("GR[%d]: OUTSIDE em [%d] durante formação de G3 (comprador).", idxGR, i));
+                return new ResultadoPadrao(null, lastIndex);
+            }
+            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
+                continue;
+            // se romper fundo do GR antes de G3 => descarta
+            if (BigDecimalUtils.ehMenorQue(c.getMinima(), gr.getMinima())) {
+                lastIndex = i;
+                log(String.format("GR[%d]: candle [%d] rompeu fundo do GR antes de G3.", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
             if (!c.isCandleComprador()) {
                 lastIndex = i - 1;
                 break;
+            }
             lastIndex = i;
             boolean rompeTopoG2 = BigDecimalUtils.ehMaiorQue(c.getMaxima(), g2.getMaxima());
-            boolean fundoMaiorOuIgualRef = BigDecimalUtils.ehMaiorOuIgualQue(c.getMinima(), ref.getMinima());
-            if (rompeTopoG2 && fundoMaiorOuIgualRef) {
+            boolean fundoMaiorOuIgualGR = BigDecimalUtils.ehMaiorOuIgualQue(c.getMinima(), gr.getMinima());
+            if (rompeTopoG2 && fundoMaiorOuIgualGR) {
+                g3 = c;
                 idxG3 = i;
-                g3 = c;
                 break;
+            }
+        }
-        if (idxG3 == -1 || g3 == null) {
-            // padrão só até G2
-            return criarResultadoParcialComG2(ref, g1, g2, lastIndex);
-        }
+        if (g3 == null)
+            return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
-        log(String.format("RefV[%d], G1[%d], G2[%d] => G3 (comprador) em [%d]",
-                idxRef, idxG1, idxG2, idxG3));
+        log(String.format("GR[%d], G1[%d], G2[%d] => G3 (comprador) em [%d]",
+                idxGR, idxG1, idxG2, idxG3));
-        // 4) G4 – próximo candle rompe fundo do GR
+        // 6) G4 – próximo candle rompe fundo do GR
         Candle g4 = null;
         int proxIdx = idxG3 + 1;
         if (proxIdx < n) {
             Candle c = candles.get(proxIdx);
             lastIndex = proxIdx;
-            if (BigDecimalUtils.ehMenorQue(c.getMinima(), ref.getMinima())) {
+            if (BigDecimalUtils.ehMenorQue(c.getMinima(), gr.getMinima())) {
                 g4 = c;
-                log(String.format("RefV[%d], G1[%d], G2[%d], G3[%d] => G4 em [%d]",
-                        idxRef, idxG1, idxG2, idxG3, proxIdx));
+                log(String.format("GR[%d], G1[%d], G2[%d], G3[%d] => G4 em [%d]",
+                        idxGR, idxG1, idxG2, idxG3, proxIdx));
             } else {
-                log(String.format("RefV[%d], G1[%d], G2[%d], G3[%d]: próximo candle [%d] não é G4.",
-                        idxRef, idxG1, idxG2, idxG3, proxIdx));
+                log(String.format("GR[%d], G1[%d], G2[%d], G3[%d]: próximo candle [%d] não é G4.",
+                        idxGR, idxG1, idxG2, idxG3, proxIdx));
+            }
+        }
         PadraoGatilho padrao = new PadraoGatilho();
-        padrao.setReferencia(ref);
+        padrao.setReferencia(gr);
         padrao.setGatilho1(g1);
         padrao.setGatilho2(g2);
         padrao.setGatilho3(g3);
         padrao.setGatilho4(g4);
         return new ResultadoPadrao(padrao, lastIndex);
-    }
-    // =====================================================================
-    // HELPER – Candle outside em relação ao GR
-    // =====================================================================
-    /**
-     * Outside em relação ao GR:
-     *  - atual.max > GR.max e atual.min < GR.min
-     */
-    private boolean isOutsideReferencia(Candle referencia, Candle atual) {
-        if (referencia == null || atual == null) return false;
-        return BigDecimalUtils.ehMaiorQue(atual.getMaxima(), referencia.getMaxima())
-                && BigDecimalUtils.ehMenorQue(atual.getMinima(), referencia.getMinima());
+    }
     // =====================================================================
-    // MODO TEMPO REAL (candle a candle)
+    // MODO TEMPO REAL
     // =====================================================================
-    /**
-     * Reinicia o estado do modo tempo real.
-     */
     public void resetTempoReal() {
         this.idxProximaAnaliseTempoReal = 0;
+    }
-    /**
-     * Deve ser chamado SEMPRE que um novo candle for adicionado à lista.
-     *
-     * Exemplo:
-     *   candles.add(novoCandle);
-     *   PadraoGatilho padrao = detector.processarCandleTempoReal(candles);
-     *
-     *   if (padrao != null) {
-     *       // padrão completo encontrado
-     *   }
-     */
     public PadraoGatilho processarCandleTempoReal(List<Candle> candles) {
         int n = candles.size();
-        if (n < 4) {
-            return null;
-        }
+        if (n < 4) return null;
         while (idxProximaAnaliseTempoReal < n - 3) {
             ResultadoPadrao resultado = detectarPadraoAPartir(candles, idxProximaAnaliseTempoReal);
             if (resultado == null) {

Subversion Repositories Integrator Subversion

(root)/projeto-trade/stocklifepro/src/main/java/br/com/kronus/core/DetectorGatilhos.java - Rev 767 → 771