package com.kt.ai.circuitbreaker.fallback;

import com.kt.ai.model.dto.response.EventRecommendation;
import com.kt.ai.model.dto.response.ExpectedMetrics;
import com.kt.ai.model.dto.response.TrendAnalysis;
import com.kt.ai.model.enums.EventMechanicsType;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * AI Service Fallback 처리
 * - Circuit Breaker가 열린 경우 기본 데이터 반환
 *
 * @author AI Service Team
 * @since 1.0.0
 */
@Slf4j
@Component
public class AIServiceFallback {

    /**
     * 기본 트렌드 분석 결과 반환
     */
    public TrendAnalysis getDefaultTrendAnalysis(String industry, String region) {
        log.info("Fallback: 기본 트렌드 분석 결과 반환 - industry={}, region={}", industry, region);

        List<TrendAnalysis.TrendKeyword> industryTrends = List.of(
                TrendAnalysis.TrendKeyword.builder()
                        .keyword("고객 만족도 향상")
                        .relevance(0.8)
                        .description(industry + " 업종에서 고객 만족도가 중요한 트렌드입니다")
                        .build(),
                TrendAnalysis.TrendKeyword.builder()
                        .keyword("디지털 마케팅")
                        .relevance(0.75)
                        .description("SNS 및 온라인 마케팅이 효과적입니다")
                        .build()
        );

        List<TrendAnalysis.TrendKeyword> regionalTrends = List.of(
                TrendAnalysis.TrendKeyword.builder()
                        .keyword("지역 커뮤니티")
                        .relevance(0.7)
                        .description(region + " 지역 커뮤니티 참여가 효과적입니다")
                        .build()
        );

        List<TrendAnalysis.TrendKeyword> seasonalTrends = List.of(
                TrendAnalysis.TrendKeyword.builder()
                        .keyword("시즌 이벤트")
                        .relevance(0.85)
                        .description("계절 특성을 반영한 이벤트가 효과적입니다")
                        .build()
        );

        return TrendAnalysis.builder()
                .industryTrends(industryTrends)
                .regionalTrends(regionalTrends)
                .seasonalTrends(seasonalTrends)
                .build();
    }

    /**
     * 기본 이벤트 추천안 반환
     */
    public List<EventRecommendation> getDefaultRecommendations(String objective, String industry) {
        log.info("Fallback: 기본 이벤트 추천안 반환 - objective={}, industry={}", objective, industry);

        List<EventRecommendation> recommendations = new ArrayList<>();

        // 옵션 1: 저비용 이벤트
        recommendations.add(createDefaultRecommendation(1, "저비용 SNS 이벤트", objective, industry, 100000, 200000));

        // 옵션 2: 중비용 이벤트
        recommendations.add(createDefaultRecommendation(2, "중비용 방문 유도 이벤트", objective, industry, 300000, 500000));

        // 옵션 3: 고비용 이벤트
        recommendations.add(createDefaultRecommendation(3, "고비용 프리미엄 이벤트", objective, industry, 500000, 1000000));

        return recommendations;
    }

    /**
     * 기본 추천안 생성
     */
    private EventRecommendation createDefaultRecommendation(
            int optionNumber,
            String concept,
            String objective,
            String industry,
            int minCost,
            int maxCost
    ) {
        return EventRecommendation.builder()
                .optionNumber(optionNumber)
                .concept(concept)
                .title(objective + " - " + concept)
                .description("AI 서비스가 일시적으로 사용 불가능하여 기본 추천안을 제공합니다. " +
                        industry + " 업종에 적합한 " + concept + "입니다.")
                .targetAudience("일반 고객")
                .duration(EventRecommendation.Duration.builder()
                        .recommendedDays(14)
                        .recommendedPeriod("2주")
                        .build())
                .mechanics(EventRecommendation.Mechanics.builder()
                        .type(EventMechanicsType.DISCOUNT)
                        .details("할인 쿠폰 제공 또는 경품 추첨")
                        .build())
                .promotionChannels(List.of("Instagram", "네이버 블로그", "카카오톡 채널"))
                .estimatedCost(EventRecommendation.EstimatedCost.builder()
                        .min(minCost)
                        .max(maxCost)
                        .breakdown(Map.of(
                                "경품비", minCost / 2,
                                "홍보비", minCost / 2
                        ))
                        .build())
                .expectedMetrics(ExpectedMetrics.builder()
                        .newCustomers(ExpectedMetrics.Range.builder().min(30.0).max(50.0).build())
                        .revenueIncrease(ExpectedMetrics.Range.builder().min(10.0).max(20.0).build())
                        .roi(ExpectedMetrics.Range.builder().min(100.0).max(150.0).build())
                        .build())
                .differentiator("AI 분석이 제한적으로 제공되는 기본 추천안입니다")
                .build();
    }
}
