package com.assu.stury.chap08.domain;

import jakarta.persistence.*;
import lombok.Getter;

//@NoArgsConstructor
@Entity
@Getter
@Table(name = "hotels", indexes = @Index(name = "INDEX_NAME_STATUS", columnList = "name asc, status asc"))
public class HotelEntity extends AbstractManageEntity {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "hotel_id")
  private Long hotelId;
  
  @Column(name = "status")
  private HotelStatus status;
  
  @Column
  private String name;
  
  @Column
  private String address;
  
  @Column(name = "phone_number")
  private String phoneNumber;
  
  @Column(name = "room_count")
  private Integer roomCount;

  // 반드시 AbstractManageEntity 의 생성자를 호출해야 함
  public HotelEntity() {
    super();
  }

  public static HotelEntity of(String name, String address, String phoneNumber, Integer roomCount) {
    HotelEntity hotelEntity = new HotelEntity();

    hotelEntity.name = name;
    hotelEntity.status = HotelStatus.READY;
    hotelEntity.address = address;
    hotelEntity.phoneNumber = phoneNumber;
    hotelEntity.roomCount = roomCount;

    return hotelEntity;
  }
}

package com.assu.stury.chap08.domain;

import java.util.Arrays;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public enum HotelStatus {
  // 내부에 Integer value 속성이 있음
  // HotelStatus 의 value 는 데이터베이스의 값으로 변환할 때 사용하는 열거형의 속성임
  OPEN(1), CLOSED(-1), READY(0);

  // Map 의 key 는 HotelStatus 열거형의 value 로, Map 의 value 는 HotelStatus 의 상수로 저장
  // 빠르게 변환하고자 static 구문으로 클래스가 로딩될 때 Map 객체를 미리 생성함
  private static final Map<Integer, HotelStatus> valueMap = Arrays.stream(HotelStatus.values())
          .collect(Collectors.toMap(HotelStatus::getValue, Function.identity()));
  private final Integer value;

  HotelStatus(Integer value) {
    this.value = value;
  }

  // 테이블에 저장된 value 값을 사용하여 열거형 상수로 변경할 때 사용할 메서드
  // value 와 매칭되는 열거형 상수를 valueMap 에서 받아와 리턴함
  public static HotelStatus fromValue(Integer value) {
    if (value == null) {
      throw new IllegalArgumentException("value is null");
    }
    return valueMap.get(value);
  }

  public Integer getValue() {
    return value;
  }
}

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "hotel_id")
private Long hotelId;

@Entity
@Getter
@Table(name = "hotels")
public class HotelEntity extends AbstractManageEntity {
  @Column
  @Enumerated(value = EnumType.STRING)
  private HotelStatus status;
  
  // ...

  public enum HotelStatus {
    OPEN, CLOSED, READY
  }
}

package org.springframework.data.jpa.convert.threeten;

public class Jsr310JpaConverters {
  @jakarta.persistence.Converter(
          autoApply = true
  )
  // 2 개의 제네틱 타입 인자를 받음
  // 첫 번째 타입 인자는 엔티티 클래스의 속성 클래스 타입이고, 두 번째 타입 인자를 테이블 필드의 데이터 타입
  public static class LocalDateTimeConverter implements AttributeConverter<LocalDateTime, Date> {
    public LocalDateTimeConverter() {
    }

    // 엔티티 클래스의 속성값을 데이터베이스에 적합한 데이터로 변환
    // LocalDateTime 을 Date 로 변환
    @Nullable
    public Date convertToDatabaseColumn(LocalDateTime date) {
      return date == null ? null : LocalDateTimeToDateConverter.INSTANCE.convert(date);
    }

    // 데이터베이스에 저장된 데이터를 엔티티 객체의 속성으로 변환
    // Date 를 LocalDateTime 으로 변환
    @Nullable
    public LocalDateTime convertToEntityAttribute(Date date) {
      return date == null ? null : DateToLocalDateTimeConverter.INSTANCE.convert(date);
    }
  }
}

