package com.qmth.distributed.print.api;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.qmth.boot.api.annotation.Aac;
import com.qmth.boot.api.annotation.BOOL;
import com.qmth.boot.api.constant.ApiConstant;
import com.qmth.boot.api.exception.ApiException;
import com.qmth.distributed.print.business.bean.dto.*;
import com.qmth.distributed.print.business.bean.params.ArraysParams;
import com.qmth.distributed.print.business.bean.result.EditResult;
import com.qmth.distributed.print.business.entity.*;
import com.qmth.distributed.print.business.enums.*;
import com.qmth.distributed.print.business.service.*;
import com.qmth.distributed.print.business.templete.execute.AsyncPaperReviewPdfExportService;
import com.qmth.distributed.print.business.templete.execute.AsyncTaskReviewSampleExportService;
import com.qmth.distributed.print.business.util.ServletUtil;
import com.qmth.distributed.print.common.contant.SystemConstant;
import com.qmth.distributed.print.common.enums.ExceptionResultEnum;
import com.qmth.distributed.print.common.util.Result;
import com.qmth.distributed.print.common.util.ResultUtil;
import io.swagger.annotations.*;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import java.io.IOException;
import java.util.*;

/**
 * <p>
 * 命题任务 前端控制器
 * </p>
 *
 * @author xf
 * @since 2021-03-23
 */
@Api(tags = "命题任务Controller")
@RestController
@RequestMapping(ApiConstant.DEFAULT_URI_PREFIX + "/${prefix.url.exam}/task")
public class ExamTaskController {

    @Autowired
    private ExamTaskService examTaskService;

    @Autowired
    private ExamTaskDetailService examTaskDetailService;

    @Autowired
    private ExamTaskReviewLogService examTaskReviewLogService;

    @Autowired
    private BasicAttachmentService basicAttachmentService;

    @Resource
    private TBTaskService tbTaskService;

    @Resource
    private AsyncTaskReviewSampleExportService asyncTaskReviewSampleExportService;

    @Autowired
    private CommonService commonService;

    @Resource
    private BasicMessageService basicMessageService;

    /**
     * 查询
     *
     * @param enable
     * @param status
     * @param cardRuleId
     * @param courseCode
     * @param paperNumber
     * @param startTime
     * @param endTime
     * @param pageNumber
     * @param pageSize
     * @return
     */
    @ApiOperation(value = "查询")
    @RequestMapping(value = "/list", method = RequestMethod.POST)
    public Result list(@RequestParam(required = false) Boolean enable,
                       @RequestParam(required = false) String status,
                       @RequestParam(required = false) Long cardRuleId,
                       @RequestParam(required = false) String courseCode,
                       @RequestParam(required = false) String paperNumber,
                       @RequestParam(required = false) Long startTime,
                       @RequestParam(required = false) Long endTime,
                       @RequestParam Integer pageNumber,
                       @RequestParam Integer pageSize) {
        IPage<ExamTaskDto> examTasks = examTaskService.list(enable, status, cardRuleId, courseCode, paperNumber, startTime, endTime, pageNumber, pageSize);
        return ResultUtil.ok(examTasks);
    }

    /**
     * 试卷编号模糊查询
     *
     * @param param
     * @return
     */
    @ApiOperation(value = "试卷编号模糊查询")
    @RequestMapping(value = "/paper_number_query", method = RequestMethod.POST)
    public Result paperNumberQuery(@RequestParam(value = "param", required = false) String param,
                                   @RequestParam(value = "printPlanId", required = false) Long printPlanId) {
        List<String> list = examTaskService.listPaperNumber(param, printPlanId);
        return ResultUtil.ok(list);
    }

    /**
     * 命题老师模糊查询
     *
     * @param param
     * @return
     */
    @ApiOperation(value = "命题老师模糊查询")
    @RequestMapping(value = "/user_query", method = RequestMethod.POST)
    public Result userQuery(@RequestParam(value = "param", required = false) String param) {
        List<BlurryUserDto> list = examTaskService.listUser(param);
        return ResultUtil.ok(list);
    }

    /**
     * 更改/指派命题老师
     *
     * @param examTask
     * @return
     */
    @ApiOperation(value = "更改/指派命题老师")
    @RequestMapping(value = "/assign_user", method = RequestMethod.POST)
    public Result assignUser(@RequestBody ExamTask examTask) {
        boolean isSuccess = examTaskService.assignUser(examTask);
        return ResultUtil.ok(isSuccess);
    }

