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

 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)
+ * Detector de padrões de gatilhos (GR, G1, G2, G3)
  * trabalhando tanto em modo backtest quanto em modo tempo real.
+ *
- * Regras implementadas (texto alinhado):
+ * IMPORTANTE:
+ *  - Este detector FINALIZA o padrão assim que identifica o G3.
+ *  - O G4 será identificado apenas na camada de sinais de trade, fora desta classe.
+ *
+ * REGRAS IMPLEMENTADAS (com GR DINÂMICO invertido)
+ * ================================================
+ *
  * 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.
+ * Ponto de partida: um candle COMPRADOR é candidato à referência.
+ *
- * 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.
+ * G1:
+ *   - Enquanto não houver G1:
+ *       * O candidato à referência pode ser atualizado dinamicamente:
+ *         QUALQUER candle posterior, antes do G1, que fizer uma MÁXIMA
+ *         MAIOR que o candidato atual passa a ser o novo candidato.
+ *       * Se algum candle VENDEDOR subsequente ROMPER o FUNDO
+ *         do candle candidato à referência (mínima < mínima do candidato),
+ *         esse candle será o gatilho tipo 1 [G1] e o candidato vigente
+ *         torna-se o candle referência [GR].
+ *
- * 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.
+ * G2:
+ *   - Após o G1 (com GR definido):
+ *       * Assim que tiver nova tendência COMPRADORA:
+ *           - O último candle dessa sequência compradora deve ter o FECHAMENTO
+ *             dentro da região total (mínima..máxima) do GR.
+ *           - Se mudar para vendedor sem nenhum candle fechar dentro da região
+ *             do GR → descarta o padrão.
+ *       * Se qualquer candle (após o GR) romper o TOPO do GR
+ *         (máxima > máxima GR) → descarta o padrão.
+ *       * Se válido, esse último comprador é o gatilho tipo 2 [G2].
+ *
- * 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.
+ * G3:
+ *   - Após o G2:
+ *       * O próximo direcional deve ser VENDEDOR; se for comprador,
+ *         o padrão vai apenas até G2 (parcial).
+ *       * Numa sequência vendedora:
+ *           - Se algum candle VENDEDOR posterior ROMPER o FUNDO do G2
+ *             (mínima < mínima G2) e tiver TOPO <= topo do GR
+ *             (máxima <= máxima GR), sem mudança de tendência
+ *             (sem compradores no meio), será o gatilho tipo 3 [G3].
+ *
- * 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.
+ * Regra global comprador:
+ *   - Se algum candle posterior ao GR ROMPER o TOPO do GR
+ *     (máxima > máxima GR), desconsiderar o padrão.
+ *
- * 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.
+ * -----------------------------------------------------------
+ *
  * 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.
