WebSVN - Integrator Subversion - Diff - Rev 774 and 775 - /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)
- * trabalhando tanto em modo backtest quanto em modo tempo real.
+ * para o modelo Kronus.
+ *
- * 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 GERAIS:
+ * - Não usar candles INSIDE (range totalmente dentro do candle anterior).
+ * - Gatilhos sempre em ordem cronológica: GR -> G1 -> G2 -> G3.
+ * - Um candle não pode ser usado para dois gatilhos.
+ * - Não pode haver G2 antes de G1.
+ *
- * REGRAS IMPLEMENTADAS (versão alinhada)
- * ======================================
+ * -------------------------------------------------------------
+ * PADRÃO COMPRADOR (OPERAÇÃO VENDEDORA)
+ * -------------------------------------------------------------
+ *
- * 1) PADRÃO COMPRADOR
- * --------------------
- * Ponto de partida:
- *   - Um candle COMPRADOR é tomado como CANDIDATO À REFERÊNCIA.
+ * 1) Referência (GR) e G1
+ *
- * 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.
+ * A) Tenho um candle A COMPRADOR.
+ *    Se o PRÓXIMO candle direcional (não-inside) tiver mudança direcional
+ *    (for VENDEDOR), então A passa a ser CANDIDATO À REFERÊNCIA.
+ *
- * 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).
+ * B) Referência dinâmica (antes do G1):
+ *    Enquanto G1 ainda não apareceu, entre o índice do candidato e o G1:
+ *    - Se algum candle posterior fizer MÁXIMA MAIOR que a máxima do candidato,
+ *      esse candle passa a ser o NOVO candidato à referência.
+ *
- * 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.
+ * C) G1:
+ *    - Se algum candle VENDEDOR subsequente romper o FUNDO do candidato à referência
+ *      (minima < minimaCandRef), esse candle será o G1.
+ *    - O candidato atual torna-se o GR definitivo.
+ *
- * G3 (compra) – NOVA REGRA:
- *   - Após o G2:
- *       * 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.
+ * D) Regra de saída pelo G1:
+ *    - Considerar a Fibo do G1 com origem na MÁXIMA do G1 e destino na MÍNIMA do G1.
+ *    - Calcular o nível 200% dessa Fibo.
+ *    - Se ALGUM candle após o G1 ATINGIR ou PASSAR ESSE NÍVEL (mínima <= nível200)
+ *      ANTES de identificar G3, descartar a operação:
+ *        -> descartar padrão e reiniciar análise a partir do candle APÓS o GR.
+ *
- * 2) PADRÃO VENDEDOR
- * -------------------
- * Ponto de partida:
- *   - Um candle VENDEDOR é tomado como CANDIDATO À REFERÊNCIA.
+ * 2) G2 (após G1)
+ *
- * 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.
+ *    - Após o G1, QUALQUER candle COMPRADOR que tiver FECHAMENTO DENTRO da região
+ *      do GR (minGR <= fechamento <= maxGR) passa a ser CANDIDATO a G2.
+ *
- * 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 de descarte:
+ *        Se ALGUM candle posterior ao G1 ROMPER o TOPO do GR (máxima > maxGR),
+ *        descartar a operação:
+ *          -> descartar padrão e reiniciar análise a partir do candle APÓS o GR.
+ *
- * Regra global vendedor:
- *   - 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 dinâmico (entre o primeiro G2 candidato e o G3):
+ *        Enquanto G3 não tiver aparecido:
+ *        - Se surgir outro candle COMPRADOR com FECHAMENTO dentro da região do GR
+ *          e MÁXIMA MAIOR que a máxima do candidato atual a G2,
+ *          esse novo candle passa a ser o NOVO 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).
+ * 3) G3 (após ter G2)
+ *
- * G3 (venda) – NOVA REGRA:
- *   - Após o G2:
- *       * 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.
+ *    - Após existir um candidato a G2:
+ *      Se algum candle VENDEDOR posterior:
+ *        * romper o FUNDO do G2 (minima < minimaG2) e
+ *        * tiver TOPO MENOR OU IGUAL ao TOPO do GR (max <= maxGR)
+ *      => esse candle será o G3, confirmando o padrão.
+ *
- * 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.
+ *    - Ao encontrar G3, o padrão COMPRADOR é considerado COMPLETO (GR,G1,G2,G3).
+ *
- * 4) ORDEM CRONOLÓGICA
- * ---------------------
- *   - Sempre GR -> G1 -> G2 -> G3.
- *   - Todos em candles diferentes, na ordem do tempo.
+ * -------------------------------------------------------------
+ * PADRÃO VENDEDOR (OPERAÇÃO COMPRADORA)
+ * -------------------------------------------------------------
+ *
+ * 1) Referência (GR) e G1
+ *
+ * A) Tenho um candle A VENDEDOR.
+ *    Se o PRÓXIMO candle direcional (não-inside) tiver mudança direcional
+ *    (for COMPRADOR), então A passa a ser CANDIDATO À REFERÊNCIA.
+ *
+ * B) Referência dinâmica (antes do G1):
+ *    Enquanto G1 ainda não apareceu, entre o índice do candidato e o G1:
+ *    - Se algum candle posterior fizer MÍNIMA MENOR que a mínima do candidato,
+ *      esse candle passa a ser o NOVO candidato à referência.
+ *
+ * C) G1:
+ *    - Se algum candle COMPRADOR subsequente romper o TOPO do candidato à referência
+ *      (máxima > máximaCandRef), esse candle será o G1.
+ *    - O candidato atual torna-se o GR definitivo.
+ *
+ * D) Regra de saída pelo G1:
+ *    - Considerar a Fibo do G1 com origem na MÍNIMA do G1 e destino na MÁXIMA do G1.
+ *    - Calcular o nível -100% dessa Fibo.
+ *    - Se ALGUM candle após o G1 ATINGIR ou PASSAR ESSE NÍVEL para baixo
+ *      (mínima <= nível -100%) ANTES de identificar G3,
+ *      descartar a operação:
+ *        -> descartar padrão e reiniciar análise a partir do candle APÓS o GR.
+ *
+ * 2) G2 (após G1)
+ *
+ *    - Após o G1, QUALQUER candle VENDEDOR que tiver FECHAMENTO DENTRO da região
+ *      do GR (minGR <= fechamento <= maxGR) passa a ser CANDIDATO a G2.
+ *
+ *    - Regra de descarte:
+ *        Se ALGUM candle posterior ao G1 ROMPER o FUNDO do GR (mínima < minGR),
+ *        descartar a operação:
+ *          -> descartar padrão e reiniciar análise a partir do candle APÓS o GR.
+ *
+ *    - G2 dinâmico (entre o primeiro G2 candidato e o G3):
+ *        Enquanto G3 não tiver aparecido:
+ *        - Se surgir outro candle VENDEDOR com FECHAMENTO dentro da região do GR
+ *          e MÍNIMA MENOR que a mínima do candidato a G2,
+ *          esse novo candle passa a ser o NOVO G2.
+ *
+ * 3) G3 (após ter G2)
+ *
+ *    - Após existir um candidato a G2:
+ *      Se algum candle COMPRADOR posterior:
+ *        * romper o TOPO do G2 (máxima > máximaG2) e
+ *        * tiver FUNDO MENOR OU IGUAL ao FUNDO do GR (mínima <= minGR)
+ *      => esse candle será o G3, confirmando o padrão.
+ *
+ *    - Ao encontrar G3, o padrão VENDEDOR é considerado COMPLETO (GR,G1,G2,G3).
+ *
+ * -------------------------------------------------------------
+ * BACKTEST:
+ *  - identificarPadroes: varre a lista inteira e retorna todos os padrões
+ *    completos ou parciais (até G2).
+ *
+ * TEMPO REAL:
+ *  - processarCandleTempoReal: chamado a cada novo candle, retorna um padrão
+ *    assim que ele for identificado (até G3).
+ *
+ * DEBUG:
+ *  - debugarAPartirDoIndice: roda a detecção a partir de um índice e
+ *    retorna um relatório (List<String>) com tudo o que aconteceu.
  */
 public class DetectorGatilhos {
     private final boolean logAtivo;
     private int idxProximaAnaliseTempoReal = 0;
+    /**
+     * Buffer opcional para capturar logs em memória (modo debug).
+     * Se for null, não acumula; se não for null, log() adiciona aqui também.
+     */
+    private List<String> bufferDebug;
     public DetectorGatilhos() {
-        this(false);
+        this(true);
+    }
     public DetectorGatilhos(boolean logAtivo) {
         this.logAtivo = logAtivo;
+    }
     private void log(String msg) {
         if (logAtivo) {
             System.out.println(msg);
+        }
+        if (bufferDebug != null) {
+            bufferDebug.add(msg);
+        }
+    }
-    // -------------------------------------------------------------
-    // Estrutura interna de retorno
-    // -------------------------------------------------------------
+    /**
+     * Estrutura interna para carregar o resultado da detecção
+     * iniciando em um índice específico.
+     *
+     * lastIndex      = último índice efetivamente analisado na busca daquele padrão.
+     * proximoInicio  = índice sugerido para o PRÓXIMO início de análise:
+     *                  - Se NÃO existiu GR: idxA + 1
+     *                  - Se existiu GR: idxGR + 1 (recomeça após a referência)
+     */
     private static class ResultadoPadrao {
         PadraoGatilho padrao;
         int lastIndex;
+        int proximoInicio;
-        ResultadoPadrao(PadraoGatilho padrao, int lastIndex) {
+        ResultadoPadrao(PadraoGatilho padrao, int lastIndex, int proximoInicio) {
             this.padrao = padrao;
             this.lastIndex = lastIndex;
+            this.proximoInicio = proximoInicio;
+        }
+    }
-    private ResultadoPadrao criarResultadoParcialComG2(Candle gr,
+    /**
+     * Cria um resultado com padrão PARCIAL (até G2).
+     * Sempre que há GR, o próximo início deve ser após o GR.
+     */
+    private ResultadoPadrao criarResultadoParcialComG2(Candle ref,
                                                        Candle g1,
                                                        Candle g2,
-                                                       int lastIndex) {
+                                                       int lastIndex,
+                                                       int idxGR) {
         PadraoGatilho padrao = new PadraoGatilho();
-        padrao.setReferencia(gr);
+        padrao.setReferencia(ref);
         padrao.setGatilho1(g1);
         padrao.setGatilho2(g2);
         padrao.setGatilho3(null);
-        padrao.setGatilho4(null); // G4 só na camada de trade
-        return new ResultadoPadrao(padrao, lastIndex);
+        padrao.setGatilho4(null); // G4 será tratado na camada de estratégia, não aqui.
+        return new ResultadoPadrao(padrao, lastIndex, idxGR + 1);
+    }
+    // =====================================================================
+    // HELPERS
+    // =====================================================================
+    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());
+    }
+    private boolean isDirecional(Candle c) {
+        return c.isCandleComprador() || c.isCandleVendedor();
+    }
+    private boolean fechamentoDentroRegiaoGR(Candle c, Candle gr) {
+        return BigDecimalUtils.ehMaiorOuIgualQue(c.getFechamento(), gr.getMinima())
+                && BigDecimalUtils.ehMenorOuIgualQue(c.getFechamento(), gr.getMaxima());
+    }
+    /**
+     * Extensão de Fibonacci simples:
+     * origem + (destino - origem) * fator
+     */
+    private BigDecimal fibExtend(BigDecimal origem, BigDecimal destino, BigDecimal fator) {
+        BigDecimal diff = destino.subtract(origem);
+        return origem.add(diff.multiply(fator));
+    }
     // =====================================================================
     // API PRINCIPAL – BACKTEST
     // =====================================================================
             if (resultado.padrao != null) {
                 padroes.add(resultado.padrao);
+            }
-            idxRef = Math.max(resultado.lastIndex + 1, idxRef + 1);
+            // Regra de avanço:
+            // - Se houve GR, proximoInicio = idxGR + 1
+            // - Se não houve GR, proximoInicio = idxRef + 1
+            int proximoInicio = resultado.proximoInicio;
+            if (proximoInicio <= idxRef) {
+                proximoInicio = idxRef + 1;
+            }
+            idxRef = proximoInicio;
+        }
         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 {
-            return new ResultadoPadrao(null, idxRef);
+            // Candle neutro não é A; não existe GR, avança 1 candle.
+            return new ResultadoPadrao(null, idxRef, idxRef + 1);
+        }
+    }
     // =====================================================================
