Quan hệ Entity & Ánh xạ nâng cao

// UserProfile — bên sở hữu (owning side, có khóa ngoại)
@Entity
@Table(name = "user_profiles")
public class UserProfile {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "avatar_url", length = 500)
    private String avatarUrl;

    @Column(length = 500)
    private String website;

    // @OneToOne — profile này thuộc đúng một user.
    // @JoinColumn chỉ định cột khóa ngoại trong bảng user_profiles.
    // Đây là "owning side" vì nó chứa khóa ngoại.
    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id", nullable = false, unique = true)
    private User user;
}

// User — bên nghịch đảo (inverse side, không có khóa ngoại)
@Entity
@Table(name = "users")
public class User {

    // "mappedBy = user" nghĩa là: entity UserProfile sở hữu quan hệ
    // thông qua trường "user". Không có cột khóa ngoại trong bảng users.
    @OneToOne(mappedBy = "user", cascade = CascadeType.ALL,
              fetch = FetchType.LAZY, orphanRemoval = true)
    private UserProfile profile;

    // Phương thức helper — giữ cả hai bên đồng bộ
    public void setProfile(UserProfile profile) {
        this.profile = profile;
        if (profile != null) {
            profile.setUser(this);
        }
    }
}

@Entity
@Table(name = "comments")
public class Comment {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, columnDefinition = "TEXT")
    private String content;

    // Nhiều bình luận thuộc một bài viết.
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "post_id", nullable = false)
    private Post post;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "author_id", nullable = false)
    private User author;

    // Quan hệ tự tham chiếu: bình luận có thể trả lời bình luận khác
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "parent_id")
    private Comment parent;

    @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Comment> replies = new ArrayList<>();

    public void addReply(Comment reply) {
        replies.add(reply);
        reply.setParent(this);
    }
}

@Entity
@Table(name = "posts")
public class Post {

    // Một bài viết có nhiều bình luận.
    // "mappedBy = post" nghĩa là: entity Comment sở hữu quan hệ qua trường "post".
    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Comment> comments = new ArrayList<>();

    // Phương thức helper — giữ cả hai bên đồng bộ
    public void addComment(Comment comment) {
        comments.add(comment);
        comment.setPost(this);
    }

    public void removeComment(Comment comment) {
        comments.remove(comment);
        comment.setPost(null);
    }
}

private List<Comment> comments = new ArrayList<>();

// Tag entity
@Entity
@Table(name = "tags")
public class Tag {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true, length = 50)
    private String name;

    // Bên nghịch đảo
    @ManyToMany(mappedBy = "tags")
    private Set<Post> posts = new HashSet<>();
}

// Post entity — thêm trường tags
@Entity
@Table(name = "posts")
public class Post {

    // Bên SỞ HỮU — kiểm soát bảng nối
    @ManyToMany
    @JoinTable(
        name = "post_tags",
        joinColumns = @JoinColumn(name = "post_id"),
        inverseJoinColumns = @JoinColumn(name = "tag_id")
    )
    private Set<Tag> tags = new HashSet<>();

    // Helper — LUÔN cập nhật cả hai bên
    public void addTag(Tag tag) {
        this.tags.add(tag);
        tag.getPosts().add(this);
    }

    public void removeTag(Tag tag) {
        this.tags.remove(tag);
        tag.getPosts().remove(this);
    }
}

// ❌ XẤU — List với @ManyToMany
// Khi xóa tag, Hibernate: XÓA TẤT CẢ hàng rồi INSERT LẠI tất cả còn lại. Cực kỳ kém hiệu quả!
@ManyToMany
private List<Tag> tags = new ArrayList<>();

// ✅ TỐT — Set với @ManyToMany
// Khi xóa tag, Hibernate chỉ XÓA đúng một hàng. Hiệu quả hơn nhiều!
@ManyToMany
private Set<Tag> tags = new HashSet<>();

// CascadeType.ALL — cho quan hệ cha-con mạnh
// (bình luận không có ý nghĩa nếu không có bài viết)
@OneToMany(mappedBy = "post", cascade = CascadeType.ALL)
private List<Comment> comments;

// Không cascade — cho tham chiếu lỏng
// (category tồn tại độc lập với bài viết nào)
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "category_id")
private Category category;  // Không cascade

@OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
private List<Comment> comments = new ArrayList<>();