    /**
     * 启用/禁用
     *
     * @param examTask
     * @return
     */
    @ApiOperation(value = "启用/禁用")
    @RequestMapping(value = "/enable", method = RequestMethod.POST)
    public Result enable(@RequestBody ExamTask examTask) {
        boolean isSuccess = examTaskService.enable(examTask);
        return ResultUtil.ok(isSuccess);
    }

    /**
     * 新建
     *
     * @param examTask
     * @return
     */
    @ApiOperation(value = "新建")
    @RequestMapping(value = "/save", method = RequestMethod.POST)
    public Result save(@RequestBody ExamTask examTask) {
        ExamTask task = examTaskService.saveExamTask(examTask);
        //发送短信
        if (task.getId() != null) {
            basicMessageService.sendNoticeTaskCreate(task);
        }
        return ResultUtil.ok(true);
    }

    /**
     * 文件导入
     *
     * @param file
     * @return
     */
    @ApiOperation(value = "文件导入")
    @RequestMapping(value = "/import", method = RequestMethod.POST)
    public Result importFile(@ApiParam(value = "上传文件", required = true) @RequestParam MultipartFile file) {
        BasicAttachment basicAttachment = null;
        try {
            basicAttachment = basicAttachmentService.saveAttachment(file, ServletUtil.getRequestMd5(), UploadFileEnum.FILE);
            if (Objects.isNull(basicAttachment)) {
                throw ExceptionResultEnum.ATTACHMENT_ERROR.exception();
            } else {
                ExamTaskImportDto examTaskImportDto = examTaskService.importFile(file);
                return ResultUtil.ok(examTaskImportDto);
            }
        } catch (Exception e) {
            if (Objects.nonNull(basicAttachment)) {
                basicAttachmentService.deleteAttachment(basicAttachment);
            }
            if (e instanceof ApiException) {
                ResultUtil.error((ApiException) e, e.getMessage());
            } else {
                ResultUtil.error(e.getMessage());
            }
        }
        return null;
    }

    /**
     * 批量保存
     *
     * @param task
     * @return
     */
    @ApiOperation(value = "批量保存")
    @RequestMapping(value = "/save_batch", method = RequestMethod.POST)
    public Result saveBatch(@RequestBody ExamTask task) {
        List<ExamTask> examTasks = examTaskService.saveBatch(task);
        if (examTasks != null && examTasks.size() > 0) {
            // 发送短信
            ExamTask[] tasks = examTasks.toArray(new ExamTask[examTasks.size()]);
            basicMessageService.sendNoticeTaskCreate(tasks);
        }
        return ResultUtil.ok(true);
    }


    /**
     * 审核历史
     *
     * @param request
     * @param examTaskId
     * @return
     */
    @ApiOperation(value = "审核历史")
    @RequestMapping(value = "/review_list", method = RequestMethod.POST)
    public Result reviewList(HttpServletRequest request,
                             @RequestParam("examTaskId") Long examTaskId) {
        List<ReviewLogDto> list = examTaskReviewLogService.list(examTaskId);
        return ResultUtil.ok(list);
    }

    /**
     * 入库申请查询
     *
     * @param auditStatus
     * @param reviewStatus
     * @param cardRuleId
     * @param courseCode
     * @param paperNumber
     * @param startTime
     * @param endTime
     * @param pageNumber
     * @param pageSize
     * @return
     */
    @ApiOperation(value = "入库申请查询")
    @RequestMapping(value = "/apply_list", method = RequestMethod.POST)
    public Result taskApplyList(@RequestParam(value = "auditStatus", required = false) String auditStatus,
                                @RequestParam(value = "reviewStatus", required = false) String reviewStatus,
                                @RequestParam(value = "cardRuleId", required = false) Long cardRuleId,
                                @RequestParam(value = "courseCode", required = false) String courseCode,
                                @RequestParam(value = "paperNumber", required = false) String paperNumber,
                                @RequestParam(value = "startTime", required = false) Long startTime,
                                @RequestParam(value = "endTime", required = false) Long endTime,
                                @RequestParam("pageNumber") Integer pageNumber,
                                @RequestParam("pageSize") Integer pageSize) {
        IPage<ExamTaskDto> list = examTaskService.listTaskApply(auditStatus, reviewStatus, cardRuleId, courseCode, paperNumber, startTime, endTime, pageNumber, pageSize);
        return ResultUtil.ok(list);
    }