+ * Ponto de partida: um candle VENDEDOR é candidato à referência.
+ *
- * 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.
+ * G1:
+ *   - Enquanto não houver G1:
+ *       * O candidato à referência pode ser atualizado dinamicamente:
+ *         QUALQUER candle posterior, antes do G1, que fizer uma MÍNIMA
+ *         MENOR que a do candidato atual passa a ser o novo candidato.
+ *       * Se algum candle COMPRADOR subsequente ROMPER o TOPO
+ *         do candidato (máxima > máxima do candidato), esse candle
+ *         será o gatilho tipo 1 [G1] e o candidato vigente torna-se o GR.
+ *
- * 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.
+ * Regra global vendedor:
+ *   - Se algum candle posterior ao GR ROMPER o FUNDO do GR
+ *     (mínima < mínima GR), desconsiderar o padrão.
+ *
- * 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.
+ * G2:
+ *   - Após o G1 (com GR definido):
+ *       * Assim que tiver nova tendência VENDEDORA:
+ *           - O último candle dessa sequência vendedora deve ter FECHAMENTO
+ *             dentro da região total (mínima..máxima) do GR.
+ *           - Se mudar para comprador sem nenhum candle fechar dentro
+ *             da região do GR → descarta o padrão.
+ *       * Se romper o FUNDO do GR em qualquer momento após o GR
+ *         → descarta o padrão.
+ *       * Se válido, esse último vendedor é o gatilho tipo 2 [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.
+ * G3:
+ *   - Após o G2:
+ *       * O próximo direcional deve ser COMPRADOR; se for vendedor,
+ *         o padrão vai até G2 (parcial).
+ *       * Numa sequência compradora:
+ *           - Se algum COMPRADOR posterior ROMPER o TOPO de G2
+ *             (máxima > máxima G2) e tiver FUNDO >= fundo do GR
+ *             (mínima >= mínima GR), sem mudança de tendência
+ *             (sem vendedores no meio), será o gatilho tipo 3 [G3].
+ *
- * 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.
+ * Regra global adicional (texto original repetia):
+ *   - Mantida a regra principal: vendedor é invalidado
+ *     quando rompem o FUNDO do GR.
+ *
+ * -----------------------------------------------------------
+ *
  * 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.
+ *   - 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:
+ *       * Desconsidera o padrão atual (GR+G1+G2) e recomeça
+ *         a busca a partir do GR (na prática, aborta o padrão).
+ *
+ * OBS:
+ *   - Os gatilhos devem seguir ORDEM cronológica:
+ *     G1 -> G2 -> G3, sempre em candles diferentes.
  */
 public class DetectorGatilhos {
     private final boolean logAtivo;
     private int idxProximaAnaliseTempoReal = 0;
         if (logAtivo) {
             System.out.println(msg);
+        }
+    }
+    // -----------------------------------------------------------------
+    // Estrutura interna de retorno
+    // -----------------------------------------------------------------
     private static class ResultadoPadrao {
         PadraoGatilho padrao;
         int lastIndex;
         ResultadoPadrao(PadraoGatilho padrao, int lastIndex) {
             this.padrao = padrao;
             this.lastIndex = lastIndex;
+        }
+    }
         PadraoGatilho padrao = new PadraoGatilho();
         padrao.setReferencia(ref);
         padrao.setGatilho1(g1);
         padrao.setGatilho2(g2);
         padrao.setGatilho3(null);
-        padrao.setGatilho4(null);
+        padrao.setGatilho4(null); // G4 só na camada de trade
         return new ResultadoPadrao(padrao, lastIndex);
+    }
     // =====================================================================
     // API PRINCIPAL – BACKTEST
         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());
+    }
+    private boolean isDirecional(Candle c) {
+        return c.isCandleComprador() || c.isCandleVendedor();
+    }
     // =====================================================================
-    // CASO 1 – PADRÃO A PARTIR DE CANDLE COMPRADOR
+    // CASO COMPRADOR – GR DINÂMICO PELA MÁXIMA
     // =====================================================================
-    private ResultadoPadrao detectarPadraoComprador(List<Candle> candles, int idxA) {
+    private ResultadoPadrao detectarPadraoComprador(List<Candle> candles, int idxInicio) {
         int n = candles.size();
-        int lastIndex = idxA;
-        Candle candleA = candles.get(idxA);
-        if (!candleA.isCandleComprador()) {
-            return new ResultadoPadrao(null, idxA);
-        }
+        int lastIndex = idxInicio;
-        // 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 (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor())) {
-                continue;
-            }
-            if (c.isCandleComprador()) {
-                // A não é o último comprador
-                return new ResultadoPadrao(null, idxA);
-            }
-            if (c.isCandleVendedor()) {
-                idxB = i;
-                break;
-            }
+        Candle candidatoRef = candles.get(idxInicio);
+        if (!candidatoRef.isCandleComprador()) {
+            return new ResultadoPadrao(null, idxInicio);
+        }
-        if (idxB == -1) return new ResultadoPadrao(null, idxA);
-        Candle candleB = candles.get(idxB);
+        int idxCandidatoRef = idxInicio;
-        // 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;
-        }
-        // 3) G1 – primeiro vendedor que rompe fundo do candidatoRef
+        // --------------------
+        // 1) Buscar G1 (vendedor rompe fundo do candidato)
+        // --------------------
         Candle g1 = null;
         int idxG1 = -1;