-    // HELPERS
+    // PADRÃO COMPRADOR (OPERAÇÃO VENDEDORA)
     // =====================================================================
-    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());
-    }
+    private ResultadoPadrao detectarPadraoComprador(List<Candle> candles, int idxA) {
+        int n = candles.size();
+        Candle candleA = candles.get(idxA);
+        if (!candleA.isCandleComprador()) {
+            // Não pode ser A comprador -> reinicia no próximo candle.
+            return new ResultadoPadrao(null, idxA, idxA + 1);
+        }
-    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());
-    }
+        int lastIndex = idxA;
+        log(String.format("[VENDER] Iniciando busca a partir de A[%d]", idxA + 1));
-    private boolean isDirecional(Candle c) {
-        return c.isCandleComprador() || c.isCandleVendedor();
-    }
+        // 1) Verifica se o próximo candle direcional (não-inside) muda a direção
+        int idxProxDirecional = -1;
+        for (int i = idxA + 1; i < n; i++) {
+            Candle c = candles.get(i);
+            if (!isDirecional(c) || isInside(candles, i)) {
+                log(String.format("[VENDER] Candle[%d] ignorado (não direcional ou inside)", i + 1));
+                continue;
+            }
+            idxProxDirecional = i;
+            break;
+        }
-    // =====================================================================
-    // CASO COMPRADOR – GR DINÂMICO PELA MÁXIMA
-    // =====================================================================
-    private ResultadoPadrao detectarPadraoComprador(List<Candle> candles, int idxInicio) {
-        int n = candles.size();
-        int lastIndex = idxInicio;
+        if (idxProxDirecional == -1) {
+            // Não houve candle B; A não vira candidato; recomeça do próximo candle.
+            return new ResultadoPadrao(null, idxA, idxA + 1);
+        }
-        Candle candidatoRef = candles.get(idxInicio);
-        if (!candidatoRef.isCandleComprador()) {
-            return new ResultadoPadrao(null, idxInicio);
+        Candle prox = candles.get(idxProxDirecional);
+        if (!prox.isCandleVendedor()) {
+            // Não houve mudança direcional imediata -> A não vira candidato
+            return new ResultadoPadrao(null, idxA, idxA + 1);
+        }
-        int idxCandidatoRef = idxInicio;
+        // A vira candidato à referência
+        Candle candidatoRef = candleA;
+        int idxCandidatoRef = idxA;
+        log(String.format("[VENDER] CandidatoRef inicial = idx %d", idxCandidatoRef + 1));
-        // --------------------
-        // 1) Buscar G1: QUALQUER vendedor subsequente que rompa o fundo do candidatoRef
-        //    (com GR dinâmico pela MÁXIMA antes de G1)
-        // --------------------
+        // 2) Busca G1, com referência dinâmica até G1
         Candle g1 = null;
         int idxG1 = -1;
-        Candle gr = null;
-        int idxGR = -1;
-        for (int i = idxInicio + 1; i < n; i++) {
+        for (int i = idxA + 1; i < n; i++) {
             Candle c = candles.get(i);
-            if (isInside(candles, i) || !isDirecional(c)) {
+            if (!isDirecional(c) || isInside(candles, i)) {
+                log(String.format("[VENDER] Candle[%d] ignorado (não direcional ou inside) antes do G1", i + 1));
                 continue;
+            }
-            // 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);
-            }
-            // 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;
-            }
+            lastIndex = i;
-            // G1: QUALQUER vendedor subsequente que rompa o fundo do candidatoRef
+            // Primeiro checa G1: vendedor que rompe fundo do candidatoRef
             if (c.isCandleVendedor()
                     && BigDecimalUtils.ehMenorQue(c.getMinima(), candidatoRef.getMinima())) {
                 g1 = c;
                 idxG1 = i;
-                gr = candidatoRef;
-                idxGR = idxCandidatoRef;
-                lastIndex = i;
+                log(String.format("[VENDER] G1 encontrado em [%d], rompendo fundo de candRef[%d]", idxG1 + 1, idxCandidatoRef + 1));
                 break;
+            }
-            lastIndex = i;
+            // Se ainda não encontrou G1, atualiza candidatoRef se máxima maior
+            if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), candidatoRef.getMaxima())) {
+                candidatoRef = c;
+                idxCandidatoRef = i;
+                log(String.format("[VENDER] CandidatoRef atualizado dinamicamente para idx %d", idxCandidatoRef + 1));
+            }
+        }
-        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);
+        if (g1 == null) {
+            // Não formou G1; não existe GR definitivo; recomeça a partir do próximo candle após A.
+            return new ResultadoPadrao(null, lastIndex, idxA + 1);
+        }
-        log(String.format("GR COMPRADOR em [%d], G1 (vendedor) em [%d].", idxGR, idxG1));
+        Candle gr = candidatoRef;
+        int idxGR = idxCandidatoRef;
+        log(String.format("[VENDER] GR definido em [%d], G1 em [%d]", idxGR + 1, idxG1 + 1));
+        // 3) Regra de saída do G1 – Fibonacci 200% (origem = máxG1, destino = mínG1)
+        BigDecimal fib200 = fibExtend(g1.getMaxima(), g1.getMinima(), new BigDecimal("2"));
+        log(String.format("[VENDER] Fibo200 G1[%d] = %s", idxG1, fib200.toPlainString()));
-        // --------------------
-        // 2) Buscar G2 – tendência COMPRADORA com fechamento dentro do GR
-        // --------------------
+        // 4) Busca G2 dinâmico e G3
         Candle g2 = null;
         int idxG2 = -1;
