@Entity
@Table(name = "gyms")
@SQLRestriction("deleted_at IS NULL")  // 소프트 삭제
@SQLDelete(sql = "UPDATE gyms SET deleted_at = CURRENT_TIMESTAMP WHERE id = ?")
public class Gym extends BaseEntity {
    private Long id;                    // 헬스장 ID
    private String name;                // 헬스장 이름
    private String number;              // 연락처 (unique)
    private String content;             // 상세 설명
    private String address;             // 주소
    private LocalTime openTime;         // 운영 시작 시간
    private LocalTime closeTime;        // 운영 종료 시간
    private GymStatus gymStatus;        // 승인 상태
    private User user;                  // 헬스장 소유자 (OWNER)
    private List<Trainer> trainers;     // 소속 트레이너들
    private List<Image> images;         // 헬스장 이미지들
}

// 모든 헬스장 관련 작업에서 반복되는 핵심 검증
private void validateOwnership(Long userId, Gym gym) {
    // 1. 사용자 조회
    User user = userRepository.findByIdOrElseThrow(userId);
    
    // 2. OWNER 권한 확인
    if (user.getUserRole() != UserRole.OWNER) {
        throw new BaseException(ExceptionCode.NOT_GYM_OWNER);
    }
    
    // 3. 헬스장 소유자 확인
    if (!Objects.equals(gym.getOwner().getId(), userId)) {
        throw new BaseException(ExceptionCode.NOT_GYM_OWNER);
    }
}

@Entity
@Table(name = "trainers")
public class Trainer extends BaseEntity {
    private Long id;                    // 트레이너 ID
    private String name;                // 트레이너 이름
    private int price;                  // 시간당 수업료
    private String content;             // 트레이너 소개
    private String experience;          // 경력 사항
    private TrainerStatus status;       // 트레이너 상태
    private Gym gym;                    // 소속 헬스장
    private List<Image> images;         // 트레이너 프로필 이미지
    private List<User> members;         // 담당 회원들
}

public void validateTrainerBelongsToGym(Trainer trainer, Gym gym) {
    if (!trainer.getGym().getId().equals(gym.getId())) {
        throw new BaseException(INVALID_GYM_TRAINER_RELATION);
    }
}

// 트레이너 관련 모든 작업에서 수행되는 검증
private void validateTrainerOperation(Long userId, Long gymId, Long trainerId) {
    // 1. 사용자 OWNER 권한 확인
    User user = userRepository.findByIdOrElseThrow(userId);
    if (user.getUserRole() != UserRole.OWNER) {
        throw new BaseException(ExceptionCode.NOT_GYM_OWNER);
    }
    
    // 2. 헬스장 소유권 확인
    Gym gym = gymRepository.findByIdOrElseThrow(gymId);
    if (!Objects.equals(gym.getOwner().getId(), userId)) {
        throw new BaseException(ExceptionCode.NOT_GYM_OWNER);
    }
    
    // 3. 트레이너-헬스장 연관관계 확인
    Trainer trainer = trainerRepository.findByIdOrElseThrow(trainerId);
    if (!trainer.getGym().getId().equals(gymId)) {
        throw new BaseException(ExceptionCode.NOT_GYM_OWNER);
    }
    
    // 4. 트레이너 소속 확인
    trainer.validateTrainerBelongsToGym(trainer, gym);
}

@Entity
@Table(name = "memberships")
public class Membership extends BaseEntity {
    private Long id;                    // 이용권 ID
    private String name;                // 이용권 이름
    private int price;                  // 이용권 가격
    private String content;             // 이용권 설명
    private int durationInDays;         // 이용 기간 (일)
    private Gym gym;                    // 발행 헬스장
}

@Entity
@Table(name = "membership_purchase")
public class MembershipPurchase extends BaseEntity {
    private Long id;                      // 구매 ID
    private Membership membership;        // 구매한 이용권
    private User user;                    // 구매자
    private Gym gym;                      // 이용 헬스장
    private LocalDateTime purchaseDate;   // 구매일시
    private LocalDateTime startDate;      // 이용 시작일 (활성화 시 설정)
    private LocalDateTime endDate;        // 이용 종료일 (활성화 시 설정)
    private LocalDateTime scheduledStartDate; // 예약 활성화일
}

