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

+ *
  * 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)
- * ================================================
+ * REGRAS IMPLEMENTADAS (versão alinhada)
+ * ======================================
+ *
- * COMPRADOR
- * ---------
- * Ponto de partida: um candle COMPRADOR é candidato à referência.
+ * 1) PADRÃO COMPRADOR
+ * --------------------
+ * Ponto de partida:
+ *   - Um candle COMPRADOR é tomado como CANDIDATO À REFERÊNCIA.
+ *
- * 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].
+ * GR DINÂMICO (compra):
+ *   - Enquanto NÃO houver G1:
+ *       * Qualquer candle DIRECIONAL posterior (comprador ou vendedor)
+ *         que fizer uma MÁXIMA MAIOR que a do candidato atual
+ *         passa a ser o NOVO candidato à referência.
+ *
- * 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].
+ * G1 (compra):
+ *   - Pode ser QUALQUER candle vendedor subsequente (não precisa ser o primeiro),
+ *     desde que ROMPA o FUNDO do candidato:
+ *        mínima(candle vendedor) < mínima(candidatoRef).
+ *   - No momento em que isso ocorrer:
+ *        * Esse candle vendedor é o G1.
+ *        * O candidato vigente passa a ser o GR (gatilho referência).
+ *
- * G3:
+ * G2 (compra):
+ *   - Após o G1, com GR definido:
+ *       * Procurar uma nova tendência COMPRADORA:
+ *           - Achar o primeiro candle COMPRADOR após o G1.
+ *           - Seguir a sequência compradora (ignorando INSIDE e neutros)
+ *             até aparecer candle vendedor.
+ *       * O ÚLTIMO candle dessa tendência compradora será candidato a G2.
+ *       * Para ser G2:
+ *           - O FECHAMENTO deve ficar DENTRO da região [mínGR, máxGR].
+ *       * Se mudar para vendedor sem nenhum candle fechar dentro da região do GR:
+ *           - descarta o padrão.
+ *   - Regra global comprador:
+ *       * Se qualquer candle, após o GR, ROMPER o TOPO do GR
+ *         (máxima > máximaGR) em qualquer ponto antes da conclusão:
+ *           - descarta o padrão.
+ *
+ * G3 (compra) – NOVA REGRA:
  *   - 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].
+ *       * Se ALGUM candle vendedor subsequente:
+ *           - romper o FUNDO do G2 (mínima < mínimaG2) E
+ *           - tiver TOPO menor ou igual ao TOPO do GR (máxima ≤ máximaGR)
+ *         então esse candle será o G3.
+ *   - Não precisa ser o primeiro vendedor após o G2; pode haver mudança de tendência,
+ *     candles inside, etc., desde que a regra acima seja satisfeita e não ocorra:
+ *       * outside antes do G3, ou
+ *       * rompimento do topo do GR (regra global).
+ *   - Ao identificar G3, o padrão é finalizado.
+ *
- * Regra global comprador:
- *   - Se algum candle posterior ao GR ROMPER o TOPO do GR
- *     (máxima > máxima GR), desconsiderar o padrão.
+ * 2) PADRÃO VENDEDOR
+ * -------------------
+ * Ponto de partida:
+ *   - Um candle VENDEDOR é tomado como CANDIDATO À REFERÊNCIA.
+ *
- * -----------------------------------------------------------
+ * GR DINÂMICO (venda):
+ *   - Enquanto NÃO houver G1:
+ *       * Qualquer candle DIRECIONAL posterior (comprador ou vendedor)
+ *         que fizer uma MÍNIMA MENOR que a do candidato atual
+ *         passa a ser o NOVO candidato à referência.
+ *
- * VENDEDOR
- * --------
- * Ponto de partida: um candle VENDEDOR é candidato à referência.
- *
- * 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.
+ * G1 (venda):
+ *   - Pode ser QUALQUER candle comprador subsequente (não precisa ser o primeiro),
+ *     desde que ROMPA o TOPO do candidato:
+ *        máxima(candle comprador) > máxima(candidatoRef).
+ *   - No momento em que isso ocorrer:
+ *        * Esse candle comprador é o G1.
+ *        * O candidato vigente passa a ser o GR (gatilho referência).
+ *
  * Regra global vendedor:
- *   - Se algum candle posterior ao GR ROMPER o FUNDO do GR
- *     (mínima < mínima GR), desconsiderar o padrão.
+ *   - Se qualquer candle posterior ao GR ROMPER o FUNDO do GR
+ *     (mínima < mínimaGR) em qualquer momento antes da conclusão:
+ *       - descarta o padrão.
+ *
- * 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].
+ * G2 (venda):
+ *   - Após o G1, com GR definido:
+ *       * Procurar uma nova tendência VENDEDORA:
+ *           - Achar o primeiro VENDEDOR após o G1.
+ *           - Seguir a sequência vendedora (ignorando INSIDE e neutros)
+ *             até aparecer candle comprador.
+ *       * O ÚLTIMO candle dessa tendência vendedora será candidato a G2.
+ *       * Para ser G2:
+ *           - O FECHAMENTO deve ficar DENTRO da região [mínGR, máxGR].
+ *       * Se mudar para comprador sem nenhum candle fechar dentro da região do GR:
+ *           - descarta o padrão.
+ *       * Se durante essa fase algum candle romper o FUNDO do GR
+ *         (mínima < mínimaGR) → descarta o padrão (regra global).
+ *
- * G3:
+ * G3 (venda) – NOVA REGRA:
  *   - 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].
+ *       * Se ALGUM candle comprador subsequente:
+ *           - romper o TOPO do G2 (máxima > máximaG2) E
+ *           - tiver FUNDO maior ou igual ao FUNDO do GR (mínima ≥ mínimaGR)
+ *         então esse candle será o G3.
+ *   - Não precisa ser o primeiro comprador após o G2; pode haver mudança de tendência,
+ *     candles inside, etc., desde que a regra acima seja satisfeita e não ocorra:
+ *       * outside antes do G3, ou
+ *       * rompimento do fundo do GR (regra global).
+ *   - Ao identificar G3, o padrão é finalizado.
+ *
- * Regra global adicional (texto original repetia):
- *   - Mantida a regra principal: vendedor é invalidado
- *     quando rompem o FUNDO do GR.
+ * 3) OUTSIDE (ambos os lados)
+ * ---------------------------
+ *   - Candle cuja:
+ *       máxima > máxima(candle anterior)
+ *       E mínima < mínima(candle anterior).
+ *   - Se houver OUTSIDE em qualquer estágio antes de G3:
+ *       - o padrão atual (GR/G1/G2) é descartado.
+ *
- * -----------------------------------------------------------
- *
- * 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:
- *       * 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.
+ * 4) ORDEM CRONOLÓGICA
+ * ---------------------
+ *   - Sempre GR -> G1 -> G2 -> G3.
+ *   - Todos em candles diferentes, na ordem do tempo.
  */
 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;
+        }
+    }
-    private ResultadoPadrao criarResultadoParcialComG2(Candle ref,
+    private ResultadoPadrao criarResultadoParcialComG2(Candle gr,
                                                        Candle g1,
                                                        Candle g2,
                                                        int lastIndex) {
         PadraoGatilho padrao = new PadraoGatilho();
-        padrao.setReferencia(ref);
+        padrao.setReferencia(gr);
         padrao.setGatilho1(g1);
         padrao.setGatilho2(g2);
         padrao.setGatilho3(null);
         padrao.setGatilho4(null); // G4 só na camada de trade
         return new ResultadoPadrao(padrao, lastIndex);
+        }
         int idxCandidatoRef = idxInicio;
         // --------------------
-        // 1) Buscar G1 (vendedor rompe fundo do candidato)
+        // 1) Buscar G1: QUALQUER vendedor subsequente que rompa o fundo do candidatoRef
+        //    (com GR dinâmico pela MÁXIMA antes de G1)
         // --------------------
         Candle g1 = null;
         int idxG1 = -1;
-        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) || !isDirecional(c))
+            if (isInside(candles, i) || !isDirecional(c)) {
                 continue;
+            }
-            // Outside antes de G3 (aqui ainda antes de G1)
+            // OUTSIDE antes de G1 => descarta padrão
             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);
