src/main/java/com/example/myproject/service/GroupService.java

package com.example.myproject.service;

import com.example.myproject.entity.*;

import com.example.myproject.repository.*;
import jakarta.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Files;

import java.util.*;

@Service
public class GroupService {

    @Autowired
    private GroupRepository groupRepository;

    @Autowired
    private GroupMembersRepository groupMembersRepository;


    @Autowired
    private UserRepository userRepository;

    @Autowired
    private GroupPostRepository groupPostRepository;

    @Autowired
    private GroupCommentsRepository groupCommentsRepository;

    private static final String IMAGE_DIR = "uploads/groupPost/";

    @Transactional
    // 创建小组的方法
    public ResponseEntity<Map<String, Object>> createGroup(Group groupRequest) {
        try {
            // 创建新的小组对象
            Group newGroup = new Group();
            newGroup.setGroupName(groupRequest.getGroupName());
            newGroup.setDescription(groupRequest.getDescription());
            newGroup.setCreateTime(new Date());
            newGroup.setUserId(groupRequest.getUserId());
            newGroup.setMemberCount(1);
            newGroup.setCategory(groupRequest.getCategory());
            newGroup.setCoverImage(groupRequest.getCoverImage());
            Group createdGroup = groupRepository.save(newGroup);

            // 返回成功响应
            Map<String, Object> response = new HashMap<>();
            response.put("status", "success");
            response.put("message", "兴趣小组创建成功");
            response.put("group_id", createdGroup.getGroupId());

            return ResponseEntity.ok(response);
        } catch (Exception e) {
            // 返回失败响应
            Map<String, Object> errorResponse = new HashMap<>();
            errorResponse.put("status", "error");
            errorResponse.put("message", "小组创建失败");
            errorResponse.put("group_id", null);

            return ResponseEntity.status(400).body(errorResponse);
        }
    }


    // 加入小组
    @Transactional
    public ResponseEntity<Map<String, Object>> joinGroup(Long groupId, Long userId) {
        // 查找小组
        Optional<Group> groupOptional = groupRepository.findById(groupId);
        if (!groupOptional.isPresent()) {
            return ResponseEntity.status(400).body(
                    Map.of("status", "failure", "message", "小组不存在")
            );
        }

        Group group = groupOptional.get();

        // 检查用户是否已经是该小组成员
        if (groupMembersRepository.existsByGroupIdAndUserId(groupId, userId)) {
            return ResponseEntity.status(400).body(
                    Map.of("status", "failure", "message", "用户已经是该小组的成员")
            );
        }

        // 插入用户和小组的关联记录
        GroupMembers groupMembers = new GroupMembers();
        groupMembers.setGroupId(groupId);
        groupMembers.setUserId(userId);
        groupMembersRepository.save(groupMembers);

        // 更新小组的成员数
        group.setMemberCount(group.getMemberCount() + 1);
        groupRepository.save(group);

        return ResponseEntity.ok().body(
                Map.of("status", "success", "message", "成功加入小组")
        );
    }

    // 退出小组
    @Transactional
    public ResponseEntity<Map<String, Object>> leaveGroup(Long groupId, Long userId) {
        // 查找小组
        Optional<Group> groupOptional = groupRepository.findById(groupId);
        if (!groupOptional.isPresent()) {
            return ResponseEntity.status(400).body(
                    Map.of("status", "failure", "message", "小组不存在")
            );
        }

        Group group = groupOptional.get();

        // 检查用户是否是该小组成员
        if (!groupMembersRepository.existsByGroupIdAndUserId(groupId, userId)) {
            return ResponseEntity.status(400).body(
                    Map.of("status", "failure", "message", "用户不是该小组的成员")
            );
        }

        // 删除用户和小组的关联记录
        groupMembersRepository.deleteByGroupIdAndUserId(groupId, userId);

        // 更新小组的成员数
        group.setMemberCount(group.getMemberCount() - 1);
        groupRepository.save(group);

        return ResponseEntity.ok().body(
                Map.of("status", "success", "message", "成功退出小组")
        );
    }

