package com.example.demo.service;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.example.demo.model.TextToVideoTask;
import com.example.demo.repository.TextToVideoTaskRepository;

/**
 * 文生视频服务类
 * 注意：不在类级别使用 @Transactional，因为某些方法需要禁用事务（如长时间运行的外部API调用）
 */
@Service
public class TextToVideoService {

    private static final Logger logger = LoggerFactory.getLogger(TextToVideoService.class);

    @Autowired
    private TextToVideoTaskRepository taskRepository;

    @Autowired
    private RealAIService realAIService;

    @Autowired
    private TaskQueueService taskQueueService;
    
    @Autowired
    private UserWorkService userWorkService;
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private TaskStatusPollingService taskStatusPollingService;

    @Value("${app.video.output.path:/outputs}")
    private String outputPath;

    /**
     * 创建文生视频任务
     */
    @Transactional
    public TextToVideoTask createTask(String username, String prompt, String aspectRatio, int duration, boolean hdMode) {
        try {
            // 验证参数
            if (username == null || username.trim().isEmpty()) {
                throw new IllegalArgumentException("用户名不能为空");
            }
            if (prompt == null || prompt.trim().isEmpty()) {
                throw new IllegalArgumentException("文本描述不能为空");
            }
            if (duration < 1 || duration > 60) {
                throw new IllegalArgumentException("视频时长必须在1-60秒之间");
            }
            
            // 检查用户所有类型任务的总数（统一检查）
            userWorkService.checkMaxConcurrentTasks(username);
            
            // 生成任务ID
            String taskId = generateTaskId();
            
            // 创建任务
            TextToVideoTask task = new TextToVideoTask(username, prompt.trim(), aspectRatio, duration, hdMode);
            task.setTaskId(taskId);
            task.setStatus(TextToVideoTask.TaskStatus.PROCESSING);  // 直接设为生成中
            task.setProgress(0);
            
            // 保存任务
            task = taskRepository.save(task);
            
            // 添加任务到队列
            taskQueueService.addTextToVideoTask(username, taskId);
            
            // 创建PROCESSING状态的UserWork，以便用户刷新页面后能恢复任务
            try {
                userWorkService.createProcessingTextToVideoWork(task);
            } catch (Exception e) {
                logger.warn("创建PROCESSING状态作品失败（不影响任务执行）: {}", taskId, e);
            }
            
            logger.info("文生视频任务创建成功: {}, 用户: {}", taskId, username);
            return task;
            
        } catch (Exception e) {
            logger.error("创建文生视频任务失败", e);
            throw new RuntimeException("创建任务失败: " + e.getMessage());
        }
    }

