Subversion Repositories Integrator Subversion

package br.com.kronus.binance.robos;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.math.BigDecimal;

import java.nio.charset.StandardCharsets;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.StandardOpenOption;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.time.ZoneId;

import java.time.format.DateTimeFormatter;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.Date;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

import br.com.kronus.core.Candle;

import br.com.kronus.core.DetectorGatilhos;

import br.com.kronus.core.EstrategiaGatilhoTipo3Sinais;

import br.com.kronus.core.PadraoGatilho;

import br.com.kronus.core.SinalTradeGatilho3;

import br.com.kronus.core.TipoPeriodoCandle;

/**

 * RoboSinaisMain:

 *

 * - Monitora o arquivo BTCUSDT_1m.csv

 * - A cada 2 segundos verifica se foi modificado

 * - Se houve modificação:

 *      * Carrega TODOS os candles do arquivo

 *      * Identifica padrões e gera sinais (DetectorGatilhos + Estratégia)

 *      * Grava os sinais em SINAIS.csv com status 'P' (Pendente)

 *      * Evita gravar sinais duplicados via ID de sinal

 *

 * Layout BTCUSDT_1m.csv:

 * BTCUSDT;30/11/2025;14:12:00;91390,2;91410,7;91390;91390;226,94;155

 * 0       1           2        3       4       5      6      7      8

 *

 * Layout SINAIS.csv (mesmo do RoboGatilhosSinaisMain):

 * ID;Ativo;Data;Hora;TipoOperacao;PrecoEntrada;StopLoss;TakeProfit;Quantidade;Status;ClientOrderId

 */

public class RoboSinaisMain {

    private static final String ARQUIVO_SINAIS   = "D:/Dropbox/BLP/INVESTIMENTOS/DAYTRADE/sinais/SINAIS.csv";

    private static final String ARQUIVO_CANDLES = "D:/Dropbox/BLP/INVESTIMENTOS/DAYTRADE/temporeal/BTCUSDT_5m.csv";

    private static final BigDecimal VALOR_ENTRADA = new BigDecimal(0.005);

    private final ZoneId zone = ZoneId.of("America/Maceio");

    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();

    // Data/hora para candles (arquivo BTCUSDT_1m.csv)

    private final DateTimeFormatter fmtDataCandle = DateTimeFormatter.ofPattern("dd/MM/yyyy");

    private final DateTimeFormatter fmtHoraCandle = DateTimeFormatter.ofPattern("HH:mm:ss");

    // Data/hora para sinais (arquivo SINAIS.csv)

    private final DateTimeFormatter fmtDataSinal = DateTimeFormatter.ofPattern("dd/MM/yyyy");

    private final DateTimeFormatter fmtHoraSinal = DateTimeFormatter.ofPattern("HH:mm:ss");

    // Controle de modificação do arquivo de candles

    private long ultimaModificacaoCandles = 0L;

    // IDs de sinais já gravados no arquivo SINAIS.csv (para evitar duplicidade)

    private final Set<String> idsSinaisGravados = new HashSet<>();

    // =====================================================================

    // MAIN

    // =====================================================================

