Subversion Repositories Integrator Subversion

package br.com.sl.domain.service.impl;

import java.math.BigDecimal;

import java.nio.file.Paths;

import java.time.Duration;

import java.time.LocalDateTime;

import java.time.temporal.ChronoUnit;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicBoolean;

import javax.inject.Singleton;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import com.itextpdf.text.log.SysoLogger;

import br.com.ec.core.generic.AbstractService;

import br.com.ec.core.generic.GenericRepository;

import br.com.ec.core.validador.Validador;

import br.com.sl.core.ExcelProfitDataProvider;

import br.com.sl.core.ExcelProfitTempoRealPorSegundoProvider;

import br.com.sl.core.ProfitDataProvider;

import br.com.sl.domain.dto.RoboDTO;

import br.com.sl.domain.dto.robo.CandleState;

import br.com.sl.domain.dto.robo.ProfitTick;

import br.com.sl.domain.service.CandleService;

import br.com.sl.domain.service.RoboColetorService;

@Singleton

@Service

public class RoboColetorServiceImpl extends AbstractService<RoboDTO> implements RoboColetorService {

        private final AtomicBoolean rodando = new AtomicBoolean(false);

        private RoboDTO roboDTO = new RoboDTO();

        private CandleService candleService;

        private ProfitDataProvider profitDataProvider;

        // estado de candle por ativo

    private final Map<String, CandleState> estados = new ConcurrentHashMap<>();

    // config básica (pode ser lido de properties)

    private static final String EXCEL_PATH = "C:/trade/temporeal.xlsx";

    private static final String EXCEL_SHEET = "Asset";

        @Autowired

        public RoboColetorServiceImpl(CandleService candleService, Validador validador) {

                super(validador);

                this.candleService = candleService;

        }

        @Override

        protected GenericRepository<RoboDTO> getRepository() {

                return null;

        }

        public RoboDTO getRoboDTO() {

                return roboDTO;

        }

        public void setRoboDTO(RoboDTO roboDTO) {

                this.roboDTO = roboDTO;

        }

        @Override

        public void iniciarColetor1Minuto() {

                RoboDTO roboDTO = new RoboDTO();

                roboDTO.setRodando(true);

                setRoboDTO(roboDTO);

                this.profitDataProvider = new ExcelProfitTempoRealPorSegundoProvider(Paths.get(EXCEL_PATH), EXCEL_SHEET);

        if (!rodando.compareAndSet(false, true)) {

            // já está rodando

            return;

        }

        Thread t = new Thread(this::loopColetor, "CandleCollector-1M");

        t.setDaemon(true);

        t.start();

    }

        private void loopColetor() {

                System.out.println("INICIANDO COLETOR DE DADOS...");

                getRoboDTO().setObservacaoRobo("INICIANDO COLETOR DE DADOS...");

                /*

                try {

                        // INICIA NO PRIMEIRO SEGUNDO DO PRÓXIMO MINUTO HH:mm:01

                        LocalDateTime agora = LocalDateTime.now();

                        LocalDateTime proximoMinuto = agora

                                        .truncatedTo(ChronoUnit.MINUTES)

                                        .plusMinutes(1)

                                        .plusSeconds(1);

                        long millisAteProximaExecucao = Duration.between(agora, proximoMinuto).toMillis();

                        if (millisAteProximaExecucao > 0) {

                                System.out.println("AGUARDANDO PARA INICIAR NO PRÓXIMO MINUTO");

                                getRoboDTO().setObservacaoRobo("AGUARDANDO PARA INICIAR NO PRÓXIMO MINUTO");

                                Thread.sleep(millisAteProximaExecucao);

                        }

                } catch (InterruptedException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                */

                System.out.println("INICIANDO CAPTURA!");

                getRoboDTO().setObservacaoRobo("INICIANDO CAPTURA!");

        while (rodando.get()) {

            try {

                // Lê ticks atuais de TODOS os ativos (snapshot)

                Map<String, ProfitTick> ticks = profitDataProvider.readCurrentTicks();

                // Atualiza estado de cada ativo

                for (Map.Entry<String, ProfitTick> entry : ticks.entrySet()) {

                    String symbol = entry.getKey();

                    ProfitTick tick = entry.getValue();

                    processarTick(symbol, tick);

                }

                // Espera 1 segundo antes da próxima leitura

                TimeUnit.SECONDS.sleep(1);

            } catch (Exception e) {

                e.printStackTrace();

                try {

                    TimeUnit.SECONDS.sleep(1);

                } catch (InterruptedException ex) {

                    Thread.currentThread().interrupt();

                }

            }

        }

        System.out.println("CAPTURA FINALIZADA!");

        getRoboDTO().setObservacaoRobo("CAPTURA FINALIZADA!");

    }

        private void processarTick(String ativo, ProfitTick tick) {

        CandleState situacaoCandle = estados.get(ativo);

        LocalDateTime tickTime = tick.getDateTime();

        // Evita processar o mesmo tick de novo (mesma data/hora)

        if (situacaoCandle != null && situacaoCandle.getLastTickTime() != null

                && tickTime.equals(situacaoCandle.getLastTickTime())) {

            return;

        }

        LocalDateTime minutoTick = tickTime.truncatedTo(ChronoUnit.MINUTES);

        BigDecimal preco = tick.getPrice();

        System.out.println("CAPTURANDO: " + preco + " [" + tickTime + "]");

        if (situacaoCandle == null) {

            // Primeiro tick desse ativo

                situacaoCandle = new CandleState(minutoTick, preco, tickTime);

            estados.put(ativo, situacaoCandle);

            return;

        }

        // Se o minuto mudou → fecha candle anterior e salva no banco

        if (!minutoTick.equals(situacaoCandle.getMinutoAtual())) {

            LocalDateTime inicioCandle = situacaoCandle.getMinutoAtual();

            LocalDateTime fimCandle = inicioCandle.plusMinutes(1);

            candleService.cadastrar(ativo, inicioCandle, fimCandle, situacaoCandle);

            // Inicia o próximo candle (novo minuto) com o tick atual

            situacaoCandle = new CandleState(minutoTick, preco, tickTime);

        } else {

                System.out.println("PREÇO: " + preco + " [" + tickTime + "]");

            // Ainda dentro do mesmo minuto → atualiza OHLC

            if (preco.compareTo(situacaoCandle.getMaxima()) > 0) {

                situacaoCandle.setMaxima(preco);

            }

            if (preco.compareTo(situacaoCandle.getMinima()) < 0) {

                situacaoCandle.setMinima(preco);

            }

            situacaoCandle.setFechamento(preco);

            situacaoCandle.setLastTickTime(tickTime);

            // volume se tiver → state.volume += ...

        }

    }

        @Override

        public void pararColetor() {

        rodando.set(false);

    }

        @Override

        public Boolean isRodando() {

                return rodando.get();

        }

        @Override

        public RoboDTO statusRobo() {

                getRoboDTO().setRodando(isRodando());

                return getRoboDTO();

        }

}