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

package com.example.myproject.service;

import com.example.myproject.entity.Level;
import com.example.myproject.entity.Task;
import com.example.myproject.entity.UserTaskStatus;
import com.example.myproject.repository.LevelRepository;
import com.example.myproject.repository.TaskRepository;
import com.example.myproject.repository.UserTaskStatusRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.example.myproject.entity.Users;
import com.example.myproject.repository.UserRepository;

import java.util.*;

@Service
public class TaskService {

    @Autowired
    private TaskRepository taskRepository;

    @Autowired
    private UserTaskStatusRepository userTaskStatusRepository;

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private LevelRepository levelRepository;

    public Map<String, Object> getAllTasksForUser(Long userId) {
        // 获取所有任务
        List<Task> tasks = taskRepository.findAll();
        List<Map<String, Object>> taskList = new ArrayList<>();

        for (Task task : tasks) {
            Optional<UserTaskStatus> userTaskStatus = userTaskStatusRepository
                    .findByUserIdAndTaskId(userId, task.getTaskId());

            Map<String, Object> taskData = new LinkedHashMap<>();
            taskData.put("task_id", task.getTaskId());
            taskData.put("title", task.getTitle());
            taskData.put("description", task.getDescription());
            taskData.put("status", userTaskStatus.isPresent() ? userTaskStatus.get().getStatus() : "pending");
            taskData.put("progress", userTaskStatus.isPresent() ? userTaskStatus.get().getCurrentProgress() : 0);

            // 奖励
            Map<String, Integer> reward = new LinkedHashMap<>();
            reward.put("experience", task.getRewardExperience());
            reward.put("points", task.getRewardPoints());
            taskData.put("reward", reward);

            taskList.add(taskData);
        }

        Map<String, Object> response = new LinkedHashMap<>();
        response.put("tasks", taskList);
        return response;
    }

    public Map<String, Object> updateTaskStatus(Long userId, String taskId) {
        // 获取用户任务状态
        Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findByUserIdAndTaskId(userId, taskId);
        UserTaskStatus userTaskStatus = userTaskStatusOpt.get();

        // 检查任务进度
        if (userTaskStatus.getCurrentProgress() == 100f) {
            Optional<Task> taskOpt = taskRepository.findById(taskId);
            Task task = taskOpt.get();

            // 更新任务状态为已完成
            userTaskStatus.setStatus("completed");
            userTaskStatus.setCurrentExperience(task.getRewardExperience());
            userTaskStatus.setCurrentPoints(task.getRewardPoints());

            userTaskStatusRepository.save(userTaskStatus);

            // 构建返回数据
            Map<String, Object> response = new HashMap<>();
            response.put("status", "success");
            response.put("message", "任务状态已更新");

            Map<String, Integer> currentReward = new HashMap<>();
            currentReward.put("current_experience", task.getRewardExperience());
            currentReward.put("current_points", task.getRewardPoints());
            response.put("current_reward", currentReward);

            return response;
        } else {
            Map<String, Object> errorResponse = new HashMap<>();
            errorResponse.put("status", "failure");
            errorResponse.put("message", "任务未完成，无法更新状态");
            return errorResponse;
        }
    }

    public Map<String, Object> getUserExperience(Long userId) {
        // 获取用户信息
        Optional<Users> userOpt = userRepository.findById(userId);
        if (!userOpt.isPresent()) {
            Map<String, Object> errorResponse = new LinkedHashMap<>();
            errorResponse.put("status", "failure");
            errorResponse.put("message", "用户不存在");
            return errorResponse;
        }

        Users user = userOpt.get();
        Integer currentExperience = user.getCurrentExperience();
        Optional<Level> levelOpt = levelRepository.findById(user.getLevel());
        String levelName = levelOpt.isPresent() ? levelOpt.get().getLevelName() : "未知等级";

        List<UserTaskStatus> completedTasks = userTaskStatusRepository.findByUserIdAndStatus(userId, "completed");

        int totalExperience = 0;
        int totalPoints = 0;
        for (UserTaskStatus taskStatus : completedTasks) {
            Optional<Task> taskOpt = taskRepository.findById(taskStatus.getTaskId());
            if (taskOpt.isPresent()) {
                Task task = taskOpt.get();
                totalExperience += task.getRewardExperience();
                totalPoints += task.getRewardPoints();
            }
        }

        // 构建返回数据
        Map<String, Object> response = new LinkedHashMap<>();
        response.put("user_id", userId);
        response.put("current_experience", currentExperience);
        response.put("level", levelName);
        response.put("tasks_completed", completedTasks.size());

        Map<String, Integer> reward = new LinkedHashMap<>();
        reward.put("experience", totalExperience);
        reward.put("points", totalPoints);

        response.put("reward", reward);

        return response;
    }

