package com.kt.ai.controller;

import com.kt.ai.model.dto.response.AIRecommendationResult;
import com.kt.ai.model.dto.response.EventRecommendation;
import com.kt.ai.model.dto.response.TrendAnalysis;
import com.kt.ai.service.AIRecommendationService;
import com.kt.ai.service.CacheService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Internal Recommendation Controller
 * Event Service에서 호출하는 내부 API
 *
 * @author AI Service Team
 * @since 1.0.0
 */
@Slf4j
@Tag(name = "Internal API", description = "내부 서비스 간 통신용 API")
@RestController
@RequestMapping("/api/v1/ai-service/internal/recommendations")
@RequiredArgsConstructor
public class InternalRecommendationController {

    private final AIRecommendationService aiRecommendationService;
    private final CacheService cacheService;
    private final RedisTemplate<String, Object> redisTemplate;

    /**
     * AI 추천 결과 조회
     */
    @Operation(summary = "AI 추천 결과 조회", description = "Redis에 캐시된 AI 추천 결과 조회")
    @GetMapping("/{eventId}")
    public ResponseEntity<AIRecommendationResult> getRecommendation(@PathVariable String eventId) {
        log.info("AI 추천 결과 조회 요청: eventId={}", eventId);
        AIRecommendationResult response = aiRecommendationService.getRecommendation(eventId);
        return ResponseEntity.ok(response);
    }

    /**
     * Redis 디버그: 모든 키 조회
     */
    @Operation(summary = "Redis 키 조회 (디버그)", description = "Redis에 저장된 모든 키 조회")
    @GetMapping("/debug/redis-keys")
    public ResponseEntity<Map<String, Object>> debugRedisKeys() {
        log.info("Redis 키 디버그 요청");

        Map<String, Object> result = new HashMap<>();

        try {
            // 모든 ai:* 키 조회
            Set<String> keys = redisTemplate.keys("ai:*");
            result.put("totalKeys", keys != null ? keys.size() : 0);
            result.put("keys", keys);

            // 특정 키의 값 조회
            if (keys != null && !keys.isEmpty()) {
                Map<String, Object> values = new HashMap<>();
                for (String key : keys) {
                    Object value = redisTemplate.opsForValue().get(key);
                    values.put(key, value);
                }
                result.put("values", values);
            }

            log.info("Redis 키 조회 성공: {} 개의 키 발견", keys != null ? keys.size() : 0);
        } catch (Exception e) {
            log.error("Redis 키 조회 실패", e);
            result.put("error", e.getMessage());
        }

        return ResponseEntity.ok(result);
    }

    /**
     * Redis 디버그: 특정 키 조회
     */
    @Operation(summary = "Redis 특정 키 조회 (디버그)", description = "Redis에서 특정 키의 값 조회")
    @GetMapping("/debug/redis-key/{key}")
    public ResponseEntity<Map<String, Object>> debugRedisKey(@PathVariable String key) {
        log.info("Redis 특정 키 조회 요청: key={}", key);

        Map<String, Object> result = new HashMap<>();
        result.put("key", key);

        try {
            Object value = redisTemplate.opsForValue().get(key);
            result.put("exists", value != null);
            result.put("value", value);

            log.info("Redis 키 조회: key={}, exists={}", key, value != null);
        } catch (Exception e) {
            log.error("Redis 키 조회 실패: key={}", key, e);
            result.put("error", e.getMessage());
        }

        return ResponseEntity.ok(result);
    }

    /**
     * Redis 디버그: 모든 database 검색
     */
    @Operation(summary = "모든 Redis DB 검색 (디버그)", description = "Redis database 0~15에서 ai:* 키 검색")
    @GetMapping("/debug/search-all-databases")
    public ResponseEntity<Map<String, Object>> searchAllDatabases() {
        log.info("모든 Redis database 검색 시작");

        Map<String, Object> result = new HashMap<>();
        Map<Integer, Set<String>> databaseKeys = new HashMap<>();

        try {
            // Redis connection factory를 통해 database 변경하며 검색
            var connectionFactory = redisTemplate.getConnectionFactory();

            for (int db = 0; db < 16; db++) {
                try {
                    var connection = connectionFactory.getConnection();
                    connection.select(db);

                    Set<byte[]> keyBytes = connection.keys("ai:*".getBytes());
                    if (keyBytes != null && !keyBytes.isEmpty()) {
                        Set<String> keys = new java.util.HashSet<>();
                        for (byte[] keyByte : keyBytes) {
                            keys.add(new String(keyByte));
                        }
                        databaseKeys.put(db, keys);
                        log.info("Database {} 에서 {} 개의 ai:* 키 발견", db, keys.size());
                    }

                    connection.close();
                } catch (Exception e) {
                    log.warn("Database {} 검색 실패: {}", db, e.getMessage());
                }
            }

            result.put("databasesWithKeys", databaseKeys);
            result.put("totalDatabases", databaseKeys.size());

            log.info("모든 database 검색 완료: {} 개의 database에 키 존재", databaseKeys.size());
        } catch (Exception e) {
            log.error("모든 database 검색 실패", e);
            result.put("error", e.getMessage());
        }

        return ResponseEntity.ok(result);
    }