    /**
     * 根据命题任务ID查询单个数据
     *
     * @param request
     * @param examTaskId
     * @return
     */
    @ApiOperation(value = "根据命题任务ID查询单个数据")
    @RequestMapping(value = "/apply_get_one", method = RequestMethod.POST)
    public Result applyGetOne(HttpServletRequest request,
                              @RequestParam(value = "examTaskId", required = true) Long examTaskId,
                              @RequestParam(value = "source", required = false) String source) {
        ExamTaskDetailCardDto detail = examTaskService.applyGetOne(examTaskId, source);
        return ResultUtil.ok(detail);
    }

    /**
     * 暂存/提交
     *
     * @param examTaskDetail
     * @return
     */
    @ApiOperation(value = "暂存/提交")
    @RequestMapping(value = "/apply_save", method = RequestMethod.POST)
    public Result taskApplySave(@RequestBody ExamTaskDetail examTaskDetail) throws IOException {
        boolean isSuccess = examTaskService.saveExamTaskDetail(examTaskDetail);
        ExamTask examTask = examTaskService.getById(examTaskDetail.getExamTaskId());
        if (examTaskDetail.getOperateType().equals(ExamStatusEnum.SUBMIT.name()) && !examTask.getReview()) {
            // 校验是否可以提交打印状态
            commonService.checkData(examTask.getSchoolId(), examTask.getCourseCode(), examTask.getPaperNumber(), (SysUser) ServletUtil.getRequestUser());
        }
        //待审核状态，发送短信
        if (ExamStatusEnum.SUBMIT.equals(examTask.getStatus())) {
            basicMessageService.sendNoticeTaskAuditCreateOrReview(examTask, MessageEnum.NOTICE_OF_AUDIT_CREATED);
        }

        return ResultUtil.ok(isSuccess);
    }

    /**
     * 撤回/重新申请
     *
     * @param examTask
     * @return
     */
    @ApiOperation(value = "撤回")
    @RequestMapping(value = "/apply_status", method = RequestMethod.POST)
    public Result taskApplyStatus(@RequestBody ExamTask examTask) {
        boolean isSuccess = examTaskService.status(examTask);
        return ResultUtil.ok(isSuccess);
    }

    /**
     * 入库审核查询-未审核
     *
     * @param courseCode
     * @param paperNumber
     * @param userId
     * @param cardRuleId
     * @param startTime
     * @param endTime
     * @param pageNumber
     * @param pageSize
     * @return
     */
    @ApiOperation(value = "入库审核查询-未审核")
    @RequestMapping(value = "/review_list_unaudited", method = RequestMethod.POST)
    public Result taskReviewListUnaudited(@RequestParam(value = "courseCode", required = false) String courseCode,
                                          @RequestParam(value = "paperNumber", required = false) String paperNumber,
                                          @RequestParam(value = "userId", required = false) Long userId,
                                          @RequestParam(value = "cardRuleId", required = false) Long cardRuleId,
                                          @RequestParam(value = "startTime", required = false) Long startTime,
                                          @RequestParam(value = "endTime", required = false) Long endTime,
                                          @RequestParam("pageNumber") Integer pageNumber,
                                          @RequestParam("pageSize") Integer pageSize) {
        IPage<ExamTaskDto> examTaskDtoIPage = examTaskService.listTaskReviewUnaudited(courseCode, paperNumber, userId, cardRuleId, startTime, endTime, pageNumber, pageSize);
        return ResultUtil.ok(examTaskDtoIPage);
    }

    /**
     * 入库审核查询-未审核
     *
     * @param courseCode
     * @param paperNumber
     * @param userId
     * @param cardRuleId
     * @param startTime
     * @param endTime
     * @param pageNumber
     * @param pageSize
     * @return
     */
    @ApiOperation(value = "入库审核查询-已审核")
    @RequestMapping(value = "/review_list_audited", method = RequestMethod.POST)
    public Result taskReviewListAudited(@RequestParam(value = "reviewStatus", required = false) String reviewStatus,
                                        @RequestParam(value = "courseCode", required = false) String courseCode,
                                        @RequestParam(value = "paperNumber", required = false) String paperNumber,
                                        @RequestParam(value = "userId", required = false) Long userId,
                                        @RequestParam(value = "cardRuleId", required = false) Long cardRuleId,
                                        @RequestParam(value = "startTime", required = false) Long startTime,
                                        @RequestParam(value = "endTime", required = false) Long endTime,
                                        @RequestParam("pageNumber") Integer pageNumber,
                                        @RequestParam("pageSize") Integer pageSize) {
        IPage<ExamTaskDto> examTaskDtoIPage = examTaskService.listTaskReviewAudited(reviewStatus, courseCode, paperNumber, userId, cardRuleId, startTime, endTime, pageNumber, pageSize);
        return ResultUtil.ok(examTaskDtoIPage);
    }

