package com.example.batch.job;
 
import com.example.batch.domain.User;
import com.example.batch.domain.ProcessedUser;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.JobScope;
import org.springframework.batch.core.configuration.annotation.StepScope;
import org.springframework.batch.core.job.builder.JobBuilder;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.builder.StepBuilder;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.batch.item.database.JdbcPagingItemReader;
import org.springframework.batch.item.database.Order;
import org.springframework.batch.item.database.support.SqlPagingQueryProviderFactoryBean;
import org.springframework.batch.item.database.builder.JdbcBatchItemWriterBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.transaction.PlatformTransactionManager;
 
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
 
@Slf4j
@Configuration
@RequiredArgsConstructor
public class UserProcessingJobConfig {
 
    private final DataSource dataSource;
    private static final int CHUNK_SIZE = 100; // Chunk Size와 Fetch/Page Size를 일치시킴
 
    // [1] Job 빌드: 인프라의 중심인 JobRepository를 주입합니다.
    @Bean
    public Job userProcessingJob(JobRepository jobRepository, Step userProcessingStep) {
        return new JobBuilder("userProcessingJob", jobRepository)
                .start(userProcessingStep)
                .build();
    }
 
    // [2] Step 빌드: @JobScope를 통해 Job 실행 시점에 할당됩니다.
    // 트랜잭션 매니저와 Chunk Size(Commit Interval)를 여기서 설정합니다.
    @Bean
    @JobScope
    public Step userProcessingStep(JobRepository jobRepository, 
                                   PlatformTransactionManager transactionManager,
                                   JdbcPagingItemReader<User> userReader,
                                   ItemProcessor<User, ProcessedUser> userProcessor,
                                   JdbcBatchItemWriter<ProcessedUser> userWriter) {
        return new StepBuilder("userProcessingStep", jobRepository)
                .<User, ProcessedUser>chunk(CHUNK_SIZE, transactionManager) // 트랜잭션 범위 확정
                .reader(userReader)
                .processor(userProcessor)
                .writer(userWriter)
                .build();
    }
 
    // [3] ItemReader: @StepScope를 사용하여 런타임에 주입된 JobParameter를 Late Binding 합니다.
    @Bean
    @StepScope
    public JdbcPagingItemReader<User> userReader(
            @Value("#{jobParameters['requestDate']}") String requestDate) throws Exception {
        
        log.info("--> [Reader 빈 생성] JobParameters로부터 requestDate 수신: {}", requestDate);
 
        JdbcPagingItemReader<User> reader = new JdbcPagingItemReader<>();
        reader.setDataSource(dataSource);
        reader.setPageSize(CHUNK_SIZE); // 성능 최적화: Chunk Size와 동일하게 설정
        reader.setRowMapper(new BeanPropertyRowMapper<>(User.class));
 
        // 쿼리 동적 생성 및 파라미터 매핑
        SqlPagingQueryProviderFactoryBean queryProvider = new SqlPagingQueryProviderFactoryBean();
        queryProvider.setDataSource(dataSource);
        queryProvider.setSelectClause("id, name, status, update_date");
        queryProvider.setFromClause("from users");
        queryProvider.setWhereClause("where update_date = :requestDate");
        
        Map<String, Object> sortKeys = new HashMap<>();
        sortKeys.add("id", Order.ASCENDING);
        queryProvider.setSortKeys(sortKeys);
        
        reader.setQueryProvider(queryProvider.getObject());
 
        Map<String, Object> parameterValues = new HashMap<>();
        parameterValues.put("requestDate", requestDate);
        reader.setParameterValues(parameterValues);
 
        return reader;
    }
 
    // [4] ItemProcessor: 데이터 1건씩 가공 및 필터링을 수행합니다.
    @Bean
    @StepScope
    public ItemProcessor<User, ProcessedUser> userProcessor() {
        return user -> {
            // 비즈니스 필터링 로직: 특정 조건의 유저는 Writer로 넘기지 않고 제외
            if ("BLACK_LIST".equals(user.getStatus())) {
                log.info("--> [Processor] 블랙리스트 유저 필터링 (Skip): {}", user.getId());
                return null; // null을 반환하면 Writer로 전달되지 않습니다.
            }
            
            // 데이터 변환 (DTO 가공)
            return new ProcessedUser(user.getId(), user.getName(), "PROCESSED");
        };
    }
 
    // [5] ItemWriter: Chunk 단위(100건)로 모인 List를 받아 Bulk DB 반영을 처리합니다.
    @Bean
    @StepScope
    public JdbcBatchItemWriter<ProcessedUser> userWriter() {
        log.info("--> [Writer 빈 생성] Bulk Insert/Update 내장 래퍼 구동");
        
        return new JdbcBatchItemWriterBuilder<ProcessedUser>()
                .dataSource(dataSource)
                .sql("UPDATE users SET status = :status WHERE id = :id")
                .beanMapped()
                .build();
    }
}