+        Candle g3 = null;
+        int idxG3 = -1;
-        int idxPrimeiroComprador = -1;
         for (int i = idxG1 + 1; i < n; i++) {
             Candle c = candles.get(i);
-            if (isInside(candles, i) || !isDirecional(c))
+            if (!isDirecional(c) || isInside(candles, i)) {
+                log(String.format("[VENDER] Candle[%d] ignorado (não direcional ou inside) após G1", i + 1));
                 continue;
-            // OUTSIDE antes de G2 => descarta padrão
-            if (isOutside(candles, i)) {
-                lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] antes da tendência compradora de G2.", idxGR, i));
-                return new ResultadoPadrao(null, lastIndex);
+            }
-            // 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/na formação de G2.", idxGR, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
+            lastIndex = i;
-            if (c.isCandleComprador()) {
-                idxPrimeiroComprador = i;
-                break;
-            } else {
-                lastIndex = i;
-            }
-        }
+            // --- Regras de DESCARTE após G1 (devem reiniciar do candle após o GR) ---
-        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 durante G2 => descarta padrão
-            if (isOutside(candles, i)) {
-                lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] durante formação de G2 (comprador).", idxGR, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
-            // Regra global comprador: se romper topo do GR => descarta
+            // 4.1) Se candle romper TOPO do GR => descarta operação
             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);