    public static void main(String[] args) {

        try {

            RoboSinaisMain r = new RoboSinaisMain();

            r.iniciar();

            Runtime.getRuntime().addShutdownHook(new Thread(r::parar));

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    // =====================================================================

    // CONSTRUTOR / INÍCIO / FIM

    // =====================================================================

    public RoboSinaisMain() {

        System.out.println("[ROBO-SINAIS] Inicializando RoboSinaisMain...");

        carregarIdsSinaisExistentes();

    }

    public void iniciar() {

        System.out.println("[ROBO-SINAIS] Iniciando monitor de candles (BTCUSDT_1m) a cada 2 segundos...");

        scheduler.scheduleAtFixedRate(() -> {

            try {

                ciclo();

            } catch (Exception e) {

                e.printStackTrace();

            }

        }, 0, 2, TimeUnit.SECONDS);

    }

    public void parar() {

        System.out.println("[ROBO-SINAIS] Encerrando RoboSinaisMain.");

        scheduler.shutdownNow();

    }

    // =====================================================================

    // CICLO A CADA 2 SEGUNDOS

    // =====================================================================

    private void ciclo() {

        if (arquivoCandlesFoiModificado()) {

            System.out.println("[ROBO-SINAIS] BTCUSDT_1m.csv modificado. Recarregando candles e gerando sinais...");

            List<Candle> candles = carregarCandlesDoArquivo();

            if (candles.isEmpty()) {

                System.out.println("[ROBO-SINAIS] Nenhum candle carregado. Ignorando ciclo.");

                return;

            }

            // 1) Detector de padrões

            DetectorGatilhos detector = new DetectorGatilhos();

            List<PadraoGatilho> padroes = detector.identificarPadroes(candles);

            if (padroes == null || padroes.isEmpty()) {

                System.out.println("[ROBO-SINAIS] Nenhum padrão encontrado.");

                return;

            }

            System.out.println("[ROBO-SINAIS] Padrões encontrados: " + padroes.size());

            // 2) Estratégia para gerar sinais

            EstrategiaGatilhoTipo3Sinais estrategia = new EstrategiaGatilhoTipo3Sinais();

            List<SinalTradeGatilho3> sinais = estrategia.gerarSinais(padroes);

            if (sinais == null || sinais.isEmpty()) {

                System.out.println("[ROBO-SINAIS] Nenhum sinal gerado.");

                return;

            }

            // Ordena por data/hora de entrada DESC (mais recente primeiro)

            sinais.sort(Comparator.comparing(SinalTradeGatilho3::getDataHoraEntrada).reversed());

            System.out.println("[ROBO-SINAIS] Sinais gerados: " + sinais.size());

            // 3) Grava apenas os sinais ainda não registrados em SINAIS.csv

            gravarNovosSinais(sinais);

        }

    }

    private boolean arquivoCandlesFoiModificado() {

        try {

            Path path = Paths.get(ARQUIVO_CANDLES);

            if (!Files.exists(path)) {

                System.out.println("[ROBO-SINAIS] Arquivo de candles não encontrado: " + path.toAbsolutePath());

                return false;

            }

            long mod = Files.getLastModifiedTime(path).toMillis();

            if (mod > ultimaModificacaoCandles) {

                ultimaModificacaoCandles = mod;

                return true;

            }

        } catch (IOException e) {

            System.err.println("[ROBO-SINAIS] Erro ao verificar modificação do arquivo de candles: " + e.getMessage());

        }

        return false;

    }

    // =====================================================================

    // CARREGAR CANDLES DO ARQUIVO BTCUSDT_1m.csv

    // =====================================================================

    private List<Candle> carregarCandlesDoArquivo() {

        List<Candle> lista = new ArrayList<>();

        Path path = Paths.get(ARQUIVO_CANDLES);

        if (!Files.exists(path)) {

            System.out.println("[ROBO-SINAIS] Arquivo de candles não encontrado: " + path.toAbsolutePath());

            return lista;

        }

        try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.UTF_8)) {

            String linha;

            boolean primeira = true;

            int contador = 0;

            while ((linha = reader.readLine()) != null) {

                if (primeira && linha.toLowerCase().contains("data")) {

                    primeira = false;

                    continue; // pula cabeçalho, se houver

                }

                primeira = false;

                if (linha.trim().isEmpty()) continue;

                Candle c = parseLinhaParaCandle(linha, contador);

                if (c != null) {

                    lista.add(c);

                    contador++;

                }

            }

            System.out.println("[ROBO-SINAIS] Candles carregados: " + lista.size());

        } catch (IOException e) {

            System.err.println("[ROBO-SINAIS] Erro ao ler arquivo de candles: " + e.getMessage());

            e.printStackTrace();

        }

        return lista;

    }