    // 获取所有成员
    @Transactional
    public ResponseEntity<Map<String, Object>> getGroupMembers(Long groupId) {
        // 查找小组
        Optional<Group> groupOptional = groupRepository.findById(groupId);
        if (!groupOptional.isPresent()) {
            return ResponseEntity.status(400).body(
                    Map.of("status", "failure", "message", "小组不存在")
            );
        }

        Group group = groupOptional.get();

        // 获取所有小组成员
        List<GroupMembers> groupMembersList = groupMembersRepository.findByGroupId(groupId);

        // 创建成员返回列表
        List<Map<String, Object>> members = new ArrayList<>();
        for (GroupMembers groupMember : groupMembersList) {
            Optional<Users> userOptional = userRepository.findById(groupMember.getUserId());
            if (userOptional.isPresent()) {
                Users user = userOptional.get();
                members.add(Map.of(
                        "user_id", user.getUserId(),
                        "username", user.getUsername(),
                        "avatar_url", user.getAvatarUrl()
                ));
            }
        }

        return ResponseEntity.ok().body(
                Map.of("status", "success", "members", members)
        );
    }


    //发布帖子
    public Map<String, Object> createPost(Long groupId, Long userId, String postContent, String title, MultipartFile[] imageFiles) {
        // 创建一个新的帖子对象
        GroupPost post = new GroupPost();
        post.setGroupId(groupId);
        post.setUserId(userId);
        post.setContent(postContent);
        post.setTitle(title);
        post.setTime(new Date());
        post.setLikeCount(0);
        post.setCommentCount(0);

        // 处理图片上传，如果没有图片，返回空字符串
        String imageUrls = handleImages(imageFiles);
        post.setImage(imageUrls);

        // 保存帖子到数据库
        GroupPost savedPost = groupPostRepository.save(post);

        // 返回结果
        Map<String, Object> response = new LinkedHashMap<>();
        response.put("post_id", savedPost.getGroupPostId());
        response.put("message", "帖子创建成功");
        return response;
    }

    // 处理图片上传的方法，返回图片的 URL 字符串
    private String handleImages(MultipartFile[] imageFiles) {
        if (imageFiles == null || imageFiles.length == 0) {
            return "";
        }

        StringBuilder imageUrlsBuilder = new StringBuilder();

        for (int i = 0; i < imageFiles.length; i++) {
            if (i > 0) {
                imageUrlsBuilder.append(",");
            }
            try {
                String imageUrl = saveImage(imageFiles[i]);
                imageUrlsBuilder.append(imageUrl);
            } catch (IOException e) {
                throw new RuntimeException("图片上传失败: " + e.getMessage());
            }
        }
        return imageUrlsBuilder.toString();
    }

    // 保存图片并返回图片的 URL
    private String saveImage(MultipartFile imageFile) throws IOException {
        if (imageFile == null) {
            throw new IOException("图片文件为空");
        }

        String fileName = imageFile.getOriginalFilename();
        Path path = Path.of(IMAGE_DIR + fileName);
        Files.createDirectories(path.getParent());
        Files.write(path, imageFile.getBytes());
        return "/images/" + fileName;
    }

    // 获取小组内的所有帖子
    public Map<String, Object> getAllPosts(Long groupId) {
        List<GroupPost> posts = groupPostRepository.findByGroupId(groupId);

        List<Map<String, Object>> postList = new ArrayList<>();

        for (GroupPost post : posts) {
            Map<String, Object> postData = new HashMap<>();
            Users user = userRepository.findById(post.getUserId()).orElseThrow(() -> new RuntimeException("User not found"));
            postData.put("group_post_id", post.getGroupPostId());
            postData.put("user_id", post.getUserId());
            postData.put("username", user.getUsername());
            postData.put("title", post.getTitle());
            postData.put("content", post.getContent());
            postData.put("time", post.getTime());

            postList.add(postData);
        }

        // 返回响应数据
        Map<String, Object> response = new LinkedHashMap<>();
        response.put("status", "success");
        response.put("posts", postList);
        return response;
    }