    /**
     * 使用真实API处理任务
     */
    @Async("taskExecutor")
    public CompletableFuture<Void> processTaskWithRealAPI(TextToVideoTask task) {
        try {
            logger.info("开始使用真实API处理文生视频任务: {}", task.getTaskId());
            
            // 重新从数据库加载任务，确保获取最新状态
            TextToVideoTask currentTask = taskRepository.findByTaskId(task.getTaskId())
                .orElseThrow(() -> new RuntimeException("任务不存在: " + task.getTaskId()));
            
            // 检查任务是否已经有 realTaskId，如果有，说明已经提交过了，不应该再次处理
            if (currentTask.getRealTaskId() != null && !currentTask.getRealTaskId().isEmpty()) {
                logger.warn("文生视频任务 {} 已经有 realTaskId（{}），说明已经提交过了，跳过处理", 
                    task.getTaskId(), currentTask.getRealTaskId());
                return CompletableFuture.completedFuture(null);
            }
            
            // 检查任务状态，如果已经不是PENDING，说明已经被其他线程处理了
            if (currentTask.getStatus() != TextToVideoTask.TaskStatus.PENDING) {
                logger.warn("文生视频任务 {} 状态已不是PENDING（当前状态: {}），跳过处理，可能已被其他线程处理", 
                    task.getTaskId(), currentTask.getStatus());
                return CompletableFuture.completedFuture(null);
            }
            
            // 更新任务状态为处理中
            currentTask.updateStatus(TextToVideoTask.TaskStatus.PROCESSING);
            taskRepository.save(currentTask);

            // 调用真实API提交任务
            Map<String, Object> apiResponse = realAIService.submitTextToVideoTask(
                currentTask.getPrompt(),
                currentTask.getAspectRatio(),
                String.valueOf(currentTask.getDuration()),
                currentTask.isHdMode()
            );

            // 从API响应中提取真实任务ID
            // 注意：根据真实API响应，任务ID可能在不同的位置
            // 这里先记录API响应，后续根据实际响应调整
            logger.info("API响应数据: {}", apiResponse);
            
            // 尝试从不同位置提取任务ID
            String realTaskId = null;
            if (apiResponse.containsKey("data")) {
                Object data = apiResponse.get("data");
                if (data instanceof Map) {
                    // 如果data是Map，尝试获取taskNo（API返回的字段名）
                    realTaskId = (String) ((Map<?, ?>) data).get("taskNo");
                    if (realTaskId == null) {
                        // 如果没有taskNo，尝试taskId（兼容性）
                        realTaskId = (String) ((Map<?, ?>) data).get("taskId");
                    }
                } else if (data instanceof List) {
                    // 如果data是List，检查第一个元素
                    List<?> dataList = (List<?>) data;
                    if (!dataList.isEmpty()) {
                        Object firstElement = dataList.get(0);
                        if (firstElement instanceof Map) {
                            Map<?, ?> firstMap = (Map<?, ?>) firstElement;
                            realTaskId = (String) firstMap.get("taskNo");
                            if (realTaskId == null) {
                                realTaskId = (String) firstMap.get("taskId");
                            }
                        }
                    }
                }
            }
            
            // 如果找到了真实任务ID，保存到数据库
            if (realTaskId != null) {
                // 重新加载任务以确保获取最新状态
                currentTask = taskRepository.findByTaskId(task.getTaskId())
                    .orElseThrow(() -> new RuntimeException("任务不存在: " + task.getTaskId()));
                currentTask.setRealTaskId(realTaskId);
                taskRepository.save(currentTask);
                logger.info("真实任务ID已保存: {} -> {}", task.getTaskId(), realTaskId);
            } else {
                // 如果没有找到任务ID，说明任务提交失败（尝试通过 task_status 触发级联）
                // 注意：积分返还由 updateTaskStatusWithCascade 自动处理
                logger.error("任务提交失败：未从API响应中获取到任务ID");
                boolean updated = taskStatusPollingService.markTaskFailed(task.getTaskId(), "任务提交失败：API未返回有效的任务ID");
                if (!updated) {
                    // 回退：直接更新业务表
                    currentTask = taskRepository.findByTaskId(task.getTaskId())
                        .orElseThrow(() -> new RuntimeException("任务不存在: " + task.getTaskId()));
                    currentTask.updateStatus(TextToVideoTask.TaskStatus.FAILED);
                    currentTask.setErrorMessage("任务提交失败：API未返回有效的任务ID");
                    currentTask.setCompletedAt(LocalDateTime.now());
                    taskRepository.save(currentTask);
                    // 更新 UserWork
                    try {
                        userWorkService.updateWorkStatus(task.getTaskId(), 
                            com.example.demo.model.UserWork.WorkStatus.FAILED);
                    } catch (Exception e) {
                        logger.warn("回退更新UserWork状态失败: taskId={}", task.getTaskId());
                    }
                    // 回退时需要返还积分
                    returnFrozenPointsSafely(task.getTaskId());
                }
                return CompletableFuture.completedFuture(null); // 直接返回，不进行轮询
            }

            // 开始轮询真实任务状态
            pollRealTaskStatus(currentTask);
            
        } catch (Exception e) {
            logger.error("使用真实API处理文生视频任务失败: {}", task.getTaskId(), e);
            logger.error("异常详情: {}", e.getClass().getSimpleName() + ": " + e.getMessage());
            if (e.getCause() != null) {
                logger.error("异常原因: {}", e.getCause().getMessage());
            }
            
            try {
                // 尝试通过 task_status 触发级联更新
                // 注意：积分返还由 updateTaskStatusWithCascade 自动处理
                boolean updated = taskStatusPollingService.markTaskFailed(task.getTaskId(), e.getMessage());
                if (!updated) {
                    // 回退：直接更新业务表
                    TextToVideoTask currentTask = taskRepository.findByTaskId(task.getTaskId()).orElse(null);
                    if (currentTask != null) {
                        currentTask.updateStatus(TextToVideoTask.TaskStatus.FAILED);
                        currentTask.setErrorMessage(e.getMessage());
                        currentTask.setCompletedAt(LocalDateTime.now());
                        taskRepository.save(currentTask);
                        // 更新 UserWork
                        try {
                            userWorkService.updateWorkStatus(task.getTaskId(), 
                                com.example.demo.model.UserWork.WorkStatus.FAILED);
                        } catch (Exception ue) {
                            logger.warn("回退更新UserWork状态失败: taskId={}", task.getTaskId());
                        }
                        // 回退时需要返还积分
                        returnFrozenPointsSafely(task.getTaskId());
                    }
                }
            } catch (Exception saveException) {
                logger.error("保存失败状态时出错: {}", task.getTaskId(), saveException);
            }
        }
        
        return CompletableFuture.completedFuture(null);
    }