package com.assu.stury.chap08.domain.converter;

import com.assu.stury.chap08.domain.HotelStatus;
import jakarta.persistence.AttributeConverter;

import java.util.Objects;

public class HotelStatusConverter implements AttributeConverter<HotelStatus, Integer> {

  // 데이터베이스에서 사용할 데이터로 변환
  // HotelStatus 의 value 값을 리턴하는 getValue() 리턴
  @Override
  public Integer convertToDatabaseColumn(HotelStatus attribute) {
    if (Objects.isNull(attribute)) {
      return null;
    }
    return attribute.getValue();
  }

  // 데이터베이스에 저장된 값을 HotelStatus 열거형으로 변환
  // 데이터베이스에 저장된 Integer 값과 매핑되는 HotelStatus 상수를 리턴하는 fromValue() 리턴
  @Override
  public HotelStatus convertToEntityAttribute(Integer dbData) {
    if (Objects.isNull(dbData)) {
      return null;
    }
    return HotelStatus.fromValue(dbData);
  }
}

public class HotelEntity extends AbstractManageEntity {
  // ...
  
  @Column
  @Convert(converter = HotelStatusConverter.class)
  private HotelStatus status;
  
  // ...
}

package org.springframework.data.jpa.convert.threeten;

public class Jsr310JpaConverters {
  @jakarta.persistence.Converter(
          autoApply = true  // 애플리케이션 전체에 글로벌 설정
  )
  public static class LocalDateTimeConverter implements AttributeConverter<LocalDateTime, Date> {
  }// ...
}

package com.assu.stury.chap08.domain;

import com.assu.stury.chap08.server.UserIdHolder;
import jakarta.persistence.Column;
import jakarta.persistence.MappedSuperclass;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.time.ZonedDateTime;

@Slf4j
@MappedSuperclass // 상속할 수 있도록 애너테이션 정의
@Getter
// 단독으로 매핑되는 테이블이 없으므로 영속할 수 없다.
// 따라서 abstract 제어자를 사용하여 클래스가 단독으로 생성되는 상황을 막는다.
public abstract class AbstractManageEntity {
  @Column(name = "created_at")
  private final ZonedDateTime createdAt;

  @Column(name = "created_by")
  private final String createdBy;

  @Column(name = "modified_at")
  private ZonedDateTime modifiedAt;

  @Column(name = "modified_by")
  private String modifiedBy;

  public AbstractManageEntity() {
    this.createdAt = ZonedDateTime.now();
    this.createdBy = UserIdHolder.getUserId();
  }
}

// AbstractManageEntity 를 상속받으므로 createdAt, createdBy, modifiedAt, modifiedBy 를 구현할 필요가 없다.
public class HotelEntity extends AbstractManageEntity {
  // ...

  // 반드시 AbstractManageEntity 의 생성자를 호출해야 함
  public HotelEntity() {
    super();
  }
}

package com.assu.stury.chap08.server;

public class UserIdHolder {
  private static final ThreadLocal<String> threadLocalUserId = new ThreadLocal<>();

  public static String getUserId() {
    return threadLocalUserId.get();
  }

  public static void setUserId(String userId) {
    threadLocalUserId.set(userId);
  }

  public static void unset() {
    threadLocalUserId.remove();
  }
}

package com.assu.stury.chap08.server;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;

@Slf4j
public class UserIdInterceptor implements HandlerInterceptor {
  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    String userId = request.getHeader("user-id");
    UserIdHolder.setUserId(userId);

    return true;
  }

  @Override
  public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    UserIdHolder.unset();
  }
}

package com.assu.stury.chap08.config;

import com.assu.stury.chap08.server.UserIdInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {
  @Bean
  public UserIdInterceptor userIdInterceptor() {
    return new UserIdInterceptor();
  }

  @Override
  public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(userIdInterceptor());
  }
}