@SpringBootApplication
@EnableEurekaServer
public class DiscoveryServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(DiscoveryServiceApplication.class, args);
    }
}

@Configuration
public class PlanWebClientConfig {
    
    @Bean
    @LoadBalanced  // Eureka 서비스명으로 호출
    public WebClient.Builder webClientBuilder() {
        return WebClient.builder();
    }
}

@Service
public class PlanServiceClientImpl implements PlanServiceClient {
    
    private final WebClient webClient;
    
    public PlanServiceClientImpl(WebClient.Builder builder) {
        // "plan-service"는 Eureka에 등록된 서비스명
        this.webClient = builder.baseUrl("http://plan-service").build();
    }
    
    @Override
    public Mono<ApiResponse<List<PlanDto>>> getPlans(String sortBy) {
        return webClient.get()
                .uri("/api/plans?sortBy={sortBy}", sortBy)
                .retrieve()
                .bodyToMono(new ParameterizedTypeReference<>() {})
                .retryWhen(Retry.backoff(3, Duration.ofSeconds(1)))
                .timeout(Duration.ofSeconds(30));
    }
}

// 문제점: 로그 저장 지연이 사용자 응답 지연으로 이어짐
chatLogService.saveToRedis(userId, message);      // 50ms
chatLogService.saveToMongoDB(userId, message);    // 100ms
return response;  // 총 150ms 지연

// Producer (Chatbot Service)
@Service
public class ChatLogProducer {
    
    private final KafkaTemplate<String, ChatLogEvent> kafkaTemplate;
    
    public void sendUserMessage(String userId, String sessionId, String message) {
        ChatLogEvent event = ChatLogEvent.ofUserMessage(userId, sessionId, message);
        kafkaTemplate.send("chat-logs", sessionId, event);  // 비동기 전송
        // 즉시 리턴 (1ms 미만)
    }
}

// Consumer (별도 스레드)
@Service
public class ChatLogConsumer {
    
    @KafkaListener(topics = "chat-logs", groupId = "chatbot-service-group")
    public void handleChatLog(ChatLogEvent event) {
        // 백그라운드에서 처리
        saveToRedis(event);
        saveToMongoDB(event);
    }
}

@RestController
@RequestMapping("/api/chat")
public class ChatBotController {
    
    @PostMapping(produces = MediaType.APPLICATION_NDJSON_VALUE)
    public Flux<ChatResponseDto> chat(@RequestBody ChatRequestDto request) {
        return chatStateDispatcher.dispatch(userId, request)
                .delayElements(Duration.ofMillis(100));  // 스트리밍 효과
    }
}

// Tier 1: 메모리 캐시 (PlanProvider)
@Component
public class PlanProvider {
    private List<PlanDto> plans;  // JVM 힙 메모리
    
    @PostConstruct
    private void init() {
        // 서버 시작 시 Plan Service에서 로드
        this.plans = planServiceClient.getPlans("popular").block().getData();
    }
    
    public List<PlanDto> getPlans() {
        return plans;  // 1ms 미만 (메모리 조회)
    }
}

// Tier 2: Redis 캐시 (JWT Refresh Token)
@Service
public class TokenService {
    
    @Cacheable(value = "refreshTokens", key = "#userId")
    public String getRefreshToken(String userId) {
        return refreshTokenRepository.findByUserId(userId);
    }
}

// 초기 시도: Feign Client (실패)
@FeignClient(name = "plan-service")
public interface PlanServiceClient {
    @GetMapping("/api/plans")
    List<PlanDto> getPlans(@RequestParam String sortBy);  // 동기 블로킹
}

// 에러 발생
BeanCreationException: No qualifying bean of type 
'org.springframework.boot.autoconfigure.http.HttpMessageConverters' available

// LLM이 예상치 못한 응답 반환
{
  "reply": "추천 요금제입니다.",
  "planIds": ["OTT_PLAN_1", "BASIC_001"]  // 존재하지 않는 ID!
}

