package com.kt.event.eventservice.infrastructure.kafka;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.kt.event.eventservice.application.dto.kafka.ImageGenerationJobMessage;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.concurrent.CompletableFuture;

/**
 * 이미지 생성 작업 메시지 발행 Producer
 *
 * image-generation-job 토픽에 이미지 생성 작업 메시지를 발행합니다.
 *
 * @author Event Service Team
 * @version 1.0.0
 * @since 2025-10-29
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class ImageJobKafkaProducer {

    private final KafkaTemplate<String, Object> kafkaTemplate;
    private final ObjectMapper objectMapper;

    @Value("${app.kafka.topics.image-generation-job:image-generation-job}")
    private String imageGenerationJobTopic;

    /**
     * 이미지 생성 작업 메시지 발행
     *
     * @param jobId 작업 ID (JOB-{type}-{timestamp}-{random8})
     * @param userId 사용자 ID
     * @param eventId 이벤트 ID (EVT-{storeId}-{yyyyMMddHHmmss}-{random8})
     * @param prompt 이미지 생성 프롬프트
     */
    public void publishImageGenerationJob(
            String jobId,
            String userId,
            String eventId,
            String prompt) {

        ImageGenerationJobMessage message = ImageGenerationJobMessage.builder()
            .jobId(jobId)
            .userId(userId)
            .eventId(eventId)
            .prompt(prompt)
            .status("PENDING")
            .createdAt(LocalDateTime.now())
            .build();

        publishMessage(message);
    }

    /**
     * 이미지 생성 작업 메시지 발행
     *
     * @param message ImageGenerationJobMessage 객체
     */
    public void publishMessage(ImageGenerationJobMessage message) {
        try {
            // JSON 문자열로 변환
            String jsonMessage = objectMapper.writeValueAsString(message);

            CompletableFuture<SendResult<String, Object>> future =
                kafkaTemplate.send(imageGenerationJobTopic, message.getJobId(), jsonMessage);

            future.whenComplete((result, ex) -> {
                if (ex == null) {
                    log.info("이미지 생성 작업 메시지 발행 성공 - Topic: {}, JobId: {}, EventId: {}, Offset: {}",
                        imageGenerationJobTopic,
                        message.getJobId(),
                        message.getEventId(),
                        result.getRecordMetadata().offset());
                } else {
                    log.error("이미지 생성 작업 메시지 발행 실패 - Topic: {}, JobId: {}, Error: {}",
                        imageGenerationJobTopic,
                        message.getJobId(),
                        ex.getMessage(), ex);
                }
            });
        } catch (Exception e) {
            log.error("이미지 생성 작업 메시지 발행 중 예외 발생 - JobId: {}, Error: {}",
                message.getJobId(), e.getMessage(), e);
        }
    }
}