-        for (int i = idxCandidatoRef + 1; i < n; i++) {
+        boolean temGR = false;
+        Candle gr = null;
+        int idxGR = -1;
+        for (int i = idxInicio + 1; i < n; i++) {
             Candle c = candles.get(i);
-            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor())) {
+            if (isInside(candles, i) || !isDirecional(c))
                 continue;
-            }
-            if (!c.isCandleVendedor()) {
-                lastIndex = i - 1;
+            // Outside antes de G3 (aqui ainda antes de G1)
+            if (isOutside(candles, i)) {
+                lastIndex = i;
+                log(String.format("Comprador: OUTSIDE em [%d] antes de G1. Abortando padrão.", i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
-            lastIndex = i;
-            if (BigDecimalUtils.ehMenorQue(c.getMinima(), candidatoRef.getMinima())) {
+            // G1: vendedor rompe fundo do candidato
+            if (c.isCandleVendedor()
+                    && BigDecimalUtils.ehMenorQue(c.getMinima(), candidatoRef.getMinima())) {
                 g1 = c;
                 idxG1 = i;
+                gr = candidatoRef;
+                idxGR = idxCandidatoRef;
+                temGR = true;
+                lastIndex = i;
                 break;
+            }
+            // GR DINÂMICO (compra): atualiza pelo TOPO mais alto antes de G1
+            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), candidatoRef.getMaxima())) {
+                candidatoRef = c;
+                idxCandidatoRef = i;
+                lastIndex = i;
+                continue;
+            }
+            lastIndex = i;
+        }
-        if (g1 == null) return new ResultadoPadrao(null, lastIndex);
+        if (g1 == null || !temGR) {
+            log(String.format("Comprador: não foi possível formar G1 a partir de idx %d.", idxInicio));
+            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("GR COMPRADOR em [%d], G1 (vendedor) em [%d].", idxGR, idxG1));
-        // 4) G2 – nova tendência compradora com fechamento dentro da região do GR
+        // --------------------
+        // 2) Buscar G2 (tendência compradora com fechamento dentro do GR)
+        // --------------------
         Candle g2 = null;
         int idxG2 = -1;
         int idxPrimeiroComprador = -1;
         for (int i = idxG1 + 1; i < n; i++) {
             Candle c = candles.get(i);
-            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
+            if (isInside(candles, i) || !isDirecional(c))
                 continue;
+            // Outside antes de G3
+            if (isOutside(candles, i)) {
+                lastIndex = idxGR;
+                log(String.format("GR[%d]: OUTSIDE em [%d] antes da perna compradora de G2.", idxGR, i));
+                return new ResultadoPadrao(null, lastIndex);
+            }
+            // Regra global: romper topo do GR invalida
+            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), gr.getMaxima())) {
+                lastIndex = i;
+                log(String.format("GR[%d]: candle[%d] rompeu topo do GR antes de G2.", idxGR, i));
+                return new ResultadoPadrao(null, lastIndex);
+            }
             if (c.isCandleComprador()) {
                 idxPrimeiroComprador = i;
                 break;
             } else {
-                // ainda vendedor
                 lastIndex = i;
+            }
+        }
-        if (idxPrimeiroComprador == -1) return new ResultadoPadrao(null, lastIndex);
+        if (idxPrimeiroComprador == -1) {
+            log(String.format("GR[%d], G1[%d]: não houve nova tendência compradora para G2.", idxGR, idxG1));
+            return new ResultadoPadrao(null, lastIndex);
+        }
         Candle ultimoComprador = null;
         int idxUltimoComprador = -1;
         for (int i = idxPrimeiroComprador; i < n; i++) {
             Candle c = candles.get(i);
+            if (isInside(candles, i) || !isDirecional(c))
+                continue;
-            // outside antes de G3 descarta
+            // Outside durante G2
             if (isOutside(candles, i)) {
+                lastIndex = idxGR;
+                log(String.format("GR[%d]: OUTSIDE em [%d] durante G2 (comprador).", idxGR, i));
+                return new ResultadoPadrao(null, lastIndex);
+            }
+            // Regra global: romper topo do GR invalida
+            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), gr.getMaxima())) {
                 lastIndex = i;
-                log(String.format("GR[%d]: OUTSIDE em [%d] durante formação de G2 (comprador).", idxGR, i));
+                log(String.format("GR[%d]: candle[%d] rompeu topo do GR durante G2.", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
-            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
-                continue;
             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 (ultimoComprador == null) return new ResultadoPadrao(null, lastIndex);
+        if (ultimoComprador == null) {
+            log(String.format("GR[%d], G1[%d]: não houve comprador válido para G2.", idxGR, idxG1));
+            return new ResultadoPadrao(null, lastIndex);
+        }
         boolean fechamentoDentroRegiaoGR =
                 BigDecimalUtils.ehMaiorOuIgualQue(ultimoComprador.getFechamento(), gr.getMinima()) &&
                 BigDecimalUtils.ehMenorOuIgualQue(ultimoComprador.getFechamento(), gr.getMaxima());
         if (!fechamentoDentroRegiaoGR) {
+            log(String.format(
+                    "GR[%d], G1[%d]: último comprador[%d] não fechou dentro da região do GR (fech=%s, faixa=[%s,%s]).",
+                    idxGR, idxG1, idxUltimoComprador,
+                    ultimoComprador.getFechamento().toPlainString(),
+                    gr.getMinima().toPlainString(),
+                    gr.getMaxima().toPlainString()
+            ));
             return new ResultadoPadrao(null, lastIndex);
+        }
         g2 = ultimoComprador;
         idxG2 = idxUltimoComprador;
-        log(String.format("GR[%d], G1[%d] => G2 (comprador) em [%d]", idxGR, idxG1, idxG2));
+        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
+        // --------------------
+        // 3) Buscar G3 (vendedor rompe fundo de G2 com topo <= topo GR)
+        // --------------------
         Candle g3 = null;
         int idxG3 = -1;
         int idxPrimeiroVendedorAposG2 = -1;
         for (int i = idxG2 + 1; i < n; i++) {
             Candle c = candles.get(i);
-            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
+            if (isInside(candles, i) || !isDirecional(c))
                 continue;
+            if (isOutside(candles, i)) {
+                lastIndex = idxGR;
+                log(String.format("GR[%d]: OUTSIDE em [%d] antes da sequência vendedora de G3.", idxGR, i));
+                return new ResultadoPadrao(null, lastIndex);
+            }
+            // Regra global: romper topo do GR invalida
+            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), gr.getMaxima())) {
+                lastIndex = i;
+                log(String.format("GR[%d]: candle[%d] rompeu topo do GR antes da perna vendedora de G3.", idxGR, i));
+                return new ResultadoPadrao(null, lastIndex);
+            }
             if (c.isCandleVendedor()) {
                 idxPrimeiroVendedorAposG2 = i;
                 break;
             } else {
-                // primeiro direcional não é vendedor => padrão só até G2
+                // primeiro direcional após G2 é comprador → padrão só até G2
                 lastIndex = i;
+                log(String.format("GR[%d], G1[%d], G2[%d]: primeiro direcional após G2 é comprador (idx %d).",
+                        idxGR, idxG1, idxG2, i));
                 return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
+            }
+        }
-        if (idxPrimeiroVendedorAposG2 == -1)
+        if (idxPrimeiroVendedorAposG2 == -1) {
+            log(String.format("GR[%d], G1[%d], G2[%d]: não houve vendedor após G2.", idxGR, idxG1, idxG2));
             return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
+        }
         for (int i = idxPrimeiroVendedorAposG2; i < n; i++) {
             Candle c = candles.get(i);
+            if (isInside(candles, i) || !isDirecional(c))
+                continue;
-            // outside antes de G3 descarta
             if (isOutside(candles, i)) {
-                lastIndex = i;
+                lastIndex = idxGR;
                 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
+            // Regra global: romper topo do GR invalida
             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));