    /**
     * 轮询真实任务状态
     */
    private void pollRealTaskStatus(TextToVideoTask task) {
        try {
            String realTaskId = task.getRealTaskId();
            if (realTaskId == null) {
                logger.error("真实任务ID为空，无法轮询状态: {}", task.getTaskId());
                return;
            }

            // 轮询任务状态
            int maxAttempts = 450; // 最大轮询次数（15分钟）
            int attempt = 0;
            
            while (attempt < maxAttempts) {
                // 检查任务是否已被取消
                TextToVideoTask currentTask = taskRepository.findByTaskId(task.getTaskId()).orElse(null);
                if (currentTask != null && currentTask.getStatus() == TextToVideoTask.TaskStatus.CANCELLED) {
                    logger.info("任务 {} 已被取消，停止轮询", task.getTaskId());
                    // 任务取消时返还冻结积分
                    returnFrozenPointsSafely(task.getTaskId());
                    return;
                }
                
                // 使用最新的任务状态
                if (currentTask != null) {
                    task = currentTask;
                }

                try {
                    // 查询真实任务状态
                    Map<String, Object> statusResponse = realAIService.getTaskStatus(realTaskId);
                    logger.info("任务状态查询响应: {}", statusResponse);
                    
                    // 处理状态响应
                    if (statusResponse != null && statusResponse.containsKey("data")) {
                        Object data = statusResponse.get("data");
                        Map<?, ?> taskData = null;
                        
                        // 处理不同的响应格式
                        if (data instanceof Map) {
                            taskData = (Map<?, ?>) data;
                        } else if (data instanceof List) {
                            List<?> dataList = (List<?>) data;
                            if (!dataList.isEmpty() && dataList.get(0) instanceof Map) {
                                taskData = (Map<?, ?>) dataList.get(0);
                            }
                        }
                        
                        if (taskData != null) {
                            String status = (String) taskData.get("status");
                            Integer progress = (Integer) taskData.get("progress");
                            String resultUrl = (String) taskData.get("resultUrl");
                            String errorMessage = (String) taskData.get("errorMessage");

                            // 更新任务状态（通过 task_status 表触发级联）
                            if ("completed".equals(status) || "success".equals(status)) {
                                // 尝试通过 task_status 触发级联更新
                                boolean updated = taskStatusPollingService.markTaskCompleted(task.getTaskId(), resultUrl);
                                if (!updated) {
                                    // 回退：直接更新业务表
                                    task.setResultUrl(resultUrl);
                                    task.updateStatus(TextToVideoTask.TaskStatus.COMPLETED);
                                    task.updateProgress(100);
                                    task.setCompletedAt(LocalDateTime.now());
                                    taskRepository.save(task);
                                    // 更新 UserWork
                                    try {
                                        userWorkService.updateWorkOnComplete(task.getTaskId(), resultUrl, 
                                            com.example.demo.model.UserWork.WorkStatus.COMPLETED);
                                    } catch (Exception e) {
                                        logger.warn("回退更新UserWork状态失败: taskId={}", task.getTaskId());
                                    }
                                }
                                logger.info("文生视频任务完成: {}", task.getTaskId());
                                return;
                            } else if ("failed".equals(status) || "error".equals(status)) {
                                // 尝试通过 task_status 触发级联更新
                                // 注意：积分返还由 updateTaskStatusWithCascade 自动处理
                                boolean updated = taskStatusPollingService.markTaskFailed(task.getTaskId(), errorMessage);
                                if (!updated) {
                                    // 回退：直接更新业务表
                                    task.updateStatus(TextToVideoTask.TaskStatus.FAILED);
                                    task.setErrorMessage(errorMessage);
                                    task.setCompletedAt(LocalDateTime.now());
                                    taskRepository.save(task);
                                    // 更新 UserWork
                                    try {
                                        userWorkService.updateWorkStatus(task.getTaskId(), 
                                            com.example.demo.model.UserWork.WorkStatus.FAILED);
                                    } catch (Exception e) {
                                        logger.warn("回退更新UserWork状态失败: taskId={}", task.getTaskId());
                                    }
                                    // 回退时需要返还积分
                                    returnFrozenPointsSafely(task.getTaskId());
                                }
                                logger.error("文生视频任务失败: {}", task.getTaskId());
                                return;
                            } else if ("processing".equals(status) || "pending".equals(status) || "running".equals(status)) {
                                // 更新进度
                                if (progress != null) {
                                    task.updateProgress(progress);
                                } else {
                                    // 根据轮询次数估算进度
                                    int estimatedProgress = Math.min(90, (attempt * 100) / maxAttempts);
                                    task.updateProgress(estimatedProgress);
                                }
                                taskRepository.save(task);
                            }
                        }
                    }
                    
                } catch (Exception e) {
                    logger.warn("查询任务状态失败，继续轮询: {}", e.getMessage());
                    logger.warn("异常详情: {}", e.getClass().getSimpleName() + ": " + e.getMessage());
                }

                attempt++;
                Thread.sleep(2000); // 每2秒轮询一次
            }
            
            // 超时处理（尝试通过 task_status 触发级联）
            // 注意：积分返还由 updateTaskStatusWithCascade 自动处理
            boolean updated = taskStatusPollingService.markTaskFailed(task.getTaskId(), "任务处理超时");
            if (!updated) {
                // 回退：直接更新业务表
                task.updateStatus(TextToVideoTask.TaskStatus.FAILED);
                task.setErrorMessage("任务处理超时");
                task.setCompletedAt(LocalDateTime.now());
                taskRepository.save(task);
                // 更新 UserWork
                try {
                    userWorkService.updateWorkStatus(task.getTaskId(), 
                        com.example.demo.model.UserWork.WorkStatus.FAILED);
                } catch (Exception e) {
                    logger.warn("回退更新UserWork状态失败: taskId={}", task.getTaskId());
                }
                // 回退时需要返还积分
                returnFrozenPointsSafely(task.getTaskId());
            }
            logger.error("文生视频任务超时: {}", task.getTaskId());
            
        } catch (InterruptedException e) {
            logger.error("轮询任务状态被中断: {}", task.getTaskId(), e);
            // 线程中断时返还冻结积分
            returnFrozenPointsSafely(task.getTaskId());
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            logger.error("轮询任务状态异常: {}", task.getTaskId(), e);
            logger.error("异常详情: {}", e.getClass().getSimpleName() + ": " + e.getMessage());
            if (e.getCause() != null) {
                logger.error("异常原因: {}", e.getCause().getMessage());
            }
            // 轮询异常时返还冻结积分
            returnFrozenPointsSafely(task.getTaskId());
        }
    }