    /**

     * Formato BTCUSDT_1m.csv:

     * BTCUSDT;30/11/2025;14:12:00;91390,2;91410,7;91390;91390;226,94;155

     * 0       1           2        3       4       5      6      7      8

     */

    private Candle parseLinhaParaCandle(String linha, int contadorCandle) {

        try {

            String[] p = linha.split(";", -1);

            if (p.length < 7) {

                System.out.println("[ROBO-SINAIS] Linha inválida em BTCUSDT_1m: " + linha);

                return null;

            }

            String ativo = p[0].trim();

            LocalDate data = LocalDate.parse(p[1].trim(), fmtDataCandle);

            LocalTime hora = LocalTime.parse(p[2].trim(), fmtHoraCandle);

            LocalDateTime dt = LocalDateTime.of(data, hora);

            BigDecimal abertura   = parseBigDecimal(p[3]);

            BigDecimal maxima     = parseBigDecimal(p[4]);

            BigDecimal minima     = parseBigDecimal(p[5]);

            BigDecimal fechamento = parseBigDecimal(p[6]);

            BigDecimal volume     = (p.length > 7) ? parseBigDecimal(p[7]) : BigDecimal.ZERO;

            Candle c = new Candle(

                    contadorCandle,

                    ativo,

                    dt,

                    abertura,

                    maxima,

                    minima,

                    fechamento,

                    TipoPeriodoCandle.M1.getValor()

            );

            c.setVolume(volume);

            return c;

        } catch (Exception e) {

            System.out.println("[ROBO-SINAIS] Erro ao parsear linha de candle: " + linha);

            e.printStackTrace();

            return null;

        }

    }

    // =====================================================================

    // GRAVAÇÃO DE SINAIS EM SINAIS.csv (STATUS = P)

    // =====================================================================

    private void gravarNovosSinais(List<SinalTradeGatilho3> sinais) {

        if (sinais == null || sinais.isEmpty()) {

            return;

        }

        Path path = Paths.get(ARQUIVO_SINAIS);

        boolean novoArquivo = !Files.exists(path);

        try {

            if (path.getParent() != null && !Files.exists(path.getParent())) {

                Files.createDirectories(path.getParent());

            }

            try (BufferedWriter writer = Files.newBufferedWriter(

                    path,

                    StandardCharsets.UTF_8,

                    StandardOpenOption.CREATE,

                    StandardOpenOption.APPEND)

            ) {

                // Cabeçalho se arquivo recém-criado

                if (novoArquivo) {

                    writer.write("ID;Ativo;Data;Hora;TipoOperacao;PrecoEntrada;StopLoss;TakeProfit;Quantidade;Status;ClientOrderId");

                    writer.newLine();

                }

                int novos = 0;

                for (SinalTradeGatilho3 s : sinais) {

                    if (s == null) continue;

                    if (s.getDataHoraEntrada() == null) continue;

                    String id = gerarIdSinal(s);

                    // Evita duplicidade

                    if (idsSinaisGravados.contains(id)) {

                        continue;

                    }

                    idsSinaisGravados.add(id);

                    // ==== Mapear campos ====

                    String ativo = s.getIdAtivo(); // AJUSTE AQUI se o getter tiver outro nome

                    if (ativo == null || ativo.trim().isEmpty()) {

                        ativo = "BTCUSDT";

                    }

                    Date dataHora = s.getDataHoraEntrada();

                    if (dataHora == null) {

                        return; // ou continue; dependendo do contexto

                    }

                    LocalDateTime dt = LocalDateTime.ofInstant(dataHora.toInstant(), zone);  // use o ZoneId que você já tem na classe

                    String data = dt.toLocalDate().format(fmtDataSinal);

                    String hora = dt.toLocalTime().format(fmtHoraSinal);

                    String tipoOperacao = (s.getTipoOperacao() != null)? s.getTipoOperacao().getValor() : "";

                    BigDecimal precoEntrada = s.getPrecoEntrada1();

                    BigDecimal stopLoss     = s.getStopMenos100();

                    BigDecimal takeProfit   = s.getAlvo2();

                    BigDecimal quantidade   = VALOR_ENTRADA; // AJUSTE se usar outro nome (ex.: getContratos)

                    String precoEntradaStr = toStr(precoEntrada);

                    String stopLossStr     = toStr(stopLoss);

                    String takeProfitStr   = toStr(takeProfit);

                    String quantidadeStr   = toStr(quantidade);

                    String status = "P";         // sempre pendente ao gravar

                    String clientOrderId = "";   // ainda não enviado pra Binance

                    String linha = id + ";" +

                            ativo + ";" +

                            data + ";" +

                            hora + ";" +

                            tipoOperacao + ";" +

                            precoEntradaStr + ";" +

                            stopLossStr + ";" +

                            takeProfitStr + ";" +

                            quantidadeStr + ";" +

                            status + ";" +

                            clientOrderId;

                    writer.write(linha);

                    writer.newLine();

                    novos++;

                }

                System.out.println("[ROBO-SINAIS] Novos sinais gravados: " + novos);

            }

        } catch (IOException e) {

            System.err.println("[ROBO-SINAIS] Erro ao gravar SINAIS.csv: " + e.getMessage());

            e.printStackTrace();

        }

    }