+            }
-            // G1: vendedor rompe fundo do candidato
+            // GR dinâmico (compra): atualiza candidatoRef pelo TOPO mais alto
+            // enquanto não existir G1
+            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), candidatoRef.getMaxima())) {
+                candidatoRef = c;
+                idxCandidatoRef = i;
+                lastIndex = i;
+                continue;
+            }
+            // G1: QUALQUER vendedor subsequente que rompa o fundo do candidatoRef
             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 || !temGR) {
+        if (g1 == null || gr == null) {
             log(String.format("Comprador: não foi possível formar G1 a partir de idx %d.", idxInicio));
             return new ResultadoPadrao(null, lastIndex);
+        }
         log(String.format("GR COMPRADOR em [%d], G1 (vendedor) em [%d].", idxGR, idxG1));
         // --------------------
-        // 2) Buscar G2 (tendência compradora com fechamento dentro 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) || !isDirecional(c))
                 continue;
-            // Outside antes de G3
+            // OUTSIDE antes de G2 => descarta padrão
             if (isOutside(candles, i)) {
                 lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] antes da perna compradora de G2.", idxGR, i));
+                log(String.format("GR[%d]: OUTSIDE em [%d] antes da tendência compradora de G2.", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
-            // Regra global: romper topo do GR invalida
+            // Regra global comprador: 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 antes de G2.", idxGR, i));
+                log(String.format("GR[%d]: candle[%d] rompeu TOPO do GR antes/na formação de G2.", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
             if (c.isCandleComprador()) {
                 idxPrimeiroComprador = i;
         for (int i = idxPrimeiroComprador; i < n; i++) {
             Candle c = candles.get(i);
             if (isInside(candles, i) || !isDirecional(c))
                 continue;
-            // Outside durante G2
+            // OUTSIDE durante G2 => descarta padrão
             if (isOutside(candles, i)) {
                 lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] durante G2 (comprador).", idxGR, i));
+                log(String.format("GR[%d]: OUTSIDE em [%d] durante formação de G2 (comprador).", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
-            // Regra global: romper topo do GR invalida
+            // Regra global comprador: 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));
+                log(String.format("GR[%d]: candle[%d] rompeu TOPO do GR durante G2.", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
             if (c.isCandleComprador()) {
                 ultimoComprador = c;
                 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()
+                    "GR[%d], G1[%d]: último comprador[%d] NÃO fechou dentro da região do GR.",
+                    idxGR, idxG1, idxUltimoComprador
             ));
             return new ResultadoPadrao(null, lastIndex);
+        }
         g2 = ultimoComprador;
         idxG2 = idxUltimoComprador;
         log(String.format("GR[%d], G1[%d] => G2 (comprador) em [%d].", idxGR, idxG1, idxG2));
         // --------------------
-        // 3) Buscar G3 (vendedor rompe fundo de G2 com topo <= topo GR)
+        // 3) Buscar G3 – NOVA REGRA:
+        //    QUALQUER vendedor subsequente que rompa fundo de G2
+        //    e tenha topo <= topo do 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) || !isDirecional(c))
+            if (!isDirecional(c) || isInside(candles, i)) {
                 continue;
+            }
+            // OUTSIDE antes/durante busca de G3 => descarta padrão
             if (isOutside(candles, i)) {
                 lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] antes da sequência vendedora de G3.", idxGR, i));
+                log(String.format("GR[%d]: OUTSIDE em [%d] durante busca de G3 (vendedor).", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
-            // Regra global: romper topo do GR invalida
+            // Regra global comprador: 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 antes da perna vendedora 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()) {
-                idxPrimeiroVendedorAposG2 = i;
-                break;
-            } else {
-                // 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) {
-            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;
-            if (isOutside(candles, i)) {
-                lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] durante formação de G3 (vendedor).", 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 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;
-                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());
-            if (rompeFundoG2 && topoMenorOuIgualGR) {
-                g3 = c;
-                idxG3 = i;
-                break;
+                boolean rompeFundoG2 = BigDecimalUtils.ehMenorQue(c.getMinima(), g2.getMinima());
+                boolean topoMenorOuIgualGR = BigDecimalUtils.ehMenorOuIgualQue(c.getMaxima(), gr.getMaxima());
+                if (rompeFundoG2 && topoMenorOuIgualGR) {
+                    g3 = c;
+                    idxG3 = i;
+                    lastIndex = i;
+                    break;
+                }
+            }
+        }
         if (g3 == null) {
-            log(String.format("GR[%d], G1[%d], G2[%d]: não houve G3, padrão parcial.", idxGR, idxG1, idxG2));
+            log(String.format("GR[%d], G1[%d], G2[%d]: não houve G3 (comprador -> padrão parcial).",
+                    idxGR, idxG1, idxG2));
             return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
+        }
-        lastIndex = idxG3;
-        log(String.format("GR[%d], G1[%d], G2[%d] => G3 (vendedor) em [%d].", idxGR, idxG1, idxG2, 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);
+        }
         int idxCandidatoRef = idxInicio;
         // --------------------
-        // 1) Buscar G1 (comprador rompe topo do candidato)
+        // 1) Buscar G1: QUALQUER comprador subsequente que rompa o topo do candidatoRef
+        //    (com GR dinâmico pela MÍNIMA antes de G1)
         // --------------------
         Candle g1 = null;
         int idxG1 = -1;
-        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) || !isDirecional(c))
+            if (isInside(candles, i) || !isDirecional(c)) {
                 continue;
+            }
-            // Outside antes de G1
+            // OUTSIDE antes de G1 => descarta padrão
             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);
+            }
-            // G1: comprador rompe topo do candidato
+            // GR dinâmico (venda): atualiza candidatoRef pelo FUNDO mais baixo
+            // enquanto não existir G1
+            if (BigDecimalUtils.ehMenorQue(c.getMinima(), candidatoRef.getMinima())) {
+                candidatoRef = c;
+                idxCandidatoRef = i;
+                lastIndex = i;
+                continue;
+            }
+            // G1: QUALQUER comprador subsequente que rompa o topo do candidatoRef
             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) {
+        if (g1 == null || gr == null) {
             log(String.format("Vendedor: não foi possível formar G1 a partir de idx %d.", idxInicio));
             return new ResultadoPadrao(null, lastIndex);
+        }
         log(String.format("GR VENDEDOR em [%d], G1 (comprador) em [%d].", idxGR, idxG1));
         // --------------------
-        // 2) Buscar G2 (tendência vendedora com fechamento dentro 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) || !isDirecional(c))
-                continue;
+            if (isInside(candles, i) || !isDirecional(c)) continue;
-            // Outside antes de G3
+            // OUTSIDE antes de G2 => descarta padrão
             if (isOutside(candles, i)) {
                 lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] antes da perna vendedora de G2.", idxGR, i));
+                log(String.format("GR[%d]: OUTSIDE em [%d] antes da tendência vendedora de G2.", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
-            // Regra global vendedor: romper fundo do GR invalida
+            // Regra global vendedor: romper fundo do GR => descarta
             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));
+                log(String.format("GR[%d]: candle[%d] rompeu FUNDO do GR antes/na formação de G2.", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
             if (c.isCandleVendedor()) {
                 idxPrimeiroVendedor = i;
         Candle ultimoVendedor = null;
         int idxUltimoVendedor = -1;
         for (int i = idxPrimeiroVendedor; i < n; i++) {
             Candle c = candles.get(i);
-            if (isInside(candles, i) || !isDirecional(c))
-                continue;
+            if (isInside(candles, i) || !isDirecional(c)) continue;
-            // Outside durante G2
+            // OUTSIDE durante G2 => descarta padrão
             if (isOutside(candles, i)) {
                 lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] durante G2 (vendedor).", idxGR, i));
+                log(String.format("GR[%d]: OUTSIDE em [%d] durante formação de G2 (vendedor).", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
-            // Regra global vendedor: romper fundo do GR invalida
+            // Regra global vendedor: romper fundo do GR => descarta
             if (BigDecimalUtils.ehMenorQue(c.getMinima(), gr.getMinima())) {
                 lastIndex = i;
-                log(String.format("GR[%d]: candle[%d] rompeu fundo do GR durante G2.", idxGR, i));
+                log(String.format("GR[%d]: candle[%d] rompeu FUNDO do GR durante G2.", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
             if (c.isCandleVendedor()) {
                 ultimoVendedor = c;
                 BigDecimalUtils.ehMaiorOuIgualQue(ultimoVendedor.getFechamento(), gr.getMinima()) &&
                 BigDecimalUtils.ehMenorOuIgualQue(ultimoVendedor.getFechamento(), gr.getMaxima());
         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()
+                    "GR[%d], G1[%d]: último vendedor[%d] NÃO fechou dentro da região do GR.",
+                    idxGR, idxG1, idxUltimoVendedor
             ));
             return new ResultadoPadrao(null, lastIndex);
+        }
         g2 = ultimoVendedor;
         idxG2 = idxUltimoVendedor;
         log(String.format("GR[%d], G1[%d] => G2 (vendedor) em [%d].", idxGR, idxG1, idxG2));
         // --------------------
-        // 3) Buscar G3 (comprador rompe topo de G2 com fundo >= fundo GR)
+        // 3) Buscar G3 – NOVA REGRA:
+        //    QUALQUER comprador subsequente que rompa topo de G2
+        //    e tenha fundo >= fundo do 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) || !isDirecional(c))
+            if (!isDirecional(c) || isInside(candles, i)) {
                 continue;
+            }
+            // OUTSIDE antes/durante busca de G3 => descarta padrão
             if (isOutside(candles, i)) {
                 lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] antes da sequência compradora de G3.", idxGR, i));
+                log(String.format("GR[%d]: OUTSIDE em [%d] durante busca de G3 (comprador).", idxGR, i));
                 return new ResultadoPadrao(null, lastIndex);
+            }
-            // Regra global vendedor: romper fundo do GR antes de G3 invalida
+            // Regra global vendedor: romper fundo do GR => 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));
+                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()) {
-                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) {
-            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 = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] durante formação de G3 (comprador).", 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 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;
-                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());
-            if (rompeTopoG2 && fundoMaiorOuIgualGR) {
-                g3 = c;
-                idxG3 = i;
-                break;
+                boolean rompeTopoG2 = BigDecimalUtils.ehMaiorQue(c.getMaxima(), g2.getMaxima());
+                boolean fundoMaiorOuIgualGR = BigDecimalUtils.ehMaiorOuIgualQue(c.getMinima(), gr.getMinima());
+                if (rompeTopoG2 && fundoMaiorOuIgualGR) {
+                    g3 = c;
+                    idxG3 = i;
+                    lastIndex = i;
+                    break;
+                }
+            }
+        }
         if (g3 == null) {
-            log(String.format("GR[%d], G1[%d], G2[%d]: não houve G3, padrão parcial.", idxGR, idxG1, idxG2));
+            log(String.format("GR[%d], G1[%d], G2[%d]: não houve G3 (vendedor -> padrão parcial).",
+                    idxGR, idxG1, idxG2));
             return criarResultadoParcialComG2(gr, g1, g2, lastIndex);
+        }
-        lastIndex = idxG3;
-        log(String.format("GR[%d], G1[%d], G2[%d] => G3 (comprador) em [%d].", idxGR, idxG1, idxG2, 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);
     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 (até G3) encontrado
+     *   }
+     */
     public PadraoGatilho processarCandleTempoReal(List<Candle> candles) {
         int n = candles.size();
         if (n < 4) return null;
         while (idxProximaAnaliseTempoReal < n - 3) {

Subversion Repositories Integrator Subversion

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