+                log(String.format("GR[%d]: candle[%d] rompeu topo do GR durante busca de G3.", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
             if (!c.isCandleVendedor()) {
+                // apareceu comprador antes de G3 → padrão só até G2
                 lastIndex = i - 1;
-                break;
+                log(String.format("GR[%d], G1[%d], G2[%d]: comprador em [%d] antes de G3.", idxGR, idxG1, idxG2, i));
+                return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
+            }
             lastIndex = i;
             boolean rompeFundoG2 = BigDecimalUtils.ehMenorQue(c.getMinima(), g2.getMinima());
             boolean topoMenorOuIgualGR = BigDecimalUtils.ehMenorOuIgualQue(c.getMaxima(), gr.getMaxima());
                 idxG3 = i;
                 break;
+            }
+        }
-        if (g3 == null)
+        if (g3 == null) {
+            log(String.format("GR[%d], G1[%d], G2[%d]: não houve G3, padrão parcial.", idxGR, idxG1, idxG2));
             return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
-        log(String.format("GR[%d], G1[%d], G2[%d] => G3 (vendedor) em [%d]",
-                idxGR, idxG1, idxG2, idxG3));
-        // 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(), gr.getMaxima())) {
-                g4 = c;
-                log(String.format("GR[%d], G1[%d], G2[%d], G3[%d] => G4 em [%d]",
-                        idxGR, idxG1, idxG2, idxG3, proxIdx));
-            } else {
-                log(String.format("GR[%d], G1[%d], G2[%d], G3[%d]: próximo candle [%d] não é G4.",
-                        idxGR, idxG1, idxG2, idxG3, proxIdx));
-            }
+        }
+        lastIndex = idxG3;
+        log(String.format("GR[%d], G1[%d], G2[%d] => G3 (vendedor) em [%d].", idxGR, idxG1, idxG2, idxG3));
         PadraoGatilho padrao = new PadraoGatilho();
         padrao.setReferencia(gr);
         padrao.setGatilho1(g1);
         padrao.setGatilho2(g2);
         padrao.setGatilho3(g3);
