// 모든 경우의 수를 메서드로 만들어야 함
List<Order> findByMemberName(String memberName);
List<Order> findByShippingStatus(ShippingStatus status);
List<Order> findByMemberNameAndShippingStatus(String memberName, ShippingStatus status);
List<Order> findByMemberNameAndShippingStatusAndCreatedAtBetween(...);
// 🔴 조합이 늘어날수록 메서드가 기하급수적으로 증가!

// 검색 조건들을 레고 블록처럼 자유롭게 조합
Specification<Order> spec = Specification
    .where(OrderSpecification.withMemberName(memberName))      // 🧩 토핑 1
    .and(OrderSpecification.withShippingStatus(status))        // 🧩 토핑 2  
    .and(OrderSpecification.betweenDates(startDate, endDate)); // 🧩 토핑 3

List<Order> orders = orderRepository.findAll(spec); // 🍕 맞춤형 피자 완성!

package com.kobe.productmanagement.repository.specification;

import com.kobe.productmanagement.common.ShippingStatus;
import com.kobe.productmanagement.domain.Member;
import com.kobe.productmanagement.domain.Order;
import jakarta.persistence.criteria.Join;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.util.StringUtils;

import java.time.LocalDate;
import java.time.LocalTime;

public class OrderSpecification {

    // 🔍 회원 이름으로 검색하는 Specification
    public static Specification<Order> withMemberName(String memberName) {
        return (root, query, criteriaBuilder) -> {
            // 🟢 null/빈 문자열 체크로 안전성 확보
            if (!StringUtils.hasText(memberName)) {
                return null; // 조건이 없으면 무시됨
            }
            Join<Order, Member> memberJoin = root.join("member");
            return criteriaBuilder.like(memberJoin.get("memberName"), "%" + memberName + "%");
        };
    }

    // 📦 배송 상태로 검색하는 Specification  
    public static Specification<Order> withShippingStatus(ShippingStatus status) {
        return (root, query, criteriaBuilder) -> {
            if (status == null) {
                return null;
            }
            return criteriaBuilder.equal(root.get("shippingStatus"), status);
        };
    }

    // 📅 주문 날짜 범위로 검색하는 Specification
    public static Specification<Order> betweenDates(LocalDate startDate, LocalDate endDate) {
        return (root, query, criteriaBuilder) -> {
            if (startDate == null || endDate == null) {
                return null;
            }
            return criteriaBuilder.between(
                root.get("createdAt"), 
                startDate.atStartOfDay(), 
                endDate.atTime(LocalTime.MAX)
            );
        };
    }
}

package com.kobe.productmanagement.service;

import com.kobe.productmanagement.domain.Order;
import com.kobe.productmanagement.dto.request.OrderSearchRequest;
import com.kobe.productmanagement.dto.request.OrderStatusUpdateRequest;
import com.kobe.productmanagement.dto.response.OrderResponse;
import com.kobe.productmanagement.repository.OrderRepository;
import com.kobe.productmanagement.repository.specification.OrderSpecification; // 🟢 신규 import
import lombok.RequiredArgsConstructor;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
@Transactional
public class OrderServiceImpl implements OrderService {

    private final OrderRepository orderRepository;

    @Override
    @Transactional(readOnly = true)
    public List<OrderResponse> getAllOrders(OrderSearchRequest searchRequest) {
        // 🧩 Specification들을 레고 블록처럼 체인 형태로 조합
        Specification<Order> spec = Specification
            .where(OrderSpecification.withMemberName(searchRequest.getMemberName()))
            .and(OrderSpecification.withShippingStatus(searchRequest.getShippingStatus()))
            .and(OrderSpecification.betweenDates(searchRequest.getStartDate(), searchRequest.getEndDate()));

        return orderRepository.findAll(spec).stream()
                .map(OrderResponse::from)
                .collect(Collectors.toList());
    }

    @Override
    public OrderResponse updateOrderState(String orderId, OrderStatusUpdateRequest request) {
        Order order = orderRepository.findById(orderId)
                .orElseThrow(() -> new IllegalArgumentException("해당 주문을 찾을 수 없습니다 ID: " + orderId));

        order.updateDetails(request.getStatus());
        return OrderResponse.from(order);
    }

    // 🗑️ 기존의 복잡한 private searchOrders 메서드는 이제 삭제!
}

// 다른 서비스에서도 동일한 Specification 재사용 가능
public class AdminService {
    public List<Order> getVipOrders() {
        return orderRepository.findAll(
            OrderSpecification.withShippingStatus(ShippingStatus.DELIVERED)
                .and(OrderSpecification.withMemberName("VIP"))
        );
    }
}

// ❌ 기존: 복잡한 쿼리 생성 로직이 서비스에 섞임
if (memberName != null) {
    // 복잡한 Criteria API 코드...
}
if (status != null) {
    // 또 다른 복잡한 코드...
}

// ✅ 개선: 선언적이고 명확한 의도 표현
Specification<Order> spec = Specification
    .where(OrderSpecification.withMemberName(memberName))
    .and(OrderSpecification.withShippingStatus(status));

// 🎪 복잡한 조건도 자유자재로 조합 가능
Specification<Order> complexSpec = Specification
    .where(OrderSpecification.withMemberName("김철수"))
    .and(OrderSpecification.withShippingStatus(ShippingStatus.SHIPPED))
    .or(OrderSpecification.betweenDates(startDate, endDate))
    .and(Specification.not(OrderSpecification.withShippingStatus(ShippingStatus.CANCELLED)));

// ✅ 좋은 네이밍: 의도가 명확함
OrderSpecification.withMemberName()
OrderSpecification.betweenDates()
OrderSpecification.hasShippingStatus()

// ❌ 나쁜 네이밍: 의도가 불분명
OrderSpecification.memberName()
OrderSpecification.dates()
OrderSpecification.status()

// 🟢 항상 null 체크를 통해 안전성 확보
public static Specification<Order> withMemberName(String memberName) {
    return (root, query, criteriaBuilder) -> {
        if (!StringUtils.hasText(memberName)) {
            return null; // null 반환 시 해당 조건은 무시됨
        }
        // 실제 조건 로직...
    };
}

// 실무에서 자주 사용되는 복잡한 검색 조건
Specification<Order> spec = Specification
    .where(OrderSpecification.withMemberName(searchRequest.getMemberName()))
    .and(OrderSpecification.withShippingStatus(searchRequest.getStatus()))
    .and(OrderSpecification.betweenDates(searchRequest.getStartDate(), searchRequest.getEndDate()))
    .and(OrderSpecification.withMinAmount(searchRequest.getMinAmount()))
    .or(OrderSpecification.isVipOrder());