// build.gradle (Spring Boot 3.x MSA 기본 설정)
plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.0'
    id 'io.spring.dependency-management' version '1.1.4'
}

java {
    sourceCompatibility = JavaVersion.VERSION_17
}

dependencies {
    // Spring Boot 기본
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    
    // Spring Cloud (MSA 핵심!)
    implementation 'org.springframework.cloud:spring-cloud-starter-netflix-eureka-client'
    implementation 'org.springframework.cloud:spring-cloud-starter-config'
    
    // 보안
    implementation 'org.springframework.boot:spring-boot-starter-security'
    
    // 모니터링
    implementation 'io.micrometer:micrometer-registry-prometheus'
    
    // 테스트
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

dependencyManagement {
    imports {
        mavenBom "org.springframework.cloud:spring-cloud-dependencies:2023.0.0"
    }
}

// application.yml - API Gateway 라우팅 설정
spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://USER-SERVICE        # 로드밸런서를 통해 Eureka에서 찾음
          predicates:
            - Path=/api/users/**
          filters:
            - StripPrefix=1             # /api 제거 후 전달
            - name: CircuitBreaker      # 서킷브레이커 적용
              args:
                name: userServiceCB
                fallbackUri: forward:/fallback/user
                
        - id: order-service
          uri: lb://ORDER-SERVICE
          predicates:
            - Path=/api/orders/**
          filters:
            - StripPrefix=1
            - AddRequestHeader=X-Request-Source, gateway  # 헤더 추가
            
        - id: payment-service
          uri: lb://PAYMENT-SERVICE
          predicates:
            - Path=/api/payments/**
            - Method=POST,GET           # 특정 HTTP 메서드만 허용
          filters:
            - StripPrefix=1

// JwtAuthenticationFilter.java
@Component
public class JwtAuthenticationFilter implements GlobalFilter, Ordered {

    private final JwtTokenProvider jwtTokenProvider;
    
    // 인증 불필요 경로
    private static final List<String> WHITELIST = List.of(
        "/api/users/login",
        "/api/users/register",
        "/actuator/health"
    );

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String path = exchange.getRequest().getPath().value();
        
        // 화이트리스트 경로는 통과
        if (WHITELIST.stream().anyMatch(path::startsWith)) {
            return chain.filter(exchange);
        }
        
        // Authorization 헤더에서 JWT 추출
        String token = extractToken(exchange.getRequest());
        
        if (token == null || !jwtTokenProvider.validateToken(token)) {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        
        // 사용자 정보를 헤더에 추가해서 하위 서비스로 전달
        String userId = jwtTokenProvider.getUserId(token);
        ServerHttpRequest mutatedRequest = exchange.getRequest()
            .mutate()
            .header("X-User-Id", userId)
            .build();
            
        return chain.filter(exchange.mutate().request(mutatedRequest).build());
    }

    @Override
    public int getOrder() {
        return -1; // 최우선 실행
    }
}

// EurekaServerApplication.java
@SpringBootApplication
@EnableEurekaServer  // 이 한 줄로 Eureka Server 완성!
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

// application.yml (Eureka Server)
server:
  port: 8761

eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false   # 자기 자신은 등록 안 함
    fetchRegistry: false
  server:
    enableSelfPreservation: false  # 개발환경에서는 비활성화

// 각 마이크로서비스 application.yml (Eureka Client)
spring:
  application:
    name: ORDER-SERVICE   # 서비스 이름 (대문자 권장)

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    preferIpAddress: true
    instanceId: ${spring.application.name}:${server.port}

// application.yml - Resilience4j 서킷브레이커 설정
resilience4j:
  circuitbreaker:
    instances:
      userService:
        slidingWindowSize: 10           # 최근 10번의 요청 기준
        failureRateThreshold: 50        # 50% 실패 시 OPEN
        waitDurationInOpenState: 10s    # 10초 후 HALF-OPEN
        permittedNumberOfCallsInHalfOpenState: 3
        
  retry:
    instances:
      userService:
        maxAttempts: 3                  # 최대 3번 재시도
        waitDuration: 1s
        
  timelimiter:
    instances:
      userService:
        timeoutDuration: 3s             # 3초 타임아웃

// 서비스에서 사용
@Service
public class OrderService {

    @CircuitBreaker(name = "userService", fallbackMethod = "getUserFallback")
    @Retry(name = "userService")
    @TimeLimiter(name = "userService")
    public CompletableFuture<UserResponse> getUser(Long userId) {
        return CompletableFuture.supplyAsync(() -> 
            userServiceClient.getUserById(userId)
        );
    }
    
    // 폴백 메서드
    public CompletableFuture<UserResponse> getUserFallback(Long userId, Exception e) {
        log.warn("User Service 장애 - 기본값 반환, userId: {}", userId);
        return CompletableFuture.completedFuture(UserResponse.defaultUser(userId));
    }
}

// build.gradle - 분산 추적 의존성
dependencies {
    // Micrometer Tracing (Spring Boot 3.x 표준)
    implementation 'io.micrometer:micrometer-tracing-bridge-brave'
    implementation 'io.zipkin.reporter2:zipkin-reporter-brave'
    
    // Prometheus 메트릭
    implementation 'io.micrometer:micrometer-registry-prometheus'
    
    // Spring Boot Actuator (헬스체크, 메트릭 엔드포인트)
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
}

// application.yml
management:
  tracing:
    sampling:
      probability: 1.0    # 100% 샘플링 (운영에선 0.1 정도로)
  zipkin:
    tracing:
      endpoint: http://zipkin:9411/api/v2/spans
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  metrics:
    tags:
      application: ${spring.application.name}

# Dockerfile (Spring Boot 3.x 최적화)
FROM eclipse-temurin:17-jre-alpine AS base
WORKDIR /app

# 레이어 캐싱 최적화 (Spring Boot 레이어드 JAR)
ARG JAR_FILE=build/libs/*.jar
COPY ${JAR_FILE} app.jar

RUN java -Djarmode=layertools -jar app.jar extract

FROM eclipse-temurin:17-jre-alpine
WORKDIR /app

COPY --from=base /app/dependencies/ ./
COPY --from=base /app/spring-boot-loader/ ./
COPY --from=base /app/snapshot-dependencies/ ./
COPY --from=base /app/application/ ./

ENTRYPOINT ["java", "org.springframework.boot.loader.launch.JarLauncher"]

# Gradle로 직접 Docker 이미지 빌드 (Buildpacks 사용)
./gradlew bootBuildImage --imageName=my-service:latest

# 또는 build.gradle에 설정
tasks.named("bootBuildImage") {
    imageName = "my-registry/order-service:${version}"
    builder = "paketobuildpacks/builder:base"
    environment = ["BP_JVM_VERSION": "17"]
}

# kubernetes/order-service-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
  labels:
    app: order-service
spec:
  replicas: 3                    # 3개 인스턴스 운영
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      containers:
      - name: order-service
        image: my-registry/order-service:1.0.0
        ports:
        - containerPort: 8082
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "prod"
        - name: EUREKA_CLIENT_SERVICEURL_DEFAULTZONE
          value: "http://eureka-server:8761/eureka/"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:           # 헬스체크
          httpGet:
            path: /actuator/health/liveness
            port: 8082
          initialDelaySeconds: 30
        readinessProbe:
          httpGet:
            path: /actuator/health/readiness
            port: 8082
          initialDelaySeconds: 20

# Native Image 빌드 (GraalVM 설치 필요)
./gradlew nativeCompile

# 또는 Docker로 Native Image 빌드
./gradlew bootBuildImage --imageName=order-service:native \
  -Pspring.aot.enabled=true

# build.gradle에 AOT 설정
plugins {
    id 'org.graalvm.buildtools.native' version '0.9.28'
}

graalvmNative {
    binaries {
        main {
            imageName = 'order-service'
            buildArgs.add('--initialize-at-build-time')
            buildArgs.add('-H:+ReportExceptionStackTraces')
        }
    }
}

// Spring Security 6.0 설정 (Lambda DSL 방식)
@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            // CSRF 비활성화 (REST API는 세션 없음)
            .csrf(csrf -> csrf.disable())
            
            // 세션 사용 안 함 (JWT 사용)
            .sessionManagement(session -> 
                session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            
            // 요청 권한 설정
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/actuator/health/**").permitAll()
                .requestMatchers(HttpMethod.POST, "/users/register").permitAll()
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            
            // JWT 필터 추가
            .addFilterBefore(
                jwtAuthenticationFilter, 
                UsernamePasswordAuthenticationFilter.class
            )
            
            // 예외 처리
            .exceptionHandling(ex -> ex
                .authenticationEntryPoint(customAuthenticationEntryPoint)
                .accessDeniedHandler(customAccessDeniedHandler)
            )
            .build();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

// Java 21 Virtual Threads 활성화 (Spring Boot 3.2+)
// application.yml
spring:
  threads:
    virtual:
      enabled: true

// 또는 코드로 설정
@Bean
public TomcatProtocolHandlerCustomizer<?> protocolHandlerVirtualThreadExecutorCustomizer() {
    return protocolHandler -> {
        protocolHandler.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
    };
}