    /**
     * 处理视频生成过程
     */
    private void simulateVideoGeneration(TextToVideoTask task) throws InterruptedException {
        // 处理时间
        int totalSteps = 15; // 文生视频步骤更多
        for (int i = 1; i <= totalSteps; i++) {
            // 检查任务是否已被取消
            TextToVideoTask currentTask = taskRepository.findByTaskId(task.getTaskId()).orElse(null);
            if (currentTask != null && currentTask.getStatus() == TextToVideoTask.TaskStatus.CANCELLED) {
                logger.info("任务 {} 已被取消，停止处理", task.getTaskId());
                return;
            }
            
            Thread.sleep(1500); // 处理时间
            
            // 更新进度
            int progress = (i * 100) / totalSteps;
            task.updateProgress(progress);
            taskRepository.save(task);
            
            logger.debug("任务 {} 进度: {}%", task.getTaskId(), progress);
        }
    }

    /**
     * 获取用户任务列表
     */
    @Transactional(readOnly = true)
    public List<TextToVideoTask> getUserTasks(String username, int page, int size) {
        // 验证参数
        if (username == null || username.trim().isEmpty()) {
            throw new IllegalArgumentException("用户名不能为空");
        }
        if (page < 0) {
            page = 0;
        }
        if (size <= 0) {
            size = 10; // 默认每页10条
        }
        // 移除size上限限制，允许获取全部历史记录
        
        Pageable pageable = PageRequest.of(page, size);
        Page<TextToVideoTask> taskPage = taskRepository.findByUsernameOrderByCreatedAtDesc(username, pageable);
        return taskPage.getContent();
    }