    /**

     * Gera um ID único para o sinal, baseado em:

     *  Ativo + DataHoraEntrada + TipoOperacao + PrecoEntrada

     *

     * Isso garante que, se o mesmo sinal for recalculado depois,

     * não será gravado novamente.

     */

    private String gerarIdSinal(SinalTradeGatilho3 s) {

        String ativo = s.getIdAtivo();

        if (ativo == null || ativo.trim().isEmpty()) {

            ativo = "BTCUSDT";

        }

        Date dataHora = s.getDataHoraEntrada();

        LocalDateTime dt = LocalDateTime.ofInstant(

                dataHora.toInstant(),

                zone

        );

        String tipo = (s.getTipoOperacao() != null) ? s.getTipoOperacao().getValor() : "";

        String preco = (s.getAlvo1() != null)? s.getAlvo1().toPlainString(): "0";

        return ativo + "_" + dt.toString() + "_" + tipo + "_" + preco;

    }

    // =====================================================================

    // CARREGAR IDs JÁ EXISTENTES EM SINAIS.csv (para não duplicar)

    // =====================================================================

    private void carregarIdsSinaisExistentes() {

        Path path = Paths.get(ARQUIVO_SINAIS);

        if (!Files.exists(path)) {

            return;

        }

        try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.UTF_8)) {

            String linha;

            boolean primeira = true;

            while ((linha = reader.readLine()) != null) {

                if (primeira) {

                    primeira = false;

                    continue; // cabeçalho

                }

                if (linha.trim().isEmpty()) continue;

                String[] p = linha.split(";", -1);

                if (p.length < 1) continue;

                String id = p[0].trim();

                if (!id.isEmpty()) {

                    idsSinaisGravados.add(id);

                }

            }

            System.out.println("[ROBO-SINAIS] IDs de sinais existentes carregados: " + idsSinaisGravados.size());

        } catch (IOException e) {

            System.err.println("[ROBO-SINAIS] Erro ao carregar IDs de SINAIS.csv: " + e.getMessage());

            e.printStackTrace();

        }

    }

    // =====================================================================

    // UTILS

    // =====================================================================

    private BigDecimal parseBigDecimal(String s) {

        if (s == null) return BigDecimal.ZERO;

        s = s.trim();

        if (s.isEmpty()) return BigDecimal.ZERO;

        return new BigDecimal(s.replace(",", "."));

    }

    private String toStr(BigDecimal v) {

        if (v == null) return "";

        return v.toPlainString().replace(".", ",");

    }

}