+                log(String.format("[VENDER] GR[%d]: candle[%d] rompeu topo do GR. Descartando padrão.", idxGR + 1, i + 1));
+                return new ResultadoPadrao(null, i, idxGR + 1);
+            }
-            if (c.isCandleComprador()) {
-                ultimoComprador = c;
-                idxUltimoComprador = i;
-                lastIndex = i;
-            } else if (c.isCandleVendedor()) {
-                lastIndex = i - 1;
-                break;
+            // 4.2) Regra Fib 200% do G1: se mínima <= fib200 => descarta
+            if (BigDecimalUtils.ehMenorOuIgualQue(c.getMinima(), fib200)) {
+                log(String.format("[VENDER] GR[%d], G1[%d]: candle[%d] atingiu 200%% da fibo G1. Descartando padrão.",
+                        idxGR + 1, idxG1 + 1, i + 1));
+                return new ResultadoPadrao(null, i, idxGR + 1);
+            }
-        }
-        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.",
-                    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 – NOVA REGRA:
-        //    QUALQUER vendedor subsequente que rompa fundo de G2
-        //    e tenha topo <= topo do GR.
-        // --------------------
-        Candle g3 = null;
-        int idxG3 = -1;
-        for (int i = idxG2 + 1; i < n; i++) {
-            Candle c = candles.get(i);
-            if (!isDirecional(c) || isInside(candles, i)) {
+            // --- Construção de G2 dinâmico (COMPRADOR com FECHAMENTO dentro da região do GR) ---
+            if (c.isCandleComprador() && fechamentoDentroRegiaoGR(c, gr)) {
+                if (g2 == null) {
+                    g2 = c;
+                    idxG2 = i;
+                    log(String.format("[VENDER] GR[%d], G1[%d]: candidato G2 em [%d]", idxGR + 1, idxG1 + 1, idxG2 + 1));
+                } else {
+                    // Atualização dinâmica: máxima maior e fechamento ainda dentro da região
+                    if (BigDecimalUtils.ehMaiorQue(c.getMaxima(), g2.getMaxima())) {
+                        g2 = c;
+                        idxG2 = i;
+                        log(String.format("[VENDER] GR[%d], G1[%d]: G2 atualizado em [%d]", idxGR + 1, idxG1 + 1, idxG2 + 1));
+                    }
+                }
                 continue;
+            }
-            // OUTSIDE antes/durante busca de G3 => descarta padrão
-            if (isOutside(candles, i)) {
-                lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] durante busca de G3 (vendedor).", idxGR, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
-            // 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 durante busca de G3.", idxGR, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
-            if (c.isCandleVendedor()) {
+            // --- G3: só pode ser avaliado após existir candidato G2 ---
+            if (g2 != null && c.isCandleVendedor()) {
                 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;
+                    log(String.format("[VENDER] GR[%d], G1[%d], G2[%d]: G3 em [%d] (padrão confirmado)",
+                            idxGR + 1, idxG1 + 1, idxG2 + 1, idxG3 + 1));
                     break;
+                }
+            }
+        }
         if (g3 == null) {
-            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);
+            // Padrão só até G2 (se G2 existir), senão nada.
+            if (g2 != null) {
+                log(String.format("[VENDER] Padrão parcial (GR[%d], G1[%d], G2[%d]) sem G3.", idxGR + 1, idxG1 + 1, idxG2 + 1));
+                return criarResultadoParcialComG2(gr, g1, g2, lastIndex, idxGR);
+            }
+            // Já houve GR e G1, mas não houve G2/G3 -> recomeça após GR.
+            log(String.format("[VENDER] GR[%d], G1[%d] sem G2/G3. Recomeçando após GR.", idxGR + 1, idxG1 + 1));
+            return new ResultadoPadrao(null, lastIndex, idxGR + 1);
+        }
-        log(String.format("GR[%d], G1[%d], G2[%d] => G3 (vendedor) em [%d].",
-                idxGR, idxG1, idxG2, idxG3));
+        // Finaliza padrão no G3
         PadraoGatilho padrao = new PadraoGatilho();
         padrao.setReferencia(gr);
         padrao.setGatilho1(g1);
         padrao.setGatilho2(g2);
         padrao.setGatilho3(g3);
         padrao.setGatilho4(null);
