package com.goldenchart.service;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.goldenchart.entity.GcStrategy;
import com.goldenchart.repository.GcStrategyRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import java.util.LinkedHashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 전략 DSL(buy/sell LogicNode)에 포함된 조건 판별 시간봉 수집.
 * START / TIMEFRAME / AND|OR+TIMEFRAME 분기와 동일 규칙.
 */
@Service
@Slf4j
public class StrategyConditionTimeframeService {

    private final GcStrategyRepository strategyRepo;
    private final ObjectMapper objectMapper;
    private final StrategyDslTimeframeNormalizer dslNormalizer;
    private final LiveStrategyEvaluator liveStrategyEvaluator;

    private final ConcurrentHashMap<Long, Set<String>> cache = new ConcurrentHashMap<>();

    public StrategyConditionTimeframeService(
            GcStrategyRepository strategyRepo,
            ObjectMapper objectMapper,
            StrategyDslTimeframeNormalizer dslNormalizer,
            @Lazy LiveStrategyEvaluator liveStrategyEvaluator) {
        this.strategyRepo = strategyRepo;
        this.objectMapper = objectMapper;
        this.dslNormalizer = dslNormalizer;
        this.liveStrategyEvaluator = liveStrategyEvaluator;
    }

    public Set<String> collectForStrategy(long strategyId) {
        return cache.computeIfAbsent(strategyId, this::loadFromDb);
    }

    public List<String> collectForStrategyList(long strategyId) {
        return List.copyOf(collectForStrategy(strategyId));
    }

    public boolean usesTimeframe(long strategyId, String candleType) {
        String ct = LiveStrategyTimeframeService.normalize(candleType);
        return collectForStrategy(strategyId).contains(ct);
    }

    public void invalidate(long strategyId) {
        cache.remove(strategyId);
    }

    public void invalidateAll() {
        cache.clear();
    }

    private Set<String> loadFromDb(long strategyId) {
        Optional<GcStrategy> opt = strategyRepo.findById(strategyId);
        if (opt.isEmpty()) return Set.of("1m");
        GcStrategy strategy = opt.get();
        ensureDslRepaired(strategy);

        Set<String> buyOut = new LinkedHashSet<>();
        Set<String> sellOut = new LinkedHashSet<>();
        boolean buyScoped = collectStartScopeFromJson(strategy.getBuyConditionJson(), buyOut);
        boolean sellScoped = collectStartScopeFromJson(strategy.getSellConditionJson(), sellOut);

        // 평가 분봉은 buy/sell DSL(TIMEFRAME·START)이 단일 원천 — flow_layout 은 편집기 UI 보조
        if (buyScoped && !buyOut.isEmpty()) {
            return sanitizeEvaluationTimeframes(buyOut, strategy);
        }
        if (sellScoped && !sellOut.isEmpty()) {
            return sanitizeEvaluationTimeframes(sellOut, strategy);
        }

        Set<String> out = new LinkedHashSet<>();

        // 레거시: START(TIMEFRAME) 래핑 없는 DSL
        if (!buyScoped) {
            collectLegacyFromJson(strategy.getBuyConditionJson(), out, strategy.getName());
        }
        if (!sellScoped) {
            collectLegacyFromJson(strategy.getSellConditionJson(), out, strategy.getName());
        }

        if (out.isEmpty()) {
            Set<String> fromFlowLayout = collectFromFlowLayoutJson(strategy.getFlowLayoutJson());
            if (!fromFlowLayout.isEmpty()) {
                return sanitizeEvaluationTimeframes(fromFlowLayout, strategy);
            }
            String fromName = StrategyDslTimeframeNormalizer.inferFromStrategyName(strategy.getName());
            return Set.of(fromName != null ? fromName : "1m");
        }
        return sanitizeEvaluationTimeframes(out, strategy);
    }