    /**
     * 审核
     *
     * @param taskReviewLog
     * @return
     */
    @ApiOperation(value = "审核")
    @RequestMapping(value = "/review_save", method = RequestMethod.POST)
    public Result taskReviewSave(@RequestBody ExamTaskReviewLog taskReviewLog) throws IOException {
        List<Long> examTaskIdList = new ArrayList<>();
        examTaskIdList.add(taskReviewLog.getExamTaskId());
        SysUser sysUser = (SysUser) ServletUtil.getRequestUser();
        boolean isSuccess = examTaskService.taskReviewSave(taskReviewLog);
        if (isSuccess && taskReviewLog.getReviewStatus().name().equals(ReviewStatusEnum.PASS.name())) {
            ExamTask examTask = examTaskService.getById(taskReviewLog.getExamTaskId());
            // 校验是否可以提交打印状态
            commonService.checkData(examTask.getSchoolId(), examTask.getCourseCode(), examTask.getPaperNumber(), sysUser);
            // 发送审核通过短信通知
            basicMessageService.noticeOfExamTaskAudit(examTaskIdList, MessageEnum.NOTICE_OF_AUDIT_PASS, sysUser);
        } else if (isSuccess && taskReviewLog.getReviewStatus().name().equals(ReviewStatusEnum.NOT_PASS.name())) {
            // 发送审核不通过短信通知
            basicMessageService.noticeOfExamTaskAudit(examTaskIdList, MessageEnum.NOTICE_OF_AUDIT_NOT_PASS, sysUser);
        }
        return ResultUtil.ok(isSuccess);
    }

    /**
     * 批量审核
     *
     * @param taskReviewLog
     * @return
     */
    @ApiOperation(value = "批量审核")
    @RequestMapping(value = "/review_save_batch", method = RequestMethod.POST)
    public Result taskReviewSaveBatch(@RequestBody ExamTaskReviewLog taskReviewLog) throws IOException {
        List<Long> examTaskIdList = Arrays.asList(taskReviewLog.getExamTaskIds());
        SysUser sysUser = (SysUser) ServletUtil.getRequestUser();
        boolean isSuccess = examTaskService.taskReviewSaveBatch(taskReviewLog);
        if (isSuccess && taskReviewLog.getReviewStatus().name().equals(ReviewStatusEnum.PASS.name())) {
            // 发送审核通过短信通知
            basicMessageService.noticeOfExamTaskAudit(examTaskIdList, MessageEnum.NOTICE_OF_AUDIT_PASS, sysUser);
        } else if (isSuccess && taskReviewLog.getReviewStatus().name().equals(ReviewStatusEnum.NOT_PASS.name())) {
            // 发送审核不通过短信通知
            basicMessageService.noticeOfExamTaskAudit(examTaskIdList, MessageEnum.NOTICE_OF_AUDIT_NOT_PASS, sysUser);
        }
        return ResultUtil.ok(isSuccess);
    }

    @ApiOperation(value = "导出审核样本")
    @RequestMapping(value = "/review_export", method = RequestMethod.POST)
    public Result taskReviewExport(@Valid @RequestBody ArraysParams arraysParams, BindingResult bindingResult) throws Exception {
        if (bindingResult.hasErrors()) {
            return ResultUtil.error(bindingResult.getAllErrors().get(0).getDefaultMessage());
        }
        Long[] ids = arraysParams.getIds();
        Map<String, Object> map = tbTaskService.saveTask(TaskTypeEnum.SAMPLE_EXPORT);
        map.put("ids", ids);
        asyncTaskReviewSampleExportService.exportTask(map);
        TBTask tbTask = Objects.nonNull(map.get(SystemConstant.TASK)) ? (TBTask) map.get(SystemConstant.TASK) : null;
        return Objects.nonNull(tbTask) ? ResultUtil.ok(tbTask.getId()) : ResultUtil.error("创建任务失败");
    }

