Subversion Repositories Integrator Subversion

package br.com.robo.model;

import java.util.ArrayList;

import java.util.List;

/**

 * Identifica sequências de 3 gatilhos em tendência de alta,

 * conforme regras fornecidas.

 */

public class TriggerFinder {

    /**

     * Representa um padrão completo de gatilhos:

     * - refIndex: candle de referência (topo da perna de alta)

     * - g1Index: índice do Gatilho tipo 1

     * - g2Index: índice do Gatilho tipo 2

     * - g3Index: índice do Gatilho tipo 3

     */

    public static class TriggerPattern {

        private final int refIndex;

        private final int g1Index;

        private final int g2Index;

        private final int g3Index;

        public TriggerPattern(int refIndex, int g1Index, int g2Index, int g3Index) {

            this.refIndex = refIndex;

            this.g1Index = g1Index;

            this.g2Index = g2Index;

            this.g3Index = g3Index;

        }

        public int getRefIndex() {

            return refIndex;

        }

        public int getG1Index() {

            return g1Index;

        }

        public int getG2Index() {

            return g2Index;

        }

        public int getG3Index() {

            return g3Index;

        }

        @Override

        public String toString() {

            return "TriggerPattern{" +

                    "refIndex=" + refIndex +

                    ", g1Index=" + g1Index +

                    ", g2Index=" + g2Index +

                    ", g3Index=" + g3Index +

                    '}';

        }

    }

    /**

     * Encontra todos os padrões de 3 gatilhos em tendência de alta

     * na lista de candles.

     */

    public List<TriggerPattern> findTriggers(List<Candle> candles) {

        List<TriggerPattern> patterns = new ArrayList<>();

        if (candles == null || candles.size() < 5) {

            return patterns;

        }

        int i = 2; // começa em 2 por causa da checagem de tendência

        while (i < candles.size() - 3) {

            int refIndex = i - 1;

            Candle ref = candles.get(refIndex);

            Candle possibleG1 = candles.get(i);

            // 1) Tendência de alta antes do refIndex

            if (!isUptrend(candles, refIndex)) {

                i++;

                continue;

            }

            // 2) Candle de referência deve ser comprador

            if (!isBullish(ref)) {

                i++;

                continue;

            }

            // 3) Gatilho tipo 1: candle vendedor contrário ao ref

            if (!isBearish(possibleG1)) {

                i++;

                continue;

            }

            int g1Index = i;

            Candle g1 = possibleG1;

            int g2Index = -1;

            int g3Index = -1;

            // -------------------------------

            // 4) Procurar G2

            //

            // Gatilho tipo 2:

            // - Candle comprador dentro da região da referência (ref)

            //      => high(G2) <= high(ref) e low(G2) >= low(ref)

            //   OU

            // - Candle vendedor rompendo com pavio o topo do G1

            //      => candle vendedor e high(G2) > high(G1)

            //

            // IMPORTANTE: aqui AINDA NÃO vale a regra especial

            // do rompimento do topo da referência; ela só entra

            // na etapa de busca do G3.

            // -------------------------------

            int j = g1Index + 1;

            while (j < candles.size() - 1) { // deixa pelo menos 1 candle depois pra ser o G3

                Candle c = candles.get(j);

                boolean isG2 = false;

                // Caso 1: comprador dentro da região da referência

                boolean compradorDentroRef =

                        isBullish(c)

                        && c.getHigh() <= ref.getHigh()

                        && c.getLow() >= ref.getLow();

                // Caso 2: vendedor rompendo com pavio o topo do G1

                // (pavio rompe topo do G1)

                boolean vendedorRompeTopoG1 =

                        isBearish(c)

                        && c.getHigh() > g1.getHigh();

                if (compradorDentroRef || vendedorRompeTopoG1) {

                    isG2 = true;

                }

                if (isG2) {

                    g2Index = j;

                    break;

                }

                j++;

            }

            // Se não achou G2, avança e segue a busca

            if (g2Index == -1) {

                i++;

                continue;

            }

            Candle g2 = candles.get(g2Index);

            // -------------------------------

            // 5) Procurar G3

            //

            // Gatilho tipo 3:

            // - Candle vendedor

            // - topo < topo do candle de referência

            // - rompe o fundo do G2 (low(G3) < low(G2))

            //

            // REGRA ESPECIAL:

            // "Se houver o rompimento do topo do referência,

            //  não considerar mais os gatilhos definidos anteriormente."

            //

            // Ou seja: durante a busca do G3, se QUALQUER candle tiver

            // high > high(ref), invalida essa sequência.

            // -------------------------------

            boolean invalidSequence = false;

            int k = g2Index + 1;

            while (k < candles.size()) {

                Candle c = candles.get(k);

                // Regra especial: rompimento do topo da referência

                if (c.getHigh() > ref.getHigh()) {

                    invalidSequence = true;

                    break;

                }

                if (isBearish(c)

                        && c.getHigh() < ref.getHigh()

                        && c.getLow() < g2.getLow()) {

                    g3Index = k;

                    break;

                }

                k++;

            }

            if (invalidSequence) {

                // sequência descartada, segue a partir do candle

                // que rompeu o topo da referência

                i = k + 1;

                continue;

            }

            if (g3Index != -1) {

                patterns.add(new TriggerPattern(refIndex, g1Index, g2Index, g3Index));

                // pula pra depois do G3 pra evitar muitos padrões sobrepostos

                i = g3Index + 1;

            } else {

                // não houve G3, segue a partir do próximo candle após G1

                i = g1Index + 1;

            }

        }

        return patterns;

    }

    // ---------- Funções auxiliares ----------

    private boolean isBullish(Candle c) {

        return c.getClose() > c.getOpen();

    }

    private boolean isBearish(Candle c) {

        return c.getClose() < c.getOpen();

    }

    /**

     * Tendência de alta simples:

     * close[ref] > close[ref-1] > close[ref-2]

     */

    private boolean isUptrend(List<Candle> candles, int refIndex) {

        if (refIndex < 2) {

            return false;

        }

        double c0 = candles.get(refIndex).getClose();

        double c1 = candles.get(refIndex - 1).getClose();

        double c2 = candles.get(refIndex - 2).getClose();

        return c0 > c1 && c1 > c2;

    }

}