public boolean isNotStarted() {
    return startDate == null;
}

public boolean isActive() {
    return startDate != null && endDate != null
        && LocalDateTime.now().isAfter(startDate)
        && LocalDateTime.now().isBefore(endDate);
}

// 구매일 기준 제한 사항
LocalDate today = LocalDate.now();
if (activationDate.isBefore(today)) {
    throw new BaseException(ExceptionCode.INVALID_ACTIVATION_DATE_PAST);
}
if (activationDate.isAfter(today.plusDays(7))) {
    throw new BaseException(ExceptionCode.INVALID_ACTIVATION_DATE_TOO_FAR);
}

@Scheduled(cron = "0 0 6 * * *")
@Transactional
public void activateScheduledMemberships() {
    // 1. 오늘 활성화 예정인 이용권 조회
    List<MembershipPurchase> scheduled = membershipPurchaseRepository
        .findScheduledForActivation(startOfDay, endOfDay);
    
    // 2. 자동 활성화 실행
    scheduled.forEach(purchase -> {
        purchase.activate(LocalDateTime.now());
        
        // 3. 활성화 알림 발송
        notifyService.send(purchase.getUser(), 
            NotificationType.MEMBERSHIP, 
            "이용권이 활성화되었습니다!", 
            "/memberships/purchases/active");
    });
}

@Scheduled(cron = "0 0 9 * * *")
public void sendThreeDaysBeforeExpirationNotice() {
    LocalDateTime threeDaysLater = LocalDateTime.now().plusDays(3);
    // 3일 후 만료되는 이용권 조회 및 알림 발송
}

@Scheduled(cron = "0 0 9 * * *")
public void sendOneDayBeforeExpirationNotice() {
    LocalDateTime tomorrow = LocalDateTime.now().plusDays(1);
    // 내일 만료되는 이용권 조회 및 알림 발송
}

@Scheduled(cron = "0 0 9 * * *")
public void sendTodayExpirationNotice() {
    LocalDateTime today = LocalDateTime.now();
    // 오늘 만료되는 이용권 조회 및 알림 발송
}

// 트레이너 삭제 시 연관 데이터 정리
@Transactional
public void deleteTrainer(Long trainerId) {
    Trainer trainer = trainerRepository.findByIdOrElseThrow(trainerId);
    
    // 1. 진행 중인 예약 확인
    if (hasActiveReservations(trainer)) {
        throw new BaseException(ExceptionCode.TRAINER_HAS_ACTIVE_RESERVATIONS);
    }
    
    // 2. S3 이미지 삭제
    trainer.getImages().forEach(image -> 
        s3Service.deleteFileFromS3(image.getUrl()));
    
    // 3. 트레이너 삭제
    trainerRepository.delete(trainer);
}

@SQLRestriction("deleted_at IS NULL")
@SQLDelete(sql = "UPDATE gyms SET deleted_at = CURRENT_TIMESTAMP WHERE id = ?")

// 트레이너 수정 시 수행되는 검증
private void validateTrainerUpdate(Long userId, Long gymId, Long trainerId) {
    // Level 1: 사용자 존재 및 권한 확인
    User user = userRepository.findByIdOrElseThrow(userId);
    if (user.getUserRole() != UserRole.OWNER) {
        throw new BaseException(ExceptionCode.NOT_GYM_OWNER);
    }
    
    // Level 2: 헬스장 소유권 확인
    Gym gym = gymRepository.findByIdOrElseThrow(gymId);
    if (!Objects.equals(gym.getOwner().getId(), userId)) {
        throw new BaseException(ExceptionCode.NOT_GYM_OWNER);
    }
    
    // Level 3: 트레이너 소속 확인
    Trainer trainer = trainerRepository.findByIdOrElseThrow(trainerId);
    if (!trainer.getGym().getId().equals(gymId)) {
        throw new BaseException(ExceptionCode.NOT_GYM_OWNER);
    }
    
    // Level 4: 연관관계 검증
    trainer.validateTrainerBelongsToGym(trainer, gym);
}