package com.supervision.job;

import com.alibaba.fastjson.JSON;
import com.supervision.police.domain.NotePrompt;
import com.supervision.police.domain.TaskCaseRecord;
import com.supervision.police.domain.TaskRecord;
import com.supervision.police.service.*;
import com.xxl.job.core.context.XxlJobHelper;
import com.xxl.job.core.handler.annotation.XxlJob;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.Map;

import static com.supervision.common.constant.NotePromptConstants.TYPE_GRAPH_REASONING;
import static com.supervision.common.constant.NotePromptConstants.TYPE_STRUCTURAL_REASONING;
import static com.supervision.common.constant.TaskRecordConstants.*;

@Slf4j
@Component
@RequiredArgsConstructor
public class XxlJobTask {
    private CaseEvidenceService caseEvidenceService;
    private TaskRecordService taskRecordService;
    private TaskCaseRecordService taskCaseRecordService;
    private ModelCaseService modelCaseService;
    private NotePromptService notePromptService;

    /**
     * 睡觉通知
     */
    @XxlJob("evidenceAnalysis")
    public void evidenceAnalysis() {
        String param = XxlJobHelper.getJobParam();
        log.info("【证据解析】任务开始。ID: 【{}】", param);
        try {
            caseEvidenceService.evidenceAnalysis(param);
        } catch (Exception e) {
            log.error("任务执行失败", e);
        } finally {
            log.info("任务执行完成");
        }
    }

    /**
     * 提取任务
     */
    @XxlJob("extractTask")
    public void extractEvidenceByTask() {
        Map<String, String> map = JSON.parseObject(XxlJobHelper.getJobParam(), Map.class);
        log.info("【提取任务】任务开始。参数: 【{}】", map.toString());
        String taskId = map.get("taskId");
        String caseId = map.get("caseId");
        String promptId = map.get("promptId");
        NotePrompt prompt = notePromptService.getById(promptId);
        boolean executable = true;
        try {
            TaskRecord taskRecord = taskRecordService.getById(taskId);
            switch (taskRecord.getStatus()) {
                case TASK_STATUS_WAITING:
                    log.info("任务状态为等待中，任务状态更新为处理中，任务ID: 【{}】", taskId);
                    taskRecord.setStatus(TASK_STATUS_PROCESSING);
                    taskRecordService.updateById(taskRecord);
                    break;
                case TASK_STATUS_CANCELLING:
                    log.info("任务状态为取消中，任务状态更新为已取消，任务ID: 【{}】", taskId);
                    taskRecord.setStatus(TASK_STATUS_CANCELED);
                    taskRecordService.updateById(taskRecord);
                    executable = false;
                    break;
                case TASK_STATUS_CANCELED:
                    log.info("任务状态为已取消，任务不可执行，任务ID: 【{}】", taskId);
                    executable = false;
                    break;
                default:
                    break;
            }
            if (executable) {
                TaskCaseRecord taskCaseRecord = taskCaseRecordService.lambdaQuery().eq(TaskCaseRecord::getCaseId, caseId).eq(TaskCaseRecord::getTaskRecordId, taskId).one();
                if (TASK_STATUS_WAITING.equals(taskCaseRecord.getStatus())) {
                    log.info("任务状态为等待中，任务状态更新为处理中，任务案件ID: 【{}】", taskCaseRecord.getId());
                    taskCaseRecord.setStatus(TASK_STATUS_PROCESSING);
                    taskCaseRecordService.updateById(taskCaseRecord);
                }
                switch (prompt.getType()) {
                    case TYPE_GRAPH_REASONING:
                        // TODO: 笔录处理
                        break;
                    case TYPE_STRUCTURAL_REASONING:
                        // TODO: 证据处理
                        break;
                    default:
                        log.error("未知的任务类型");
                        break;
                }
            }
        } catch (Exception e) {
            log.error("任务执行失败", e);
        } finally {
            log.info("【提取任务】任务结束。");
        }
    }

}