// Sử dụng:
post.getComments().removeIf(c -> c.getId().equals(commentId));
// Vì orphanRemoval = true, Hibernate tự sinh: DELETE FROM comments WHERE id = ?

// Mọi quan hệ nên là LAZY
@ManyToOne(fetch = FetchType.LAZY)   // Tải khi gọi getAuthor()
@OneToOne(fetch = FetchType.LAZY)
@OneToMany(fetch = FetchType.LAZY)   // mặc định, nhưng rõ ràng
@ManyToMany(fetch = FetchType.LAZY)  // mặc định, nhưng rõ ràng

List<Post> posts = postRepository.findAll();  // Truy vấn 1: SELECT * FROM posts
for (Post post : posts) {
    String authorName = post.getAuthor().getUsername();  // N truy vấn thêm!
}

@Query("SELECT p FROM Post p JOIN FETCH p.author")
List<Post> findAllWithAuthors();
// Một truy vấn duy nhất tải tất cả!

@EntityGraph(attributePaths = {"author", "category"})
List<Post> findByStatus(String status);

@OneToMany(mappedBy = "post", fetch = FetchType.LAZY)
@BatchSize(size = 25)  // Tải bình luận theo lô 25, không phải từng cái
private List<Comment> comments = new ArrayList<>();

spring.jpa.properties.hibernate.default_batch_fetch_size=25

@Query("SELECT new com.example.blogapi.dto.PostWithAuthorDto(" +
       "p.id, p.title, p.status, p.author.username) " +
       "FROM Post p WHERE p.status = :status")
List<PostWithAuthorDto> findPostsWithAuthorInfo(@Param("status") String status);

// Comment biết Post, nhưng Post KHÔNG biết Comments
@Entity
public class Comment {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "post_id")
    private Post post;
}

@Entity
public class Post {
    // Không có trường comments
}
// Lấy bình luận qua: commentRepository.findByPostId(postId);

@Entity
public class Comment {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "post_id")
    private Post post;
}

@Entity
public class Post {
    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL)
    private List<Comment> comments;
}

// ⚠️ NGUY HIỂM — nếu user có 10,000 bài viết, gọi user.getPosts()
// tải tất cả 10,000 vào bộ nhớ!
@OneToMany(mappedBy = "author")
private List<Post> posts;  // Có thể RẤT LỚN

// ✅ AN TOÀN — dùng repository query với phân trang
postRepository.findByAuthorId(authorId, pageable);

private List<Comment> comments = new ArrayList<>();  // ✅
private List<Comment> comments;                       // ❌ NullPointerException

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Post post = (Post) o;
    return id != null && id.equals(post.id);
}

@Override
public int hashCode() {
    return getClass().hashCode();  // Hằng số — an toàn khi id chưa được gán
}

public void addComment(Comment comment) {
    comments.add(comment);
    comment.setPost(this);  // Đồng bộ cả hai bên
}

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "post_id")
@JsonIgnore  // Không serialize post khi serialize comment
private Post post;

// ❌ NGUY HIỂM — lưu comment KHÔNG nên cascade thay đổi đến post
@ManyToOne(cascade = CascadeType.ALL)

// ✅ ĐÚNG — không cascade trên @ManyToOne
@ManyToOne(fetch = FetchType.LAZY)

public interface PostRepository extends JpaRepository<Post, Long> {

    // Tải bài viết với tác giả, danh mục, và tags (một truy vấn)
    @Query("SELECT DISTINCT p FROM Post p " +
           "JOIN FETCH p.author " +
           "LEFT JOIN FETCH p.category " +
           "LEFT JOIN FETCH p.tags " +
           "WHERE p.id = :id")
    Optional<Post> findByIdWithAllDetails(@Param("id") Long id);

    // Bài viết theo tag
    @Query("SELECT p FROM Post p JOIN p.tags t WHERE t.slug = :tagSlug AND p.status = 'PUBLISHED'")
    Page<Post> findByTagSlug(@Param("tagSlug") String tagSlug, Pageable pageable);
}

public interface CommentRepository extends JpaRepository<Comment, Long> {

    // Bình luận cấp cao nhất (parent IS NULL) với phân trang
    @Query("SELECT c FROM Comment c JOIN FETCH c.author " +
           "WHERE c.post.id = :postId AND c.parent IS NULL ORDER BY c.createdAt DESC")
    Page<Comment> findTopLevelByPostId(@Param("postId") Long postId, Pageable pageable);

    long countByPostId(Long postId);
}