    /**
     * Redis 디버그: 테스트 데이터 생성
     */
    @Operation(summary = "테스트 데이터 생성 (디버그)", description = "Redis에 샘플 AI 추천 데이터 저장")
    @GetMapping("/debug/create-test-data/{eventId}")
    public ResponseEntity<Map<String, Object>> createTestData(@PathVariable String eventId) {
        log.info("테스트 데이터 생성 요청: eventId={}", eventId);

        Map<String, Object> result = new HashMap<>();

        try {
            // 샘플 AI 추천 결과 생성
            AIRecommendationResult testData = AIRecommendationResult.builder()
                    .eventId(eventId)
                    .trendAnalysis(TrendAnalysis.builder()
                            .industryTrends(List.of(
                                    TrendAnalysis.TrendKeyword.builder()
                                            .keyword("BBQ 고기집")
                                            .relevance(0.95)
                                            .description("음식점 업종, 고기 구이 인기 트렌드")
                                            .build()
                            ))
                            .regionalTrends(List.of(
                                    TrendAnalysis.TrendKeyword.builder()
                                            .keyword("강남 맛집")
                                            .relevance(0.90)
                                            .description("강남구 지역 외식 인기 증가")
                                            .build()
                            ))
                            .seasonalTrends(List.of(
                                    TrendAnalysis.TrendKeyword.builder()
                                            .keyword("봄나들이 외식")
                                            .relevance(0.85)
                                            .description("봄철 야외 활동 및 외식 증가")
                                            .build()
                            ))
                            .build())
                    .recommendations(List.of(
                            EventRecommendation.builder()
                                    .optionNumber(1)
                                    .concept("SNS 이벤트")
                                    .title("인스타그램 후기 이벤트")
                                    .description("음식 사진을 인스타그램에 올리고 해시태그를 달면 할인 쿠폰 제공")
                                    .targetAudience("20-30대 SNS 활동층")
                                    .duration(EventRecommendation.Duration.builder()
                                            .recommendedDays(14)
                                            .recommendedPeriod("2주")
                                            .build())
                                    .mechanics(EventRecommendation.Mechanics.builder()
                                            .type(com.kt.ai.model.enums.EventMechanicsType.DISCOUNT)
                                            .details("인스타그램 게시물 작성 시 10% 할인")
                                            .build())
                                    .promotionChannels(List.of("Instagram", "Facebook", "매장 포스터"))
                                    .estimatedCost(EventRecommendation.EstimatedCost.builder()
                                            .min(100000)
                                            .max(200000)
                                            .breakdown(Map.of(
                                                    "할인비용", 150000,
                                                    "홍보비", 50000
                                            ))
                                            .build())
                                    .expectedMetrics(com.kt.ai.model.dto.response.ExpectedMetrics.builder()
                                            .newCustomers(com.kt.ai.model.dto.response.ExpectedMetrics.Range.builder()
                                                    .min(30.0)
                                                    .max(50.0)
                                                    .build())
                                            .revenueIncrease(com.kt.ai.model.dto.response.ExpectedMetrics.Range.builder()
                                                    .min(10.0)
                                                    .max(20.0)
                                                    .build())
                                            .roi(com.kt.ai.model.dto.response.ExpectedMetrics.Range.builder()
                                                    .min(100.0)
                                                    .max(150.0)
                                                    .build())
                                            .build())
                                    .differentiator("SNS를 활용한 바이럴 마케팅")
                                    .build()
                    ))
                    .generatedAt(java.time.LocalDateTime.now())
                    .expiresAt(java.time.LocalDateTime.now().plusDays(1))
                    .aiProvider(com.kt.ai.model.enums.AIProvider.CLAUDE)
                    .build();

            // Redis에 저장
            cacheService.saveRecommendation(eventId, testData);

            // 저장 확인
            Object saved = cacheService.getRecommendation(eventId);

            result.put("success", true);
            result.put("eventId", eventId);
            result.put("saved", saved != null);
            result.put("data", saved);

            log.info("테스트 데이터 생성 완료: eventId={}, saved={}", eventId, saved != null);
        } catch (Exception e) {
            log.error("테스트 데이터 생성 실패: eventId={}", eventId, e);
            result.put("success", false);
            result.put("error", e.getMessage());
        }

        return ResponseEntity.ok(result);
    }
}