-        return new ResultadoPadrao(padrao, lastIndex);
+        // Padrão completo -> próxima busca deve começar após o GR
+        return new ResultadoPadrao(padrao, idxG3, idxGR + 1);
+    }
     // =====================================================================
-    // CASO VENDEDOR – GR DINÂMICO PELA MÍNIMA
+    // PADRÃO VENDEDOR (OPERAÇÃO COMPRADORA)
     // =====================================================================
-    private ResultadoPadrao detectarPadraoVendedor(List<Candle> candles, int idxInicio) {
+    private ResultadoPadrao detectarPadraoVendedor(List<Candle> candles, int idxA) {
         int n = candles.size();
-        int lastIndex = idxInicio;
+        Candle candleA = candles.get(idxA);
+        if (!candleA.isCandleVendedor()) {
+            // Não pode ser A vendedor -> reinicia no próximo candle.
+            return new ResultadoPadrao(null, idxA, idxA + 1);
+        }
-        Candle candidatoRef = candles.get(idxInicio);
-        if (!candidatoRef.isCandleVendedor()) {
-            return new ResultadoPadrao(null, idxInicio);
+        int lastIndex = idxA;
+        log(String.format("[COMPRAR] Iniciando busca a partir de A[%d]", idxA + 1));
+        // 1) Verifica se o próximo candle direcional (não-inside) muda a direção
+        int idxProxDirecional = -1;
+        for (int i = idxA + 1; i < n; i++) {
+            Candle c = candles.get(i);
+            if (!isDirecional(c) || isInside(candles, i)) {
+                log(String.format("[COMPRAR] Candle[%d] ignorado (não direcional ou inside)", i + 1));
+                continue;
+            }
+            idxProxDirecional = i;
+            break;
+        }
+        if (idxProxDirecional == -1) {
+            // Não houve candle B; A não vira candidato; recomeça do próximo candle.
+            return new ResultadoPadrao(null, idxA, idxA + 1);
+        }
+        Candle prox = candles.get(idxProxDirecional);
+        if (!prox.isCandleComprador()) {
+            // Não houve mudança direcional imediata -> A não vira candidato
+            return new ResultadoPadrao(null, idxA, idxA + 1);
+        }
-        int idxCandidatoRef = idxInicio;
+        // A vira candidato à referência
+        Candle candidatoRef = candleA;
+        int idxCandidatoRef = idxA;
+        log(String.format("[COMPRAR] CandidatoRef inicial = idx %d", idxCandidatoRef + 1));
-        // --------------------
-        // 1) Buscar G1: QUALQUER comprador subsequente que rompa o topo do candidatoRef
-        //    (com GR dinâmico pela MÍNIMA antes de G1)
-        // --------------------
+        // 2) Busca G1, com referência dinâmica até G1
         Candle g1 = null;
         int idxG1 = -1;
-        Candle gr = null;
-        int idxGR = -1;
-        for (int i = idxInicio + 1; i < n; i++) {
+        for (int i = idxA + 1; i < n; i++) {
             Candle c = candles.get(i);
-            if (isInside(candles, i) || !isDirecional(c)) {
+            if (!isDirecional(c) || isInside(candles, i)) {
+                log(String.format("[COMPRAR] Candle[%d] ignorado (não direcional ou inside) antes do G1", i + 1));
                 continue;
+            }
-            // 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);
-            }
-            // 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;
-            }
+            lastIndex = i;
-            // G1: QUALQUER comprador subsequente que rompa o topo do candidatoRef
+            // Primeiro checa G1: comprador que rompe topo do candidatoRef
             if (c.isCandleComprador()
                     && BigDecimalUtils.ehMaiorQue(c.getMaxima(), candidatoRef.getMaxima())) {
                 g1 = c;
                 idxG1 = i;
-                gr = candidatoRef;
-                idxGR = idxCandidatoRef;
-                lastIndex = i;
+                log(String.format("[COMPRAR] G1 encontrado em [%d], rompendo topo de candRef[%d]", idxG1 + 1, idxCandidatoRef + 1));
                 break;
+            }
-            lastIndex = i;
+            // Se ainda não encontrou G1, atualiza candidatoRef se mínima menor
+            if (BigDecimalUtils.ehMenorQue(c.getMinima(), candidatoRef.getMinima())) {
+                candidatoRef = c;
+                idxCandidatoRef = i;
+                log(String.format("[COMPRAR] CandidatoRef atualizado dinamicamente para idx %d", idxCandidatoRef + 1));
+            }
+        }
-        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);
+        if (g1 == null) {
+            // Não formou G1; não existe GR definitivo; recomeça a partir do próximo candle após A.
+            return new ResultadoPadrao(null, lastIndex, idxA + 1);
+        }
-        log(String.format("GR VENDEDOR em [%d], G1 (comprador) em [%d].", idxGR, idxG1));
+        Candle gr = candidatoRef;
+        int idxGR = idxCandidatoRef;
+        log(String.format("[COMPRAR] GR definido em [%d], G1 em [%d]", idxGR + 1, idxG1 + 1));
-        // --------------------
-        // 2) Buscar G2 – tendência VENDEDORA com fechamento dentro do GR
-        // --------------------
+        // 3) Regra de saída do G1 – Fibonacci 200% (origem = mínG1, destino = máxG1)
+        BigDecimal fib200MinMax = fibExtend(g1.getMinima(), g1.getMaxima(), new BigDecimal("2"));
+        log(String.format("[COMPRAR] Fibo200 G1[%d] = %s", idxG1 + 1, fib200MinMax.toPlainString()));
+        // 4) Busca G2 dinâmico e G3
         Candle g2 = null;
         int idxG2 = -1;
+        Candle g3 = null;
+        int idxG3 = -1;
-        int idxPrimeiroVendedor = -1;
         for (int i = idxG1 + 1; i < n; i++) {
             Candle c = candles.get(i);
-            if (isInside(candles, i) || !isDirecional(c)) continue;
-            // OUTSIDE antes de G2 => descarta padrão
-            if (isOutside(candles, i)) {
-                lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] antes da tendência vendedora de G2.", idxGR, i));
-                return new ResultadoPadrao(null, lastIndex);
+            if (!isDirecional(c) || isInside(candles, i)) {
+                log(String.format("[COMPRAR] Candle[%d] ignorado (não direcional ou inside) após G1", i + 1));
+                continue;
+            }
-            // 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/na formação de G2.", idxGR, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
+            lastIndex = i;
-            if (c.isCandleVendedor()) {
-                idxPrimeiroVendedor = i;
-                break;
-            } else {
-                lastIndex = i;
-            }
-        }
-        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;
-        for (int i = idxPrimeiroVendedor; i < n; i++) {
-            Candle c = candles.get(i);
-            if (isInside(candles, i) || !isDirecional(c)) continue;
-            // OUTSIDE durante G2 => descarta padrão
-            if (isOutside(candles, i)) {
-                lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] durante formação de G2 (vendedor).", idxGR, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
+            // --- Regras de DESCARTE após G1 (reiniciar após GR) ---
-            // Regra global vendedor: romper fundo do GR => descarta
+            // 4.1) Se candle romper FUNDO do GR => descarta operação
             if (BigDecimalUtils.ehMenorQue(c.getMinima(), gr.getMinima())) {
-                lastIndex = i;
-                log(String.format("GR[%d]: candle[%d] rompeu FUNDO do GR durante G2.", idxGR, i));
-                return new ResultadoPadrao(null, lastIndex);
+                log(String.format("[COMPRAR] GR[%d]: candle[%d] rompeu fundo do GR. Descartando padrão.", idxGR + 1, i + 1));
+                return new ResultadoPadrao(null, i, idxGR + 1);
+            }
-            if (c.isCandleVendedor()) {
-                ultimoVendedor = c;
-                idxUltimoVendedor = i;
-                lastIndex = i;
-            } else if (c.isCandleComprador()) {
-                lastIndex = i - 1;
-                break;
+            // 4.2) Regra Fib 200% do G1: se mínima > fib200MinMax => descarta
+            if (BigDecimalUtils.ehMaiorQue(c.getMinima(), fib200MinMax)) {
+                log(String.format("[COMPRAR] GR[%d], G1[%d]: candle[%d] atingiu 200%% da fibo G1. Descartando padrão.",
+                        idxGR + 1, idxG1 + 1, i + 1));
+                return new ResultadoPadrao(null, i, idxGR + 1);
+            }
-        }
-        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) {
-            log(String.format(
-                    "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 – NOVA REGRA:
-        //    QUALQUER comprador subsequente que rompa topo de G2
-        //    e tenha fundo >= fundo do GR.
-        // --------------------
-        Candle g3 = null;
-        int idxG3 = -1;
-        for (int i = idxG2 + 1; i < n; i++) {
-            Candle c = candles.get(i);
-            if (!isDirecional(c) || isInside(candles, i)) {
+            // --- Construção de G2 dinâmico (VENDEDOR com FECHAMENTO dentro da região do GR) ---
+            if (c.isCandleVendedor() && fechamentoDentroRegiaoGR(c, gr)) {
+                if (g2 == null) {
+                    g2 = c;
+                    idxG2 = i;
+                    log(String.format("[COMPRAR] GR[%d], G1[%d]: candidato G2 em [%d]", idxGR + 1, idxG1 + 1, idxG2 + 1));
+                } else {
+                    // Atualização dinâmica: mínima menor e fechamento ainda dentro da região
+                    if (BigDecimalUtils.ehMenorQue(c.getMinima(), g2.getMinima())) {
+                        g2 = c;
+                        idxG2 = i;
+                        log(String.format("[COMPRAR] GR[%d], G1[%d]: G2 atualizado em [%d]", idxGR + 1, idxG1 + 1, idxG2 + 1));
+                    }
+                }
                 continue;
+            }
-            // OUTSIDE antes/durante busca de G3 => descarta padrão
-            if (isOutside(candles, i)) {
-                lastIndex = idxGR;
-                log(String.format("GR[%d]: OUTSIDE em [%d] durante busca de G3 (comprador).", idxGR, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
+            // --- G3: só pode ser avaliado após existir candidato G2 ---
+            if (g2 != null && c.isCandleComprador()) {
+                boolean rompeTopoG2 = BigDecimalUtils.ehMaiorQue(c.getMaxima(), g2.getMaxima());
+                boolean fundoMenorOuIgualGR = BigDecimalUtils.ehMenorOuIgualQue(c.getMinima(), gr.getMinima());
-            // 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 busca de G3.", idxGR, i));
-                return new ResultadoPadrao(null, lastIndex);
-            }
-            if (c.isCandleComprador()) {
-                boolean rompeTopoG2 = BigDecimalUtils.ehMaiorQue(c.getMaxima(), g2.getMaxima());
-                boolean fundoMaiorOuIgualGR = BigDecimalUtils.ehMaiorOuIgualQue(c.getMinima(), gr.getMinima());
-                if (rompeTopoG2 && fundoMaiorOuIgualGR) {
+                if (rompeTopoG2 && fundoMenorOuIgualGR) {
                     g3 = c;
                     idxG3 = i;
-                    lastIndex = i;
+                    log(String.format("[COMPRAR] GR[%d], G1[%d], G2[%d]: G3 em [%d] (padrão confirmado)",
+                            idxGR + 1, idxG1 + 1, idxG2 + 1, idxG3 + 1));
                     break;
+                }
+            }
+        }
         if (g3 == null) {
-            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);
+            // Padrão só até G2 (se G2 existir), senão nada
+            if (g2 != null) {
+                log(String.format("[COMPRAR] Padrão parcial (GR[%d], G1[%d], G2[%d]) sem G3.", idxGR + 1, idxG1 + 1, idxG2 + 1));
+                return criarResultadoParcialComG2(gr, g1, g2, lastIndex, idxGR);
+            }
+            // Já houve GR e G1, mas não houve G2/G3 -> recomeça após GR.
+            log(String.format("[COMPRAR] GR[%d], G1[%d] sem G2/G3. Recomeçando após GR.", idxGR + 1, idxG1 + 1));
+            return new ResultadoPadrao(null, lastIndex, idxGR + 1);
+        }
-        log(String.format("GR[%d], G1[%d], G2[%d] => G3 (comprador) em [%d].",
-                idxGR, idxG1, idxG2, idxG3));
+        // Finaliza padrão no G3
         PadraoGatilho padrao = new PadraoGatilho();
         padrao.setReferencia(gr);
         padrao.setGatilho1(g1);
         padrao.setGatilho2(g2);
         padrao.setGatilho3(g3);
         padrao.setGatilho4(null);
-        return new ResultadoPadrao(padrao, lastIndex);
+        // Padrão completo -> próxima busca deve começar após o GR
+        return new ResultadoPadrao(padrao, idxG3, idxGR + 1);
+    }
     // =====================================================================
     // MODO TEMPO REAL
     // =====================================================================
             if (resultado == null) {
                 idxProximaAnaliseTempoReal++;
                 continue;
+            }
-            int proximoInicio = resultado.lastIndex + 1;
+            int proximoInicio = resultado.proximoInicio;
             if (proximoInicio <= idxProximaAnaliseTempoReal) {
                 proximoInicio = idxProximaAnaliseTempoReal + 1;
+            }
             idxProximaAnaliseTempoReal = proximoInicio;
                 return resultado.padrao;
+            }
+        }
         return null;
+    }
+    // =====================================================================
+    // DEBUG / RELATÓRIO
+    // =====================================================================
+    /**
+     * Roda a lógica de detecção a partir de um índice específico e devolve
+     * um "relatório" em forma de lista de strings com tudo que aconteceu.
+     *
+     * NÃO altera idxProximaAnaliseTempoReal.
+     */
+    public List<String> debugarAPartirDoIndice(List<Candle> candles, int idxInicio) {
+        List<String> relatorio = new ArrayList<>();
+        List<String> antigoBuffer = this.bufferDebug;
+        this.bufferDebug = relatorio;
+        try {
+            log("====================================================");
+            log(String.format("DEBUG: iniciando debugarAPartirDoIndice(%d)", idxInicio));
+            detectarPadraoAPartir(candles, idxInicio);
+            log(String.format("DEBUG: fim da análise a partir do índice %d", idxInicio));
+            log("====================================================");
+        } finally {
+            this.bufferDebug = antigoBuffer;
+        }
+        return relatorio;
+    }
+}

Subversion Repositories Integrator Subversion

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