// 에러 발생
NotFoundException: 요금제를 찾을 수 없습니다: OTT_PLAN_1

private String getTopicBasePrompt(Topic topic) {
    return basePrompt + """
        
        🔴 중요 규칙:
        1. planIds는 반드시 위에 제공된 요금제 목록의 'id' 필드에서만 선택하세요
        2. planIds는 UUID 형식이어야 합니다 (예: "550e8400-e29b-41d4-a716-446655440000")
        3. 임의로 만들어낸 ID (예: "OTT_PLAN_1", "BASIC_001")는 절대 사용하지 마세요
        4. 적절한 요금제가 없으면 planIds 필드를 생략하세요
        """;
}

@Component
public class CardFactory {
    
    public List<Card> createFromPlanIds(List<String> planIds) {
        return planIds.stream()
                .map(planId -> {
                    try {
                        return planProvider.getPlanById(planId);
                    } catch (NotFoundException e) {
                        // LLM이 잘못된 ID를 반환한 경우 무시
                        log.warn("⚠️ 존재하지 않는 요금제 ID 무시: {}", planId);
                        return null;
                    }
                })
                .filter(Objects::nonNull)
                .map(plan -> Card.builder().value(plan).build())
                .toList();
    }
}

@Service
public class ChatLogProducer {
    
    public void sendChatLog(ChatLogEvent event) {
        // sessionId를 Key로 사용 → 같은 파티션으로 전송
        String key = event.getSessionId();
        
        kafkaTemplate.send("chat-logs", key, event);
    }
}

@Component
public class PlanProvider {
    
    @PostConstruct
    private void init() {
        // Plan Service가 실행 안 되면 여기서 예외 발생
        this.plans = planServiceClient.getPlans("popular").block();
        // → Chatbot Service 전체가 시작 실패!
    }
}

@PostConstruct
private void init() {
    try {
        log.info("PlanProvider 초기화: 요금제 목록 로드 중...");
        
        ApiResponse<List<PlanDto>> response = planServiceClient.getPlans("popular")
                .block();
        
        if (response != null && response.getData() != null) {
            this.plans = List.copyOf(response.getData());
            log.info("PlanProvider 초기화 완료: {} 개 요금제 로드", plans.size());
        } else {
            log.warn("PlanProvider 초기화: 응답이 null, 빈 리스트로 초기화");
            this.plans = List.of();
        }
    } catch (Exception e) {
        // 예외 발생 시 빈 리스트로 초기화하고 서비스는 정상 시작
        log.error("PlanProvider 초기화 실패: {}", e.getMessage(), e);
        this.plans = List.of();  // 빈 리스트로 초기화
    }
}

@CircuitBreaker(name = "plan-service", fallbackMethod = "getPlansFromCache")
public Mono<List<PlanDto>> getPlans() {
    return planServiceClient.getPlans("popular");
}

public Mono<List<PlanDto>> getPlansFromCache(Exception e) {
    log.warn("Plan Service 장애, 캐시 사용");
    return Mono.just(cachedPlans);
}

@Configuration
public class CorsConfig {
    
    @Bean
    public CorsWebFilter corsWebFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowedOrigins(Arrays.asList(
            "http://localhost:3000",
            "http://127.0.0.1:3000"
        ));
        config.setAllowedMethods(Arrays.asList("*"));
        config.setAllowedHeaders(Arrays.asList("*"));
        config.setAllowCredentials(true);
        
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", config);
        
        return new CorsWebFilter(source);
    }
}

// Before: 직접 의존
@Service
public class ChatBotService {
    @Autowired
    private PlanService planService;  // 강한 결합
}

// After: HTTP/REST 통신
@Service
public class ChatBotService {
    private final PlanServiceClient client;  // 인터페이스
    // 서비스 경계 명확, 독립 배포 가능
}