    /**
     * 获取用户任务总数
     */
    @Transactional(readOnly = true)
    public long getUserTaskCount(String username) {
        if (username == null || username.trim().isEmpty()) {
            return 0;
        }
        return taskRepository.countByUsername(username);
    }

    /**
     * 根据任务ID获取任务
     */
    @Transactional(readOnly = true)
    public TextToVideoTask getTaskById(String taskId) {
        if (taskId == null || taskId.trim().isEmpty()) {
            return null;
        }
        return taskRepository.findByTaskId(taskId).orElse(null);
    }

    /**
     * 根据任务ID和用户名获取任务
     */
    @Transactional(readOnly = true)
    public TextToVideoTask getTaskByIdAndUsername(String taskId, String username) {
        if (taskId == null || taskId.trim().isEmpty() || username == null || username.trim().isEmpty()) {
            return null;
        }
        return taskRepository.findByTaskIdAndUsername(taskId, username).orElse(null);
    }


    /**
     * 获取待处理任务列表
     */
    @Transactional(readOnly = true)
    public List<TextToVideoTask> getPendingTasks() {
        return taskRepository.findPendingTasks();
    }

    /**
     * 生成任务ID
     */
    private String generateTaskId() {
        return "txt2vid_" + UUID.randomUUID().toString().replace("-", "").substring(0, 16);
    }

    /**
     * 生成结果URL
     */
    private String generateResultUrl(String taskId) {
        return outputPath + "/" + taskId + "/video_" + System.currentTimeMillis() + ".mp4";
    }

    /**
     * 清理过期任务
     */
    public int cleanupExpiredTasks() {
        LocalDateTime expiredDate = LocalDateTime.now().minusDays(30);
        return taskRepository.deleteExpiredTasks(expiredDate);
    }
    
    /**
     * 检查并处理超时的文生视频任务
     * 超时时间：1小时（视频生成需要较长时间）
     * 注意：如果任务已经有resultUrl（视频已生成），即使超时也不标记为失败
     */
    @Transactional
    public int checkAndHandleTimeoutTasks() {
        try {
            // 计算超时时间点（1小时前）
            LocalDateTime timeoutTime = LocalDateTime.now().minusMinutes(60);
            
            // 查找超时的任务（状态为PROCESSING，创建时间超过1小时）
            List<TextToVideoTask> timeoutTasks = taskRepository.findTimeoutTasks(
                TextToVideoTask.TaskStatus.PROCESSING,
                timeoutTime
            );
            
            if (timeoutTasks.isEmpty()) {
                return 0;
            }
            
            logger.warn("发现 {} 个可能超时的文生视频任务，开始检查", timeoutTasks.size());
            
            int handledCount = 0;
            int skippedCount = 0;
            for (TextToVideoTask task : timeoutTasks) {
                try {
                    // 检查任务是否已经有resultUrl（视频已生成）
                    // 如果有resultUrl，说明视频已经成功生成，不应该被标记为超时失败
                    if (task.getResultUrl() != null && !task.getResultUrl().isEmpty()) {
                        logger.debug("任务 {} 已有resultUrl，视频已生成，跳过超时标记", task.getTaskId());
                        skippedCount++;
                        continue;
                    }
                    
                    // 尝试通过 task_status 触发级联更新
                    // 注意：积分返还由 updateTaskStatusWithCascade 自动处理
                    boolean updated = taskStatusPollingService.markTaskFailed(task.getTaskId(), "文生视频任务超时：任务创建后超过1小时仍未完成");
                    if (!updated) {
                        // 回退：直接更新业务表
                        task.updateStatus(TextToVideoTask.TaskStatus.FAILED);
                        task.setErrorMessage("文生视频任务超时：任务创建后超过1小时仍未完成");
                        task.setCompletedAt(LocalDateTime.now());
                        taskRepository.save(task);
                        
                        // 更新 UserWork
                        try {
                            userWorkService.updateWorkStatusByTaskId(task.getTaskId(), 
                                com.example.demo.model.UserWork.WorkStatus.FAILED);
                        } catch (Exception e) {
                            logger.warn("回退更新UserWork状态失败: taskId={}", task.getTaskId());
                        }
                        
                        // 回退时需要返还积分
                        returnFrozenPointsSafely(task.getTaskId());
                    }
                    
                    logger.warn("文生视频任务超时，已标记为失败: taskId={}", task.getTaskId());
                    
                    handledCount++;
                } catch (Exception e) {
                    logger.error("处理超时文生视频任务失败: taskId={}", task.getTaskId(), e);
                }
            }
            
            if (handledCount > 0 || skippedCount > 0) {
                logger.info("处理超时文生视频任务完成，失败: {}/{}，跳过（已生成）: {}", 
                    handledCount, timeoutTasks.size(), skippedCount);
            }
            return handledCount;
            
        } catch (Exception e) {
            logger.error("检查超时文生视频任务失败", e);
            return 0;
        }
    }
    