-        padrao.setGatilho4(g4);
+        padrao.setGatilho4(null);
         return new ResultadoPadrao(padrao, lastIndex);
+    }
     // =====================================================================
-    // CASO 2 – PADRÃO A PARTIR DE CANDLE VENDEDOR
+    // CASO VENDEDOR – GR DINÂMICO PELA MÍNIMA
     // =====================================================================
-    private ResultadoPadrao detectarPadraoVendedor(List<Candle> candles, int idxA) {
+    private ResultadoPadrao detectarPadraoVendedor(List<Candle> candles, int idxInicio) {
         int n = candles.size();
-        int lastIndex = idxA;
-        Candle candleA = candles.get(idxA);
-        if (!candleA.isCandleVendedor()) {
-            return new ResultadoPadrao(null, idxA);
-        }
+        int lastIndex = idxInicio;
-        // 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 (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
-                continue;
-            if (c.isCandleVendedor()) {
-                return new ResultadoPadrao(null, idxA);
-            }
-            if (c.isCandleComprador()) {
-                idxB = i;
-                break;
-            }
+        Candle candidatoRef = candles.get(idxInicio);
+        if (!candidatoRef.isCandleVendedor()) {
+            return new ResultadoPadrao(null, idxInicio);
+        }
-        if (idxB == -1) return new ResultadoPadrao(null, idxA);
-        Candle candleB = candles.get(idxB);
-        // 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;
-        }
+        int idxCandidatoRef = idxInicio;
-        // 3) G1 – primeiro comprador que rompe topo do candidatoRef
+        // --------------------
+        // 1) Buscar G1 (comprador rompe topo do candidato)
+        // --------------------
         Candle g1 = null;
         int idxG1 = -1;
-        for (int i = idxCandidatoRef + 1; i < n; i++) {
+        boolean temGR = false;
+        Candle gr = null;
+        int idxGR = -1;
+        for (int i = idxInicio + 1; i < n; i++) {
             Candle c = candles.get(i);
-            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
+            if (isInside(candles, i) || !isDirecional(c))
                 continue;
-            if (!c.isCandleComprador()) {
-                lastIndex = i - 1;
+            // Outside antes de G1
+            if (isOutside(candles, i)) {
+                lastIndex = i;
+                log(String.format("Vendedor: OUTSIDE em [%d] antes de G1. Abortando padrão.", i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
-            lastIndex = i;
-            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), candidatoRef.getMaxima())) {
+            // G1: comprador rompe topo do candidato
+            if (c.isCandleComprador()
+                    && BigDecimalUtils.ehMaiorQue(c.getMaxima(), candidatoRef.getMaxima())) {
                 g1 = c;
                 idxG1 = i;
+                gr = candidatoRef;
+                idxGR = idxCandidatoRef;
+                temGR = true;
+                lastIndex = i;
                 break;
+            }
+            // GR DINÂMICO (venda): atualiza pelo FUNDO mais baixo antes de G1
+            if (BigDecimalUtils.ehMenorQue(c.getMinima(), candidatoRef.getMinima())) {
+                candidatoRef = c;
+                idxCandidatoRef = i;
+                lastIndex = i;
+                continue;
+            }
+            lastIndex = i;
+        }
+        if (g1 == null || !temGR) {
+            log(String.format("Vendedor: não foi possível formar G1 a partir de idx %d.", idxInicio));
+            return new ResultadoPadrao(null, lastIndex);
+        }
-        if (g1 == null) 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("GR VENDEDOR em [%d], G1 (comprador) em [%d].", idxGR, idxG1));
-        // 4) G2 – nova tendência vendedora com fechamento dentro da região do GR
+        // --------------------
+        // 2) Buscar G2 (tendência vendedora com fechamento dentro do GR)
+        // --------------------
         Candle g2 = null;
         int idxG2 = -1;
         int idxPrimeiroVendedor = -1;
         for (int i = idxG1 + 1; i < n; i++) {
             Candle c = candles.get(i);
-            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
+            if (isInside(candles, i) || !isDirecional(c))
                 continue;
+            // Outside antes de G3
+            if (isOutside(candles, i)) {
+                lastIndex = idxGR;
+                log(String.format("GR[%d]: OUTSIDE em [%d] antes da perna vendedora de G2.", idxGR, i));
+                return new ResultadoPadrao(null, lastIndex);
+            }
+            // Regra global vendedor: romper fundo do GR invalida
+            if (BigDecimalUtils.ehMenorQue(c.getMinima(), gr.getMinima())) {
+                lastIndex = i;
+                log(String.format("GR[%d]: candle[%d] rompeu fundo do GR antes de G2.", idxGR, i));
+                return new ResultadoPadrao(null, lastIndex);
+            }
             if (c.isCandleVendedor()) {
                 idxPrimeiroVendedor = i;
                 break;
             } else {
                 lastIndex = i;
+            }
+        }
-        if (idxPrimeiroVendedor == -1) return new ResultadoPadrao(null, lastIndex);
+        if (idxPrimeiroVendedor == -1) {
+            log(String.format("GR[%d], G1[%d]: não houve nova tendência vendedora para G2.", idxGR, idxG1));
+            return new ResultadoPadrao(null, lastIndex);
+        }
         Candle ultimoVendedor = null;
         int idxUltimoVendedor = -1;
-        boolean rompeuFundoGR = false;
         for (int i = idxPrimeiroVendedor; i < n; i++) {
             Candle c = candles.get(i);
+            if (isInside(candles, i) || !isDirecional(c))
+                continue;
+            // Outside durante G2
             if (isOutside(candles, i)) {
+                lastIndex = idxGR;
+                log(String.format("GR[%d]: OUTSIDE em [%d] durante G2 (vendedor).", idxGR, i));
+                return new ResultadoPadrao(null, lastIndex);
+            }
+            // Regra global vendedor: romper fundo do GR invalida
+            if (BigDecimalUtils.ehMenorQue(c.getMinima(), gr.getMinima())) {
                 lastIndex = i;
-                log(String.format("GR[%d]: OUTSIDE em [%d] durante formação de G2 (vendedor).", idxGR, i));
+                log(String.format("GR[%d]: candle[%d] rompeu fundo do GR durante G2.", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
-            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
-                continue;
             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 (rompeuFundoGR || ultimoVendedor == null)
+        if (ultimoVendedor == null) {
+            log(String.format("GR[%d], G1[%d]: não houve vendedor válido para G2.", idxGR, idxG1));
             return new ResultadoPadrao(null, lastIndex);
+        }
         boolean fechamentoDentroRegiaoGR =
                 BigDecimalUtils.ehMaiorOuIgualQue(ultimoVendedor.getFechamento(), gr.getMinima()) &&
                 BigDecimalUtils.ehMenorOuIgualQue(ultimoVendedor.getFechamento(), gr.getMaxima());
-        if (!fechamentoDentroRegiaoGR)
+        if (!fechamentoDentroRegiaoGR) {
+            log(String.format(
+                    "GR[%d], G1[%d]: último vendedor[%d] não fechou dentro da região do GR (fech=%s, faixa=[%s,%s]).",
+                    idxGR, idxG1, idxUltimoVendedor,
+                    ultimoVendedor.getFechamento().toPlainString(),
+                    gr.getMinima().toPlainString(),
+                    gr.getMaxima().toPlainString()
+            ));
             return new ResultadoPadrao(null, lastIndex);
+        }
         g2 = ultimoVendedor;
         idxG2 = idxUltimoVendedor;
-        log(String.format("GR[%d], G1[%d] => G2 (vendedor) em [%d]", idxGR, idxG1, idxG2));
+        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
+        // --------------------
+        // 3) Buscar G3 (comprador rompe topo de G2 com fundo >= fundo GR)
+        // --------------------
         Candle g3 = null;
         int idxG3 = -1;
         int idxPrimeiroCompradorAposG2 = -1;
         for (int i = idxG2 + 1; i < n; i++) {
             Candle c = candles.get(i);
-            if (isInside(candles, i) || (!c.isCandleComprador() && !c.isCandleVendedor()))
+            if (isInside(candles, i) || !isDirecional(c))
                 continue;
+            if (isOutside(candles, i)) {
+                lastIndex = idxGR;
+                log(String.format("GR[%d]: OUTSIDE em [%d] antes da sequência compradora de G3.", idxGR, i));
+                return new ResultadoPadrao(null, lastIndex);
+            }
+            // Regra global vendedor: romper fundo do GR antes de G3 invalida
+            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()) {
                 idxPrimeiroCompradorAposG2 = i;
                 break;
             } else {
+                // primeiro direcional não é comprador → padrão até G2
                 lastIndex = i;
+                log(String.format("GR[%d], G1[%d], G2[%d]: primeiro direcional após G2 não é comprador (idx %d).",
+                        idxGR, idxG1, idxG2, i));
                 return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
+            }
+        }
-        if (idxPrimeiroCompradorAposG2 == -1)
+        if (idxPrimeiroCompradorAposG2 == -1) {
+            log(String.format("GR[%d], G1[%d], G2[%d]: não houve comprador após G2.", idxGR, idxG1, idxG2));
             return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
+        }
         for (int i = idxPrimeiroCompradorAposG2; i < n; i++) {
             Candle c = candles.get(i);
+            if (isInside(candles, i) || !isDirecional(c))
+                continue;
             if (isOutside(candles, i)) {
-                lastIndex = i;
+                lastIndex = idxGR;
                 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
+            // Regra global vendedor: romper fundo do GR invalida
             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));
+                log(String.format("GR[%d]: candle[%d] rompeu fundo do GR durante busca de G3.", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
             if (!c.isCandleComprador()) {
+                // apareceu vendedor antes de G3 → padrão só até G2
                 lastIndex = i - 1;
-                break;
+                log(String.format("GR[%d], G1[%d], G2[%d]: vendedor em [%d] antes de G3.", idxGR, idxG1, idxG2, i));
+                return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
+            }
             lastIndex = i;
             boolean rompeTopoG2 = BigDecimalUtils.ehMaiorQue(c.getMaxima(), g2.getMaxima());
             boolean fundoMaiorOuIgualGR = BigDecimalUtils.ehMaiorOuIgualQue(c.getMinima(), gr.getMinima());
                 idxG3 = i;
                 break;
+            }
+        }
-        if (g3 == null)
+        if (g3 == null) {
+            log(String.format("GR[%d], G1[%d], G2[%d]: não houve G3, padrão parcial.", idxGR, idxG1, idxG2));
             return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
+        }
-        log(String.format("GR[%d], G1[%d], G2[%d] => G3 (comprador) em [%d]",
-                idxGR, idxG1, idxG2, idxG3));
-        // 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(), gr.getMinima())) {
-                g4 = c;
-                log(String.format("GR[%d], G1[%d], G2[%d], G3[%d] => G4 em [%d]",
-                        idxGR, idxG1, idxG2, idxG3, proxIdx));
-            } else {
-                log(String.format("GR[%d], G1[%d], G2[%d], G3[%d]: próximo candle [%d] não é G4.",
-                        idxGR, idxG1, idxG2, idxG3, proxIdx));
-            }
-        }
+        lastIndex = idxG3;
+        log(String.format("GR[%d], G1[%d], G2[%d] => G3 (comprador) em [%d].", idxGR, idxG1, idxG2, idxG3));
         PadraoGatilho padrao = new PadraoGatilho();
         padrao.setReferencia(gr);
         padrao.setGatilho1(g1);
         padrao.setGatilho2(g2);
         padrao.setGatilho3(g3);
-        padrao.setGatilho4(g4);
+        padrao.setGatilho4(null);
         return new ResultadoPadrao(padrao, lastIndex);
+    }
     // =====================================================================

Subversion Repositories Integrator Subversion

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