    /**
     * START/flow 에만 남은 stale 1m 제거 — CONDITION 에 선언된 분봉 기준(기본값 1m 제외).
     */
    private Set<String> sanitizeEvaluationTimeframes(Set<String> scope, GcStrategy strategy) {
        if (!scope.contains("1m") || scope.size() <= 1) return scope;

        Set<String> conditionDeclared = collectConditionDeclaredFromStrategy(strategy);
        if (conditionDeclared.contains("1m") && conditionDeclared.size() > 1) {
            return scope;
        }
        if (!conditionDeclared.contains("1m")) {
            Set<String> filtered = new LinkedHashSet<>(scope);
            filtered.remove("1m");
            return filtered.isEmpty() ? scope : filtered;
        }
        if (conditionDeclared.equals(Set.of("1m"))) {
            Set<String> filtered = new LinkedHashSet<>(scope);
            filtered.remove("1m");
            return filtered.isEmpty() ? scope : filtered;
        }
        return scope;
    }

    private Set<String> collectConditionDeclaredFromStrategy(GcStrategy strategy) {
        Set<String> out = new LinkedHashSet<>();
        collectConditionDeclaredFromJson(strategy.getBuyConditionJson(), out);
        collectConditionDeclaredFromJson(strategy.getSellConditionJson(), out);
        return out;
    }

    private void collectConditionDeclaredFromJson(String json, Set<String> out) {
        if (json == null || json.isBlank()) return;
        try {
            out.addAll(StrategyDslTimeframeNormalizer.collectConditionDeclaredCandleTypes(
                    objectMapper.readTree(json)));
        } catch (Exception e) {
            log.warn("[StrategyTimeframes] condition-declared JSON 파싱 실패: {}", e.getMessage());
        }
    }

    /** TIMEFRAME 누락·잘못된 1m 래핑을 전략명·DSL 기준으로 DB 보정 */
    private void ensureDslRepaired(GcStrategy strategy) {
        boolean changed = false;
        String name = strategy.getName();

        String buyJson = strategy.getBuyConditionJson();
        String sellJson = strategy.getSellConditionJson();
        if (buyJson != null && !buyJson.isBlank()
                && sellJson != null && !sellJson.isBlank()) {
            String alignedSell = dslNormalizer.alignSellStartTimeframeToBuy(buyJson, sellJson);
            if (!alignedSell.equals(sellJson)) {
                strategy.setSellConditionJson(alignedSell);
                sellJson = alignedSell;
                changed = true;
            }
        }

        if (strategy.getBuyConditionJson() != null && !strategy.getBuyConditionJson().isBlank()) {
            String fixed = dslNormalizer.normalizeJson(strategy.getBuyConditionJson(), name);
            if (!fixed.equals(strategy.getBuyConditionJson())) {
                strategy.setBuyConditionJson(fixed);
                changed = true;
            }
        }
        if (sellJson != null && !sellJson.isBlank()) {
            String fixed = dslNormalizer.normalizeJson(sellJson, name);
            if (!fixed.equals(strategy.getSellConditionJson())) {
                strategy.setSellConditionJson(fixed);
                changed = true;
            }
        }

        if (changed) {
            strategyRepo.save(strategy);
            liveStrategyEvaluator.invalidateStrategy(strategy.getId());
            log.info("[StrategyTimeframes] DSL 분봉 보정 strategyId={} name={}",
                    strategy.getId(), name);
        }
    }

    /**
     * START 루트 TIMEFRAME(candleTypes)만 수집 — 조건 노드 leftCandleType·내부 1m 기본값은 제외.
     *
     * @return JSON 에 START 스코프가 있으면 true (빈 조건이어도)
     */
    private boolean collectStartScopeFromJson(String json, Set<String> out) {
        if (json == null || json.isBlank()) return false;
        try {
            return collectStartScopeFromNode(objectMapper.readTree(json), out);
        } catch (Exception e) {
            log.warn("[StrategyTimeframes] JSON 파싱 실패: {}", e.getMessage());
            return false;
        }
    }

    private boolean collectStartScopeFromNode(JsonNode node, Set<String> out) {
        if (node == null || node.isNull()) return false;
        return collectTimeframesFromNode(node, out);
    }

