// domain/model/Order.java
public class Order {
    private final OrderId id;
    private final CustomerId customerId;
    private final List<OrderItem> items;
    private OrderStatus status;
    private final Money totalAmount;

    public Order(CustomerId customerId, List<OrderItem> items) {
        this.id = OrderId.generate();
        this.customerId = customerId;
        this.items = List.copyOf(items);
        this.status = OrderStatus.PENDING;
        this.totalAmount = calculateTotal(items);
    }

    // ビジネスロジック
    public void confirm() {
        if (this.status != OrderStatus.PENDING) {
            throw new IllegalStateException("Order can only be confirmed when pending");
        }
        this.status = OrderStatus.CONFIRMED;
    }

    public void cancel(String reason) {
        if (this.status == OrderStatus.SHIPPED) {
            throw new IllegalStateException("Cannot cancel shipped order");
        }
        this.status = OrderStatus.CANCELLED;
    }

    private Money calculateTotal(List<OrderItem> items) {
        return items.stream()
            .map(OrderItem::getSubtotal)
            .reduce(Money.ZERO, Money::add);
    }

    // getters...
}

// domain/port/in/CreateOrderUseCase.java
public interface CreateOrderUseCase {
    OrderId createOrder(CreateOrderCommand command);
}

// domain/port/in/CreateOrderCommand.java
public record CreateOrderCommand(
    CustomerId customerId,
    List<OrderItemDto> items,
    ShippingAddress shippingAddress
) {}

// domain/port/out/OrderRepository.java
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId orderId);
    List<Order> findByCustomerId(CustomerId customerId);
}

// domain/port/out/PaymentGateway.java
public interface PaymentGateway {
    PaymentResult processPayment(OrderId orderId, Money amount);
}

// domain/port/out/NotificationService.java
public interface NotificationService {
    void sendOrderConfirmation(Order order);
}

// domain/service/OrderService.java
@Service
@Transactional
public class OrderService implements CreateOrderUseCase, ConfirmOrderUseCase {

    private final OrderRepository orderRepository;
    private final PaymentGateway paymentGateway;
    private final NotificationService notificationService;

    // コンストラクタインジェクション（ポートに依存）
    public OrderService(
        OrderRepository orderRepository,
        PaymentGateway paymentGateway,
        NotificationService notificationService
    ) {
        this.orderRepository = orderRepository;
        this.paymentGateway = paymentGateway;
        this.notificationService = notificationService;
    }

    @Override
    public OrderId createOrder(CreateOrderCommand command) {
        // ドメインモデルを生成
        List<OrderItem> items = command.items().stream()
            .map(dto -> new OrderItem(dto.productId(), dto.quantity(), dto.price()))
            .toList();

        Order order = new Order(command.customerId(), items);

        // 永続化（セカンダリポート経由）
        orderRepository.save(order);

        // 決済処理
        PaymentResult result = paymentGateway.processPayment(
            order.getId(),
            order.getTotalAmount()
        );

        if (result.isSuccess()) {
            order.confirm();
            orderRepository.save(order);
            notificationService.sendOrderConfirmation(order);
        }

        return order.getId();
    }
}

// adapter/in/web/OrderController.java
@RestController
@RequestMapping("/api/orders")
public class OrderController {

    private final CreateOrderUseCase createOrderUseCase;
    private final GetOrderUseCase getOrderUseCase;

    public OrderController(
        CreateOrderUseCase createOrderUseCase,
        GetOrderUseCase getOrderUseCase
    ) {
        this.createOrderUseCase = createOrderUseCase;
        this.getOrderUseCase = getOrderUseCase;
    }

    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(
        @RequestBody @Valid CreateOrderRequest request
    ) {
        // リクエストDTOをコマンドに変換
        CreateOrderCommand command = new CreateOrderCommand(
            new CustomerId(request.customerId()),
            request.items(),
            request.shippingAddress()
        );

        OrderId orderId = createOrderUseCase.createOrder(command);

        return ResponseEntity.status(HttpStatus.CREATED)
            .body(new OrderResponse(orderId.getValue()));
    }

    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDetailResponse> getOrder(@PathVariable String orderId) {
        OrderView order = getOrderUseCase.getOrder(new OrderId(orderId));
        return ResponseEntity.ok(OrderDetailResponse.from(order));
    }
}

// adapter/out/persistence/JpaOrderRepository.java
@Repository
public class JpaOrderRepository implements OrderRepository {

    private final SpringDataOrderRepository springDataRepo;
    private final OrderMapper mapper;

    @Override
    public void save(Order order) {
        OrderEntity entity = mapper.toEntity(order);
        springDataRepo.save(entity);
    }

    @Override
    public Optional<Order> findById(OrderId orderId) {
        return springDataRepo.findById(orderId.getValue())
            .map(mapper::toDomain);
    }

    @Override
    public List<Order> findByCustomerId(CustomerId customerId) {
        return springDataRepo.findByCustomerId(customerId.getValue()).stream()
            .map(mapper::toDomain)
            .toList();
    }
}

// JPA Entity（永続化の詳細）
@Entity
@Table(name = "orders")
class OrderEntity {
    @Id
    private String id;
    private String customerId;
    private String status;
    private BigDecimal totalAmount;

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    private List<OrderItemEntity> items;

    // getters/setters...
}

// adapter/out/payment/StripePaymentAdapter.java
@Component
public class StripePaymentAdapter implements PaymentGateway {

    private final StripeClient stripeClient;

    @Override
    public PaymentResult processPayment(OrderId orderId, Money amount) {
        try {
            // Stripe APIを呼び出し
            PaymentIntent intent = stripeClient.createPaymentIntent(
                amount.getAmount(),
                amount.getCurrency()
            );

            return new PaymentResult(
                true,
                intent.getId(),
                "Payment processed successfully"
            );
        } catch (StripeException e) {
            return new PaymentResult(
                false,
                null,
                "Payment failed: " + e.getMessage()
            );
        }
    }
}

// 粒度を適切に保つ
// ❌ 細かすぎる
interface SaveOrder {}
interface FindOrder {}
interface UpdateOrder {}

// ✅ 適切な粒度
interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId id);
    void delete(OrderId id);
}

// MapStructを活用
@Mapper(componentModel = "spring")
interface OrderMapper {
    OrderEntity toEntity(Order domain);
    Order toDomain(OrderEntity entity);
}

// ユースケース（ドメインサービス）にトランザクションを配置
@Service
@Transactional  // ← ここでトランザクション管理
public class OrderService implements CreateOrderUseCase {
    // ...
}

// アダプター層ではトランザクション不要
@Repository
public class JpaOrderRepository implements OrderRepository {
    // トランザクションなし
}

// application.yml で切り替え
@Configuration
public class RepositoryConfig {

    @Bean
    @ConditionalOnProperty(name = "storage.type", havingValue = "jpa")
    public OrderRepository jpaOrderRepository(SpringDataOrderRepository repo) {
        return new JpaOrderRepository(repo);
    }

    @Bean
    @ConditionalOnProperty(name = "storage.type", havingValue = "mongodb")
    public OrderRepository mongoOrderRepository(MongoTemplate template) {
        return new MongoOrderRepository(template);
    }
}