    // 获取小组列表接口
    public Map<String, Object> searchGroups(Map<String, Object> params) {
        String name = (String) params.get("name");
        String category = (String) params.get("category");
        Integer page = (Integer) params.getOrDefault("page", 1);
        Integer size = (Integer) params.getOrDefault("size", 10);
        String sortBy = (String) params.getOrDefault("sort_by", "memberCount");

        // 构建分页对象
        Pageable pageable;

        // 根据 `sortBy` 判断排序方式
        if ("createTime".equals(sortBy)) {
            pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.asc("createTime")));
        } else if ("groupName".equals(sortBy)) {
            pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.asc("groupName")));
        } else {
            pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.desc("memberCount")));
        }

        Page<Group> groups;
        if (name != null && !name.isEmpty()) {
            // 小组名称模糊查询
            groups = groupRepository.searchGroups(name, category, pageable);
        } else {
            groups = groupRepository.searchWithFilters(category, pageable);
        }

        return buildResponse(groups);
    }

    // 构建返回的响应数据
    private Map<String, Object> buildResponse(Page<Group> groups) {
        Map<String, Object> response = new LinkedHashMap<>();
        response.put("status", "success");
        response.put("total", groups.getTotalElements());
        response.put("total_pages", groups.getTotalPages());
        response.put("current_page", groups.getNumber() + 1);
        response.put("items", groups.getContent());

        return response;
    }

    // 点赞帖子
    public Map<String, Object> likePost(Long GroupPostId) {
        // 查找帖子
        Optional<GroupPost> postOpt = groupPostRepository.findById(GroupPostId);
        if (!postOpt.isPresent()) {
            throw new RuntimeException("Post not found");
        }

        GroupPost post = postOpt.get();

        // 更新点赞数
        post.setLikeCount(post.getLikeCount() + 1);
        groupPostRepository.save(post);

        // 返回成功信息
        Map<String, Object> response = new HashMap<>();
        response.put("status", "success");
        response.put("message", "点赞成功");
        return response;
    }

    // 取消点赞
    public Map<String, Object> unlikePost(Long GroupPostId) {
        // 查找帖子
        Optional<GroupPost> postOpt = groupPostRepository.findById(GroupPostId);
        if (!postOpt.isPresent()) {
            throw new RuntimeException("Post not found");
        }

        GroupPost post = postOpt.get();

        // 更新点赞数
        if (post.getLikeCount() > 0) {
            post.setLikeCount(post.getLikeCount() - 1);
            groupPostRepository.save(post);

            // 返回成功信息
            Map<String, Object> response = new HashMap<>();
            response.put("status", "success");
            response.put("message", "取消点赞成功");
            return response;
        } else {
            // 如果点赞数已经是0，则返回相应消息
            Map<String, Object> response = new HashMap<>();
            response.put("status", "failure");
            response.put("message", "无法取消点赞，点赞数已经为0");
            return response;
        }
    }

    // 添加评论并更新帖子的评论数
    public Map<String, Object> addComment(Long postId, GroupComments comment) {
        // 查找帖子
        Optional<GroupPost> postOpt = groupPostRepository.findById(postId);
        if (!postOpt.isPresent()) {
            throw new RuntimeException("Post not found");
        }

        GroupPost post = postOpt.get();

        comment.setGroupPostId(postId);
        comment.setTime(new java.util.Date());
        groupCommentsRepository.save(comment);
        post.setCommentCount(post.getCommentCount() + 1);
        groupPostRepository.save(post);
        Map<String, Object> response = new HashMap<>();
        response.put("status", "success");
        response.put("message", "评论成功");
        return response;
    }


}