    /** 레거시 DSL — START 래핑 없을 때만 조건 트리·전략명에서 추론 */
    private void collectLegacyFromJson(String json, Set<String> out, String strategyName) {
        if (json == null || json.isBlank()) return;
        try {
            collectLegacyFromNode(objectMapper.readTree(json), out, strategyName);
        } catch (Exception e) {
            log.warn("[StrategyTimeframes] legacy JSON 파싱 실패: {}", e.getMessage());
            addFallbackTimeframe(out, strategyName);
        }
    }

    private void collectLegacyFromNode(JsonNode node, Set<String> out, String strategyName) {
        if (node == null || node.isNull()) return;

        Set<String> meaningful = StrategyDslTimeframeNormalizer.collectMeaningfulCandleTypes(node);
        if (!meaningful.isEmpty()) {
            out.addAll(meaningful);
            return;
        }

        String fromName = StrategyDslTimeframeNormalizer.inferFromStrategyName(strategyName);
        if (fromName != null) {
            out.add(fromName);
            return;
        }

        addFallbackTimeframe(out, strategyName);
    }

    private void addFallbackTimeframe(Set<String> out, String strategyName) {
        String fromName = StrategyDslTimeframeNormalizer.inferFromStrategyName(strategyName);
        out.add(fromName != null ? fromName : "1m");
    }

    /**
     * 트리에서 TIMEFRAME 노드를 수집. 발견 시 true.
     */
    private boolean collectTimeframesFromNode(JsonNode node, Set<String> out) {
        if (node == null || node.isNull()) return false;
        String type = node.path("type").asText("");

        if ("TIMEFRAME".equals(type)) {
            addTimeframeCandleTypes(node, out);
            return true;
        }

        if ("AND".equals(type) || "OR".equals(type)) {
            JsonNode children = node.path("children");
            if (children.isArray() && !children.isEmpty()) {
                if (allTimeframeChildren(children)) {
                    for (JsonNode tf : children) {
                        addTimeframeCandleTypes(tf, out);
                    }
                    return true;
                }
                boolean found = false;
                for (JsonNode child : children) {
                    found |= collectTimeframesFromNode(child, out);
                }
                return found;
            }
        }

        JsonNode child = node.path("child");
        if (!child.isMissingNode() && !child.isNull()) {
            return collectTimeframesFromNode(child, out);
        }

        return false;
    }

    private static boolean allTimeframeChildren(JsonNode children) {
        for (JsonNode c : children) {
            if (!"TIMEFRAME".equals(c.path("type").asText(""))) return false;
        }
        return true;
    }

    /** TIMEFRAME 노드 — candleTypes 배열 또는 단일 candleType (stale 1m 제거 반영) */
    static void addTimeframeCandleTypes(JsonNode timeframeNode, Set<String> out) {
        for (String ct : StrategyDslTimeframeNormalizer.resolveStartCandleTypes(timeframeNode)) {
            out.add(ct);
        }
    }

    /** flow_layout_json.startMeta — 편집기 Logic Expression·START 분봉 (DSL과 동기 저장) */
    private Set<String> collectFromFlowLayoutJson(String flowLayoutJson) {
        Set<String> out = new LinkedHashSet<>();
        if (flowLayoutJson == null || flowLayoutJson.isBlank()) return out;
        try {
            JsonNode root = objectMapper.readTree(flowLayoutJson);
            for (String side : new String[] { "buy", "sell" }) {
                JsonNode startMeta = root.path(side).path("startMeta");
                if (!startMeta.isObject()) continue;
                startMeta.fields().forEachRemaining(entry -> {
                    JsonNode meta = entry.getValue();
                    JsonNode types = meta.path("candleTypes");
                    if (types.isArray() && !types.isEmpty()) {
                        for (JsonNode t : types) {
                            String ct = LiveStrategyTimeframeService.normalize(t.asText(""));
                            if (!ct.isBlank()) out.add(ct);
                        }
                    } else {
                        String ct = LiveStrategyTimeframeService.normalize(meta.path("candleType").asText(""));
                        if (!ct.isBlank()) out.add(ct);
                    }
                });
            }
        } catch (Exception e) {
            log.warn("[StrategyTimeframes] flow_layout_json 파싱 실패: {}", e.getMessage());
        }
        return out;
    }
}