    /**
     * 重试失败的文生视频任务
     * 复用原task_id，重新提交至外部API
     */
    @Transactional
    public TextToVideoTask retryTask(String taskId, String username) {
        logger.info("重试任务: taskId={}, username={}", taskId, username);
        
        // 获取任务
        TextToVideoTask task = taskRepository.findByTaskId(taskId)
            .orElseThrow(() -> new RuntimeException("任务不存在: " + taskId));
        
        // 验证权限
        if (!task.getUsername().equals(username)) {
            throw new RuntimeException("无权操作此任务");
        }
        
        // 允许重试：失败的任务、完成的任务、或者正在处理中的任务（可能卡住了）
        boolean canRetry = task.getStatus() == TextToVideoTask.TaskStatus.FAILED ||
            task.getStatus() == TextToVideoTask.TaskStatus.COMPLETED ||
            task.getStatus() == TextToVideoTask.TaskStatus.PROCESSING;
        
        if (!canRetry) {
            throw new RuntimeException("无法重试此任务，当前状态: " + task.getStatus());
        }
        
        logger.info("允许重试任务: taskId={}, 原状态={}, 原结果URL={}", 
            taskId, task.getStatus(), task.getResultUrl());
        
        // 重置任务状态为 PROCESSING（直接生成中）
        task.setStatus(TextToVideoTask.TaskStatus.PROCESSING);
        task.setErrorMessage(null);
        task.setRealTaskId(null); // 清除旧的外部任务ID
        task.setResultUrl(null);  // 清除旧的结果URL
        task.setProgress(0);
        task.setUpdatedAt(LocalDateTime.now());
        task.setCompletedAt(null);
        taskRepository.save(task);
        
        // 重新添加到任务队列
        try {
            taskQueueService.addTextToVideoTask(username, taskId);
            logger.info("重试任务已添加到队列: taskId={}", taskId);
        } catch (Exception e) {
            logger.error("添加重试任务到队列失败: taskId={}", taskId, e);
            // 回滚任务状态
            task.setStatus(TextToVideoTask.TaskStatus.FAILED);
            task.setErrorMessage("重试失败: " + e.getMessage());
            taskRepository.save(task);
            throw new RuntimeException("重试失败: " + e.getMessage());
        }
        
        // 更新UserWork状态为PROCESSING
        try {
            userWorkService.updateWorkStatus(taskId, com.example.demo.model.UserWork.WorkStatus.PROCESSING);
        } catch (Exception e) {
            logger.warn("更新UserWork状态失败: taskId={}", taskId, e);
        }
        
        // 更新task_status表状态
        try {
            taskStatusPollingService.updateTaskStatusWithCascade(
                taskId, 
                com.example.demo.model.TaskStatus.Status.PROCESSING, 
                null, 
                null
            );
        } catch (Exception e) {
            logger.warn("更新task_status状态失败: taskId={}", taskId, e);
        }
        
        return task;
    }
    
    /**
     * 安全返还冻结积分（捕获异常，避免影响主流程）
     */
    private void returnFrozenPointsSafely(String taskId) {
        try {
            userService.returnFrozenPoints(taskId);
            logger.info("已返还冻结积分: taskId={}", taskId);
        } catch (Exception e) {
            logger.warn("返还冻结积分失败（可能未冻结）: taskId={}, error={}", taskId, e.getMessage());
        }
    }
}