    /**
     * 卷库查询
     *
     * @param courseCode
     * @param paperNumber
     * @param startTime
     * @param endTime
     * @param pageNumber
     * @param pageSize
     * @return
     */
    @ApiOperation(value = "卷库查询")
    @RequestMapping(value = "/paper_list", method = RequestMethod.POST)
    public Result taskPaperList(@RequestParam(value = "courseCode", required = false) String courseCode,
                                @RequestParam(value = "paperNumber", required = false) String paperNumber,
                                @RequestParam(value = "startTime", required = false) Long startTime,
                                @RequestParam(value = "endTime", required = false) Long endTime,
                                @RequestParam("pageNumber") Integer pageNumber,
                                @RequestParam("pageSize") Integer pageSize) {
        IPage<ExamTaskDetailDto> examTaskDtoIPage = examTaskService.listTaskPaper(courseCode, paperNumber, startTime, endTime, pageNumber, pageSize);
        return ResultUtil.ok(examTaskDtoIPage);
    }


    /**
     * 下载
     *
     * @param response
     * @param examTaskId
     */
    @ApiOperation(value = "下载")
    @RequestMapping(value = "/paper_download", method = RequestMethod.POST)
    public void taskPaperDownload(HttpServletResponse response, @RequestParam Long examTaskId) {
        examTaskService.paperDownload(response, examTaskId);
    }

    /**
     * 卷库查询-启用/禁用
     *
     * @param examTaskDetail
     * @return
     */
    @ApiOperation(value = "卷库查询-启用/禁用")
    @RequestMapping(value = "/paper_enable", method = RequestMethod.POST)
    public Result taskPaperEnable(@RequestBody ExamTaskDetail examTaskDetail) throws IOException {
        boolean isSuccess = examTaskDetailService.enable(examTaskDetail);
        // 启用，触发考场生成pdf
        if (examTaskDetail.getEnable()) {
            SysUser sysUser = (SysUser) ServletUtil.getRequestUser();
            ExamTask examTask = examTaskService.getById(examTaskDetail.getId());
            // 校验课程关联考场，是否已经提交打印
            Boolean isCreate = commonService.checkExamDetailStatus(examTask.getSchoolId(), null, examTask.getCourseCode(), examTask.getPaperNumber());
            // 校验是否可以提交打印状态
            if (isCreate) {
                commonService.checkData(examTask.getSchoolId(), examTask.getCourseCode(), examTask.getPaperNumber(), sysUser);
            }
        }
        return ResultUtil.ok(isSuccess);
    }

    /**
     * 卷库查询-卷库修改
     *
     * @param examTaskDetail
     * @return
     */
    @ApiOperation(value = "卷库查询-卷库修改")
    @RequestMapping(value = "/paper_update", method = RequestMethod.POST)
    public Result taskPaperUpdate(@RequestBody ExamTaskDetail examTaskDetail) throws IOException {
        boolean isSuccess = examTaskDetailService.paperUpdate(examTaskDetail);
        if (isSuccess) {
            ExamTask examTask = examTaskService.getById(examTaskDetail.getExamTaskId());
            if (examTask.getReview()) {
                // 发送短信
                basicMessageService.sendNoticeTaskAuditCreateOrReview(examTask, MessageEnum.NOTICE_OF_AUDIT_REVIEW);
            } else {
                SysUser sysUser = (SysUser) ServletUtil.getRequestUser();
                // 校验课程关联考场，是否已经提交打印
                Boolean isCreate = commonService.checkExamDetailStatus(examTask.getSchoolId(), null, examTask.getCourseCode(), examTask.getPaperNumber());
                // 校验是否可以提交打印状态
                if (isCreate) {
                    commonService.checkData(examTask.getSchoolId(), examTask.getCourseCode(), examTask.getPaperNumber(), sysUser);
                }
            }
        }
        return ResultUtil.ok(isSuccess);
    }

    @ApiOperation(value = "卷库查询-批量下载试卷PDF、题卡")
    @RequestMapping(value = "/paper_card_download_pdf", method = RequestMethod.POST)
    @ApiResponses({@ApiResponse(code = 200, message = "返回信息", response = EditResult.class)})
    public Result paperCardDownloadPdf(@RequestParam(value = "courseCode", required = false) String courseCode,
                                  @RequestParam(value = "paperNumber", required = false) String paperNumber,
                                  @RequestParam(value = "startTime", required = false) Long startTime,
                                  @RequestParam(value = "endTime", required = false) Long endTime) {
        TBTask tbTask = examTaskService.taskDownloadPdf(courseCode, paperNumber, startTime, endTime);
        return Objects.nonNull(tbTask) ? ResultUtil.ok(new EditResult(tbTask.getId())) : ResultUtil.error("创建任务失败");
    }
}