    public Map<String, Object> getNewStep(Long userId) {
        // 获取用户的第一个未完成任务
        Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findFirstByUserIdAndStatus(userId, "pending");

        if (!userTaskStatusOpt.isPresent()) {
            Map<String, Object> errorResponse = new LinkedHashMap<>();
            errorResponse.put("status", "failure");
            errorResponse.put("message", "用户当前没有未完成的任务");
            return errorResponse;
        }

        UserTaskStatus userTaskStatus = userTaskStatusOpt.get();
        String taskId = userTaskStatus.getTaskId();

        // 获取该任务的描述
        Optional<Task> taskOpt = taskRepository.findById(taskId);
        if (!taskOpt.isPresent()) {
            Map<String, Object> errorResponse = new LinkedHashMap<>();
            errorResponse.put("status", "failure");
            errorResponse.put("message", "任务不存在");
            return errorResponse;
        }

        Task task = taskOpt.get();

        // 获取总任务数
        long totalTasks = taskRepository.count();

        // 构建返回数据
        Map<String, Object> response = new LinkedHashMap<>();
        response.put("current_step", taskId);
        response.put("total_steps", totalTasks);
        response.put("step_description", task.getDescription());

        return response;
    }

    public Map<String, Object> updateTaskProgress(Long userId, String taskId, Integer progress) {
        Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findByUserIdAndTaskId(userId, taskId);

        if (!userTaskStatusOpt.isPresent()) {
            Map<String, Object> errorResponse = new LinkedHashMap<>();
            errorResponse.put("status", "failure");
            errorResponse.put("message", "任务不存在或该任务不属于用户");
            return errorResponse;
        }

        UserTaskStatus userTaskStatus = userTaskStatusOpt.get();
        userTaskStatus.setCurrentProgress(Float.valueOf(progress));
        userTaskStatusRepository.save(userTaskStatus);
        Map<String, Object> response = new LinkedHashMap<>();
        response.put("status", "success");
        response.put("message", "进度已更新");

        return response;
    }

    public Map<String, Object> claimReward(Long userId, String taskId) {
        // 获取用户任务状态
        Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findByUserIdAndTaskId(userId, taskId);

        if (!userTaskStatusOpt.isPresent()) {
            Map<String, Object> errorResponse = new LinkedHashMap<>();
            errorResponse.put("status", "failure");
            errorResponse.put("message", "任务状态不存在");
            return errorResponse;
        }

        UserTaskStatus userTaskStatus = userTaskStatusOpt.get();

        if (userTaskStatus.getCurrentProgress() == 100f) {
            if (userTaskStatus.getIsRewardClaimed()) {
                Map<String, Object> errorResponse = new LinkedHashMap<>();
                errorResponse.put("status", "failure");
                errorResponse.put("message", "奖励已经领取过了");
                return errorResponse;
            }

            Optional<Task> taskOpt = taskRepository.findById(taskId);
            if (!taskOpt.isPresent()) {
                Map<String, Object> errorResponse = new LinkedHashMap<>();
                errorResponse.put("status", "failure");
                errorResponse.put("message", "任务不存在");
                return errorResponse;
            }

            Task task = taskOpt.get();

            userTaskStatus.setIsRewardClaimed(true);
            userTaskStatus.setCurrentExperience(task.getRewardExperience());
            userTaskStatus.setCurrentPoints(task.getRewardPoints());

            userTaskStatusRepository.save(userTaskStatus);

            Optional<Users> userOpt = userRepository.findById(userId);
            if (!userOpt.isPresent()) {
                Map<String, Object> errorResponse = new LinkedHashMap<>();
                errorResponse.put("status", "failure");
                errorResponse.put("message", "用户不存在");
                return errorResponse;
            }

            Users user = userOpt.get();

            // 将任务奖励加到用户的积分和经验
            user.setUserPoints(user.getUserPoints() + task.getRewardPoints());
            user.setCurrentExperience(user.getCurrentExperience() + task.getRewardExperience());

            userRepository.save(user);

            Map<String, Object> response = new LinkedHashMap<>();
            response.put("status", "success");
            response.put("message", "奖励已领取");

            Map<String, Integer> reward = new LinkedHashMap<>();
            reward.put("experience", task.getRewardExperience());
            reward.put("points", task.getRewardPoints());
            response.put("reward", reward);

            return response;
        } else {
            Map<String, Object> errorResponse = new LinkedHashMap<>();
            errorResponse.put("status", "failure");
            errorResponse.put("message", "任务未完成，无法领取奖励");
            return errorResponse;
        }
    }

    public Map<String, Object> checkRewardStatus(Long userId, String taskId) {
        // 获取用户任务状态
        Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findByUserIdAndTaskId(userId, taskId);

        if (!userTaskStatusOpt.isPresent()) {
            Map<String, Object> errorResponse = new LinkedHashMap<>();
            errorResponse.put("status", "failure");
            errorResponse.put("message", "任务状态不存在");
            return errorResponse;
        }

        UserTaskStatus userTaskStatus = userTaskStatusOpt.get();

        // 检查奖励是否已领取
        if (userTaskStatus.getIsRewardClaimed()) {
            Map<String, Object> response = new LinkedHashMap<>();
            response.put("status", "reward_issued");
            response.put("message", "任务奖励已被领取");
            return response;
        }

        Map<String, Object> response = new LinkedHashMap<>();
        response.put("status", "reward_not_issued");
        response.put("message", "任务奖励未被领取");
        return response;
    }
}