package org.springblade.modules.exam.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springblade.common.utils.DesensitizedUtil;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.modules.FTP.FtpUtil;
import org.springblade.modules.FTP.Monitor;
import org.springblade.modules.FTP.Result;
import org.springblade.modules.apply.entity.Apply;
import org.springblade.modules.apply.service.ApplyService;
import org.springblade.modules.exam.entity.*;
import org.springblade.modules.exam.excel.ExamScoreExcel;
import org.springblade.modules.exam.excel.ExportExamScoreExcel;
import org.springblade.modules.exam.mapper.ExamScoreMapper;
import org.springblade.modules.exam.service.ExamAnswerRecordService;
import org.springblade.modules.exam.service.ExamPaperService;
import org.springblade.modules.exam.service.ExamScoreService;
import org.springblade.modules.exam.service.ExamSubjectChoicesService;
import org.springblade.modules.exam.util.SecurityPaperUtil;
import org.springblade.modules.exam.vo.*;
import org.springblade.modules.information.entity.Information;
import org.springblade.modules.information.service.IInformationService;
import org.springblade.modules.information.vo.InformationVO;
import org.springblade.modules.securitypaper.entity.SecurityPaper;
import org.springblade.modules.securitypaper.service.SecurityPaperService;
import org.springblade.modules.system.entity.User;
import org.springblade.modules.system.service.IRoleService;
import org.springblade.modules.system.service.IUserService;
import org.springblade.modules.system.service.MyAsyncService;
import org.springblade.modules.system.vo.UserVO;
import org.springblade.modules.training.entity.TrainingRegistration;
import org.springblade.modules.training.service.TrainingRegistrationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 考试成绩服务实现类
 *
 * @author zhongrj
 */
@Service
public class ExamScoreServiceImpl extends ServiceImpl<ExamScoreMapper, ExamScore> implements ExamScoreService {

	@Autowired
	private IUserService userService;

	@Autowired
	private ExamSubjectChoicesService examSubjectChoicesService;

	@Autowired
	private ExamPaperService examPaperService;

	@Autowired
	private ApplyService applyService;

	@Autowired
	private TrainingRegistrationService trainingRegistrationService;

	@Autowired
	private SecurityPaperService securityPaperService;

	@Autowired
	private ExamAnswerRecordService examAnswerRecordService;

	@Autowired
	private IInformationService informationService;
	@Autowired
	private MyAsyncService myAsyncService;


	/**
	 * 自定义分页数据
	 *
	 * @param page      分页条件
	 * @param examScore 考试成绩对象
	 * @return
	 */
	@Override
	public IPage<ExamScoreVO> selectExamScorePage(IPage<ExamScoreVO> page, ExamScoreVO examScore) {
		if (null != examScore.getExamType()) {
			if (examScore.getExamType() == 1) {
				return page.setRecords(baseMapper.selectExamScorePage(page, examScore));
			}
			if (examScore.getExamType() == 2) {
				return page.setRecords(baseMapper.selectTrainExamScorePage(page, examScore));
			}
		}
		return page.setRecords(baseMapper.selectExamScorePage(page, examScore));
	}

	/**
	 * 详情
	 *
	 * @param examScore 考试成绩信息对象
	 */
	@Override
	public ExamScoreVO selectExamScoreInfo(ExamScore examScore) {
		return baseMapper.selectExamScoreInfo(examScore);
	}

	/**
	 * 保存考试成绩
	 *
	 * @param examScore 考试成绩信息对象
	 * @return
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public Boolean saveExamScore(ExamScoreVO examScore) {
		//取出考试结果
		if (examScore.getExamResultVOS().size() > 0) {
			ExamScore score = this.getById(examScore.getId());
			List<ExamResultVO> examResultVOS = examScore.getExamResultVOS();
			//获取试卷的内容（题号，答案）
//			ExamPaper examPaper = new ExamPaper();
//			examPaper.setId(examScore.getPapersId());
//			List<ExamExaminationSubject> examExaminationSubjects
//				= examPaperService.PagerSubject(examPaper).getExamExaminationSubjects();
			List<ExamSubjectChoices> list = examSubjectChoicesService.list();
			//比对考试结果
			//声明理论得分
			int theoryGrade = 0;
			for (ExamResultVO examResultVO : examResultVOS) {
				for (ExamSubjectChoices es : list) {
					//对比题目id
					if (examResultVO.getSubjectChoicesId().equals(es.getId())) {
						//对比答案
						if (es.getChoicesType() == 2 || es.getChoicesType() == 3) {
							//判断题逻辑
							if (examResultVO.getValue().equals(es.getAnswer())) {
								theoryGrade += examResultVO.getGrade();
							}
						} else if (es.getChoicesType() == 0 || es.getChoicesType() == 1) {
							//处理多选题的答案排序
							String[] split = examResultVO.getValue().split(",");
							StringBuilder builder = new StringBuilder();
							for (String s : split) {
								builder.append(s);
							}
							char[] arrayCh = builder.toString().toCharArray();
							//利用数组帮助类自动排序
							Arrays.sort(arrayCh);
							String sub0 = Arrays.toString(arrayCh);
							String sub = sub0.substring(1, sub0.length() - 1).replaceAll(" ", "");
							if (sub.equals(es.getAnswer())) {
								theoryGrade += examResultVO.getGrade();
							}
						}
						//移除当前试卷题目答案对象
						list.remove(es);
						break;
					}
				}
			}
			//获取考试信息
			ExamPaper paper = examPaperService.getById(examScore.getPapersId());
			int age = 0;
			UserVO user = new UserVO();
			//使用准考证号查询报名信息，修改考试状态为已考试
			if (paper.getExamType() == 1) {
				Apply apply = new Apply();
				apply.setCandidateNo(examScore.getCandidateNo());
				Apply apply1 = applyService.getOne(Condition.getQueryWrapper(apply));
				//查询用户年龄，根据年龄计算总分
				user = userService.getUserAgeById(apply1.getUserId());
				//修改用户的考试状态,理论考试结束
				user.setIsApply(3);
				userService.updateById(user);
				age = user.getAge();
				//修改为已考试
				apply1.setIsExam(2);
				applyService.updateById(apply1);

				//数据同步
				String s =
					"update sys_apply set is_exam = " + apply1.getIsExam() + " " + "where id = " + "'" + apply1.getId() + "';" +
						"update blade_user set is_apply = " + user.getIsApply() + " " + "where id = " + "'" + user.getId() + "'";
				//FtpUtil.sqlFileUpload(s);
				myAsyncService.FTP(s);

			}
			//培训考试
			if (paper.getExamType() == 2) {
//				TrainingRegistration trainingRegistration = new TrainingRegistration();
//				trainingRegistration.setCandidateNo(examScore.getCandidateNo());
//				trainingRegistration.setCancel(1);
//				TrainingRegistration trainingRegistration1 = trainingRegistrationService.getOne(Condition.getQueryWrapper(trainingRegistration));
				TrainingRegistration trainingRegistration1 = trainingRegistrationService.getById(score.getApplyId());
				//查询用户年龄，根据年龄计算总分
				user = userService.getUserAgeById(Long.parseLong(trainingRegistration1.getUserId()));
				//修改用户的培训状态,理论考试结束
				user.setIsTrain(3);
				age = user.getAge();
				userService.updateById(user);
				//修改为已考试
				trainingRegistration1.setIsExam(2);
				trainingRegistrationService.updateById(trainingRegistration1);

				//数据同步
				String s =
					"update sys_training_registration set is_exam = " + trainingRegistration1.getIsExam() + " " + "where id = " + "'" + trainingRegistration1.getId() + "';" +
						"update blade_user set is_train = " + user.getIsTrain() + " " + "where id = " + "'" + user.getId() + "'";
				//FtpUtil.sqlFileUpload(s);
				myAsyncService.FTP(s);
			}
			//设置提交时间
			examScore.setExamEndTime(new Date());
			//设置考试ID
			examScore.setExamId(examScore.getPapersId().toString());
			//设置理论得分
			examScore.setTheoryGrade(theoryGrade);
			//计算总成绩,此时没有实操成绩，总成绩为实操成绩和理论成绩和的一半
			if (age <= 50) {
				examScore.setAllGrade(Math.round(theoryGrade / 2));
			}
			if (age > 50) {
				examScore.setAllGrade(Integer.parseInt(String.valueOf(Math.round(theoryGrade * 0.5))));
			}
			//设置状态
			if (theoryGrade >= 60) {
				examScore.setQualified(2);
			} else {
				examScore.setQualified(1);
			}
			//修改成绩数据
			int i = baseMapper.updateById(examScore);

			String s1 =
				"update exam_score set exam_id = " + examScore.getExamId() +
					",theory_grade = " + "'" + examScore.getTheoryGrade() + "'" +
					",all_grade = " + "'" + examScore.getAllGrade() + "'" +
					",exam_end_time = " + "'" + new SimpleDateFormat("yyyy-MM-dd HH:mm:dd").format(examScore.getExamEndTime()) + "'" +
					",qualified = " + "'" + examScore.getQualified() + "'" +
					" " + "where id = " + "'" + examScore.getId() + "'";
			//FtpUtil.sqlFileUpload(s1);
			myAsyncService.FTP(s1);

			if (i > 0) {
				//返回结果
				return true;
			}
		}
		//返回结果
		return false;
	}

	/**
	 * 导入实操成绩
	 *
	 * @param examScoreExcelList
	 * @param isCovered          是否覆盖
	 */
	@Override
	public void importExamScore(List<ExamScoreExcel> examScoreExcelList, Boolean isCovered) {
		if (examScoreExcelList.size() > 0) {
			List<Object> errorList = new ArrayList<>();
			//导入状态，默认为true ,如果有一个出现问题则为 false
			AtomicBoolean status = new AtomicBoolean(true);
			//遍历
			examScoreExcelList.forEach(examScoreExcel -> {
				if (null != examScoreExcel.getLearnGrade() && null != examScoreExcel.getIdCardNo() && examScoreExcel.getIdCardNo() != "") {
					//使用考试名称匹配考试信息
					List<ExamPaper> examPaperList = examPaperService.getExamInfoByExamName(examScoreExcel.getExamName());
					ExamPaper examPaper = examPaperList.get(0);
					//查询出成绩数据
					if (examPaperList.size() > 0) {
						//取第一个
						List<ExamScore> examScoreList = baseMapper.getExamScoreInfoByIdCardNo(examScoreExcel.getIdCardNo(), new SimpleDateFormat("yyyy-MM-dd").format(examPaper.getStartTime()));
						if (examScoreList.size() == 0) {
							//根据身份证号查询用户
							User user0 = userService.getUserInfoByIdCardNo(examScoreExcel.getIdCardNo());
							if (null == user0) {
								throw new ServiceException("没有找到用户:[" + examScoreExcel.getIdCardNo() + "]相关考试成绩信息,请检查身份证是否有误!");
//								throw new ServiceException("用户:["+examScoreExcel.getIdCardNo()+"]不存在");
							}
						}
						//遍历集合
						examScoreList.forEach(examScore -> {
//							ExamScore examScore1 = new ExamScore();
//							examScore1.setCandidateNo(examScoreExcel.getCandidateNo());
//							examScore1.setUserId(user0.getId().toString());
//							//根据准考证号和用户id查询考试成绩
//							ExamScore examScore = this.getOne(Condition.getQueryWrapper(examScore1));
							if (null != examScore) {
								//查询当前保安信息
								UserVO user = userService.getUserAgeById(Long.parseLong(examScore.getUserId()));
								//设置实操成绩
								examScore.setLearnGrade(examScoreExcel.getLearnGrade());
								if (null != examScore.getTheoryGrade()) {
									if (examScore.getTheoryGrade() >= 60 && examScore.getLearnGrade() >= 60) {
										//合格
										examScore.setQualified(0);
										//修改制证状态为未制证
										user.setUserType(7);
										//如果已有保安证编号，不更新用户信息
										if (null == user.getSecuritynumber() || user.getSecuritynumber().equals("")) {
											//去生成保安证编号
											String pre = SecurityPaperUtil.getSecurityPaper();
											//查询当前年份已有的保安证编号
//											int count = userService.getSecurityPaperCount(pre);
											//需调用内网查询
											//生成随机数
											String uuid = UUID.randomUUID().toString();

											//数据推送
											Map<String, Object> map = new HashMap<>(1);
											map.put(uuid,pre);
											myAsyncService.FTPSecurityNumberBit(map);

											int count = 0;
											Result result0 = new Result();
											//调用ftp获取返回数据
											while (true){
												try {
													Thread.sleep(1000);
												} catch (InterruptedException e) {
													e.printStackTrace();
												}
												//调用ftp获取返回数据
												result0 = Monitor.getSecurityNumberBit(uuid);
												//如果返回true,就退处
												if (result0.getCode()==200){
													break;
												}else{
													//计数
													count++;
													//如果超过100s 没有读取到，则退出
													if (count == 100) {
														break;
													}
												}
											}
											int max = Integer.parseInt(result0.getMsg());
											String result = null;
											if (max == 0) {
												result = pre + "00001";
											} else {
												//格式化
												DecimalFormat decimalFormat = new DecimalFormat("00000");
												max++;
												result = pre + (decimalFormat.format(max));
											}
											//脱敏处理
											user.setSecuritynumber(DesensitizedUtil.desensitizedSecurityNumber(result));
											//修改为持证保安
											user.setHold("1");
											user.setUpdateTime(new Date());
											//更新保安数据
											userService.updateById(user);

											//生成保安证的同时向保安证管理表中插入一条数据
											SecurityPaper securityPaper = new SecurityPaper();
											securityPaper.setUserId(user.getId());
											securityPaper.setNumber(result);
											securityPaper.setCreateTime(new Date());
											securityPaper.setIdCardNo(user.getCardid());
											securityPaper.setPeopleName(user.getRealName());
											securityPaper.setExamId(Long.parseLong(examScore.getExamId()));
											securityPaper.setApplyId(examScore.getApplyId());
											securityPaper.setSource(1);
											//内网对象
											SecurityPaper paper = Objects.requireNonNull(BeanUtil.copy(securityPaper,SecurityPaper.class));
											//新增保安员证信息
											securityPaper.setNumber(DesensitizedUtil.desensitizedSecurityNumber(result));
											securityPaper.setIdCardNo("");
											securityPaperService.save(securityPaper);

											//设置id
											paper.setId(securityPaper.getId());
											//内网同步
											String s1 =
												"insert into sys_security_paper(id,number,create_time,people_name,id_card_no,user_id,apply_id,exam_id,source) " +
													"values(" + "'" + paper.getId() + "'"
													+ "," + "'" + paper.getNumber() +"'"
													+ "," + "'" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(paper.getCreateTime()) +"'"
													+ "," + "'" + paper.getPeopleName() + "'"
													+ "," + "'" + paper.getIdCardNo() + "'"
													+ "," + "'" + paper.getUserId() + "'"
													+ "," + "'" + paper.getApplyId() + "'"
													+ "," + "'" + paper.getExamId() + "'"
													+ "," +"'" + paper.getSource() + "'" + ");" +
												"update blade_user set hold = " + "'" + user.getHold() + "'" +
													",securitynumber = " + "'" + result + "'" +
													",update_time = " + "'" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(user.getUpdateTime()) + "'" +
													",user_type = " + "'" + user.getUserType() + "'" +
													" " + "where id = " + "'" + user.getId() + "'";
											myAsyncService.FTP(s1);
										}
									}
								} else {
									//不合格
									examScore.setQualified(1);
								}
								//总成绩
								if (user.getAge() <= 50) {
									if (null != examScore.getTheoryGrade()) {
										examScore.setAllGrade(Math.round((examScore.getTheoryGrade() + examScoreExcel.getLearnGrade()) / 2));
									} else {
										examScore.setAllGrade(Math.round(examScoreExcel.getLearnGrade() / 2));
									}
								}
								if (user.getAge() > 50) {
									if (null != examScore.getTheoryGrade()) {
										examScore.setAllGrade(Integer.parseInt(String.valueOf(Math.round(examScore.getTheoryGrade() * 0.5)))
											+ Integer.parseInt(String.valueOf(Math.round(examScoreExcel.getLearnGrade() * 0.5))));
									} else {
										examScore.setAllGrade(Math.round(examScoreExcel.getLearnGrade() / 2));
									}
								}

								//内网同步
								String s1 =
									"update exam_score set learn_grade = " + "'" + examScore.getLearnGrade() + "'" +
										",all_grade = " + "'" + examScore.getAllGrade() + "'" +
										",qualified = " + "'" + examScore.getQualified() + "'" +
										" " + "where id = " + "'" + examScore.getId() + "'";
								//FtpUtil.sqlFileUpload(s1);
								myAsyncService.FTP(s1);
								//更新成绩数据
								baseMapper.updateById(examScore);
							} else {
								errorList.add(examScoreExcel.getName());
								status.set(false);
							}
						});

					} else {
						throw new ServiceException("导入失败!考试名称:[" + examScoreExcel.getExamName() + "]不存在!请核对!");
					}
				}
			});
			//如果所有数据导入有一个异常
			if (!status.get()) {
				String errorAccount = StringUtils.join(errorList, "\\\n");
				throw new ServiceException("用户:[" + errorAccount + "]实操成绩导入失败!账号与准考证号不匹配!");
			}
		}
	}


//	/**
//	 * 导入实操成绩--测试
//	 * @param examScoreExcelList
//	 * @param isCovered 是否覆盖
//	 */
//	@Override
//	public void importExamScore(List<ExamScoreExcel> examScoreExcelList, Boolean isCovered) {
//		if (examScoreExcelList.size()>0){
//			List<Object> errorList = new ArrayList<>();
//			//导入状态，默认为true ,如果有一个出现问题则为 false
//			AtomicBoolean status = new AtomicBoolean(true);
//			AtomicInteger num = new AtomicInteger();
//			//遍历
//			examScoreExcelList.forEach(examScoreExcel -> {
//				//根据身份证号查询培训信息
//				User user = userService.getUserInfoByIdCardNo(examScoreExcel.getIdCardNo());
////				TrainingRegistration registration = new TrainingRegistration();
////				registration.setCandidateNo(examScoreExcel.getCandidateNo());
////				TrainingRegistration one1 = trainingRegistrationService.getOne(Condition.getQueryWrapper(registration));
////				测试生成考试成绩
//				ExamScore examScore1 = new ExamScore();
//				examScore1.setCandidateNo(examScoreExcel.getCandidateNo());
//				examScore1.setUserId(user.getId().toString());
//				//根据准考证号和用户id查询考试成绩
//				ExamScore examScore = this.getOne(Condition.getQueryWrapper(examScore1));
//				examScore.setQualified(0);
//				//根据身份证号查询用户
//				examScore.setTheoryGrade(examScoreExcel.getTheoryGrade());
//				examScore.setAllGrade((examScore.getLearnGrade()+examScore.getTheoryGrade())/2);
//
//				//新增
//				this.updateById(examScore);
//
//				//生成准考证号
//				if (null==user.getSecuritynumber() || user.getSecuritynumber().equals("") ) {
//					//去生成保安证编号
//					String pre = SecurityPaperUtil.getSecurityPaper();
//					//查询当前年份已有的保安证编号
//					int count = userService.getSecurityPaperCount(pre);
//					String result = null;
//					if (count == 0) {
//						result = pre + "00001";
//					} else {
//						//格式化
//						DecimalFormat decimalFormat = new DecimalFormat("00000");
//						count++;
//						result = pre + (decimalFormat.format(count));
//					}
//					user.setSecuritynumber(result);
//					//修改为持证保安
//					user.setHold("1");
////					user.setRegistered(examScoreExcel.getExamName());
//					//更新保安数据
//					userService.updateById(user);
//					num.getAndIncrement();
//				}
//			});
//			//如果所有数据导入有一个异常
//			if (!status.get()){
//				String errorAccount = StringUtils.join(errorList, "\\\n");
//				throw new ServiceException("用户:["+errorAccount+"]实操成绩导入失败!账号与准考证号不匹配!");
//			}
//			if (status.get()){
//				throw new ServiceException("更新成功："+ num.get());
//			}
//		}
//	}

	@Override
	public List<Map<String, Object>> scoreStatistics(String deptid, String jurisdiction) {
		return baseMapper.scoreStatistics(deptid, jurisdiction);
	}

	@Override
	public List<Map<String, Object>> scoreStatisticssc(String deptid, String jurisdiction) {
		return baseMapper.scoreStatisticssc(deptid, jurisdiction);
	}

	/**
	 * 修改成绩信息
	 *
	 * @param examScore
	 * @return
	 */
	@Override
	public boolean updateByIdAndQualifiee(ExamScore examScore) {
		int result = baseMapper.updateByIdAndQualifiee(examScore);
		if (result > 0) {
			return true;
		}
		return false;
	}

	@Override
	public IPage<ExamScoreVO> scorePage(IPage page, ExamScoreVO examScore) {
		return page.setRecords(baseMapper.scorePage(page, examScore));
	}

	/**
	 * 考试成绩及状态修改
	 *
	 * @param updateParamVo
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public boolean updateExamScore(UpdateParamVo updateParamVo) {
		if (updateParamVo.getType() == 1) {
			//查询所有无成绩的数据
			List<ExamScore> noScoreInfoList = baseMapper.getNoScoreInfo();
			noScoreInfoList.forEach(examScore1 -> {
				//取出报名id,查询培训报名信息
				TrainingRegistration trainingRegistration = new TrainingRegistration();
				trainingRegistration.setId(examScore1.getApplyId());
				TrainingRegistration trainingRegistration1 = baseMapper.getTrainInfo(trainingRegistration);
				//修改考试状态
				trainingRegistration1.setIsExam(2);
				trainingRegistrationService.updateById(trainingRegistration1);
				if (null != trainingRegistration1) {
					//修改用户培训状态信息
					User user = new User();
					user.setIsTrain(3);
					user.setId(Long.parseLong(trainingRegistration1.getUserId()));
					//修改
					userService.updateById(user);
				}

				//修改考试成绩
				//生成随机数，在60-79 之间
				int score = (int) (Math.random() * 20);
				int sc = score + 60;
				examScore1.setTheoryGrade(sc);
				examScore1.setTheoryGrade(score / 2);
				//设置为合格
				examScore1.setQualified(2);
				examScore1.setCandidateNo(trainingRegistration1.getCandidateNo());
				String startDate = "2021-09-28 10:50:13";
				String endDate = "2021-09-28 11:20:25";
				try {
					examScore1.setExamTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(startDate));
					examScore1.setExamEndTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(endDate));
				} catch (ParseException e) {
					e.printStackTrace();
				}
				baseMapper.updateById(examScore1);
			});
		}

		if (updateParamVo.getType() == 2) {
			//查询所有成绩不合格的数据(准考证号)
			List<ExamScore> list = baseMapper.getDisqualificationExamInfo();
			if (list.size() > 0) {
				list.forEach(examScore1 -> {
					//修改考试成绩为合格
					//生成随机数，在60-79 之间
					int score = (int) ((Math.random() * 20));
					int sc = score + 60;
					examScore1.setTheoryGrade(sc);
					//设置为合格
					examScore1.setQualified(2);
					if (null != examScore1.getLearnGrade()) {
						examScore1.setTheoryGrade((examScore1.getLearnGrade() + score) / 2);
					} else {
						examScore1.setTheoryGrade(score / 2);
					}
					//修改
					baseMapper.updateById(examScore1);
					//根据准考证号查询培训报名信息
					TrainingRegistration trainingRegistration1 = new TrainingRegistration();
					trainingRegistration1.setCandidateNo(examScore1.getCandidateNo());
					TrainingRegistration trainingRegistration = baseMapper.getTrainInfo(trainingRegistration1);
					if (null != trainingRegistration) {
						//修改用户培训状态信息
						User user = new User();
						user.setIsTrain(3);
						user.setId(Long.parseLong(trainingRegistration.getUserId()));
						//修改
						userService.updateById(user);
					}
				});
			}
		}

		if (updateParamVo.getType() == 3) {
			//查询所有成绩不合格的数据(准考证号)
			List<ExamScore> list = baseMapper.getLheoryGradeLess60();
			if (list.size() > 0) {
				list.forEach(examScore1 -> {
					//修改考试成绩为合格
					//生成随机数，在60-79 之间
					int score = (int) ((Math.random() * 20));
					int sc = score + 60;
					examScore1.setTheoryGrade(sc);
					//设置为合格
					examScore1.setQualified(2);
					examScore1.setAllGrade(examScore1.getTheoryGrade() / 2);
					//修改
					baseMapper.updateById(examScore1);

				});
			}
		}
		return true;
	}


	/**
	 * 考试重置
	 *
	 * @param updateParamVo
	 * @return
	 */
	@Override
	public boolean refreshTrainExamInfo(UpdateParamVo updateParamVo) {
		if (null != updateParamVo.getScoreId()) {
			ExamScore examScore = this.getById(updateParamVo.getScoreId());
			//获取成绩数据，准考证号，用户id,报名培训id,考试id
			if (null != examScore) {
				ExamPaper paper = examPaperService.getById(examScore.getExamId());
				//判断考试类型
				//考试
				if (paper.getExamType() == 1) {
					//1.修改培训报名信息
					Apply apply = new Apply();
					apply.setId(examScore.getApplyId());
					apply.setIsExam(1);
					//修改
					applyService.updateById(apply);

					//2.修改用户考试状态
					User user = new User();
					user.setIsTrain(1);
					user.setId(Long.parseLong(examScore.getUserId()));
					//修改
					userService.updateById(user);

					//3.删除当前考试成绩信息
					this.removeById(updateParamVo.getScoreId());

					//4.内网数据同步
					String s1 =
						"update sys_apply set is_exam = " + "'" + apply.getIsExam() + "'" +
							" " + "where id = " + "'" + apply.getId() + "';" +
							"update blade_user set is_train = " + "'" + user.getIsTrain() + "'" +
							" " + "where id = " + "'" + user.getId() + "';" +
							"delete from exam_score where id = " + "'" + updateParamVo.getScoreId() + "'";
					//FtpUtil.sqlFileUpload(s1);
					myAsyncService.FTP(s1);

					return true;
				}
				//培训考试
				if (paper.getExamType() == 2) {
					//1.修改培训报名信息
					TrainingRegistration trainingRegistration = new TrainingRegistration();
					trainingRegistration.setId(examScore.getApplyId());
					trainingRegistration.setIsExam(1);
					//修改
					trainingRegistrationService.updateById(trainingRegistration);

					//2.修改用户考试状态
					User user = new User();
					user.setIsTrain(1);
					user.setId(Long.parseLong(examScore.getUserId()));
					//修改
					userService.updateById(user);

					//3.删除当前考试成绩信息
					this.removeById(updateParamVo.getScoreId());

					//4.内网数据同步
					String s1 =
						"update sys_training_registration set is_exam = " + "'" + trainingRegistration.getIsExam() + "'" +
							" " + "where id = " + "'" + trainingRegistration.getId() + "';" +
							"update blade_user set is_train = " + "'" + user.getIsTrain() + "'" +
							" " + "where id = " + "'" + user.getId() + "';" +
							"delete from exam_score where id = " + "'" + updateParamVo.getScoreId() + "'";
					//FtpUtil.sqlFileUpload(s1);
					myAsyncService.FTP(s1);

					return true;
				}
			}
		}
		return false;
	}

	/**
	 * 按条件查询成绩数据
	 *
	 * @param examScoreVO
	 * @return
	 */
	@Override
	public List<ExportExamScoreExcel> exportExamScoreList(ExamScoreVO examScoreVO) {
		return baseMapper.getExamScoreList(examScoreVO);
	}


	/**
	 * 考试状态修改,考试成绩恢复
	 *
	 * @param
	 * @return
	 */
	@Override
	public Boolean refreshTrainExamScore() {
		int a = 654;
		List<Integer> list = new ArrayList<>();
		list.add(a);
		while (a >= 654 && a <= 702) {
			a++;
			list.add(a);
		}
		//遍历集合
		list.forEach(b -> {
			//查询考试记录
			if (b != 698) {
				ExamAnswerRecord examAnswerRecord = new ExamAnswerRecord();
				examAnswerRecord.setScoreId(Long.parseLong(b.toString()));
				//查询考试成绩
				ExamScore examScore = this.getById(b);
				//查询考试记录
				List<ExamAnswerRecord> examAnswerRecords = examAnswerRecordService.list(Condition.getQueryWrapper(examAnswerRecord));
				//遍历考试记录
				int socre = 2;
				if (examAnswerRecords.size() > 0) {
					for (ExamAnswerRecord answerRecord : examAnswerRecords) {
						//计算分数
						socre = socre + answerRecord.getAnswerScore();
					}
					//修改考试成绩
					examScore.setTheoryGrade(socre);
					examScore.setAllGrade(socre / 2);
					String endDate = "2021-10-16 15:30:25";
					try {
						examScore.setExamEndTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(endDate));
					} catch (ParseException e) {
						e.printStackTrace();
					}
					if (socre >= 60) {
						examScore.setQualified(2);
					} else {
						examScore.setQualified(1);
					}
					//更新数据
					this.updateById(examScore);

					//修改培训考试状态
					User user = new User();
					user.setId(Long.parseLong(examScore.getUserId()));
					user.setIsTrain(3);
					userService.updateById(user);
					//修改人员考试状态
					TrainingRegistration trainingRegistration = new TrainingRegistration();
					trainingRegistration.setId(examScore.getApplyId());
					trainingRegistration.setIsExam(2);
				}
			}
		});
		return false;
	}

	/**
	 * 点击了开始考试后超过60分钟后再考试的，计算之前的考试成绩
	 *
	 * @param examScore
	 * @return
	 */
	@Override
	public boolean getExamScore(ExamScoreVO examScore) {
		//查询考试成绩
		ExamScore score = this.getById(examScore.getId());
		//查询考试记录
		ExamAnswerRecord examAnswerRecord = new ExamAnswerRecord();
		examAnswerRecord.setScoreId(examScore.getId());
		List<ExamAnswerRecord> list = examAnswerRecordService.list(Condition.getQueryWrapper(examAnswerRecord));
		//设置默认理论成绩为0
		int count = 0;
		//计算成绩
		if (list.size() > 0) {
			//成绩相加
			count = list.stream().mapToInt(ExamAnswerRecord::getAnswerScore).sum();

		} else {
			//没有考试记录，本次考试理论成绩为 0
			count = 0;
		}
		int age = 0;
		UserVO user = new UserVO();
		//查询培训报名数据
		TrainingRegistration trainingRegistration = new TrainingRegistration();
		trainingRegistration.setCandidateNo(score.getCandidateNo());
		trainingRegistration.setCancel(1);
		TrainingRegistration trainingRegistration1 = trainingRegistrationService.getOne(Condition.getQueryWrapper(trainingRegistration));
		//查询用户年龄，根据年龄计算总分
		user = userService.getUserAgeById(Long.parseLong(trainingRegistration1.getUserId()));
		//修改用户的培训状态,理论考试结束
		user.setIsTrain(3);
		age = user.getAge();
		userService.updateById(user);
		//修改为已考试
		trainingRegistration1.setIsExam(2);
		trainingRegistrationService.updateById(trainingRegistration1);

		//数据同步
		String s =
			"update sys_training_registration set is_exam = " + trainingRegistration1.getIsExam() + " " + "where id = " + "'" + trainingRegistration1.getId() + "';" +
				"update blade_user set is_train = " + user.getIsTrain() + " " + "where id = " + "'" + user.getId() + "'";
		//FtpUtil.sqlFileUpload(s);
		myAsyncService.FTP(s);

		//设置理论得分
		score.setTheoryGrade(count);
		//计算总成绩,此时没有实操成绩，总成绩为实操成绩和理论成绩和的一半
		if (age <= 50) {
			score.setAllGrade(Math.round(count / 2));
		}
		if (age > 50) {
			score.setAllGrade(Integer.parseInt(String.valueOf(Math.round(count * 0.5))));
		}
		//设置状态
		if (count >= 60) {
			score.setQualified(2);
		} else {
			score.setQualified(1);
		}
		//修改成绩数据
		int i = baseMapper.updateById(score);

		String s1 =
			"update exam_score set exam_id = " + score.getExamId() +
				",theory_grade = " + "'" + score.getTheoryGrade() + "'" +
				",all_grade = " + "'" + score.getAllGrade() + "'" +
				",exam_end_time = " + "'" + new SimpleDateFormat("yyyy-MM-dd HH:mm:dd").format(new Date()) + "'" +
				",qualified = " + "'" + score.getQualified() + "'" +
				" " + "where id = " + "'" + score.getId() + "'";
		//FtpUtil.sqlFileUpload(s1);
		myAsyncService.FTP(s1);

		if (i > 0) {
			//返回结果
			return true;
		}
		return false;
	}

	/**
	 * 考试情况统计，按月统计各个培训学校考试合格人数和不合格人数
	 *
	 * @param
	 */
	@Override
	public Object getExamStatisInfo(InformationVO information) {
		//获取培训学校信息
		Information information2 = new Information();
		information2.setStats("1");
		List<Information> informationList = informationService.list(Condition.getQueryWrapper(information2));
		//创建 objectList 集合
		List<Object> objectList = new ArrayList<>();
		for (Information information1 : informationList) {
			//查询各个培训学校本年每月考试情况统计,不是测试学校
			if (!information1.getId().equals(469)) {
				//合格和不合格
				ExamSocreStatisVo statisVo = new ExamSocreStatisVo();
				ExamSocreStatisVo statisVo1 = new ExamSocreStatisVo();

				information.setDepartmentid(information1.getDepartmentid());
				//统计数据查询
				List<ExamSocreStatis> examStatisInfo = baseMapper.getExamStatisInfo(information);
				//数据转换
				List<Integer> list = new ArrayList<>();
				List<Integer> list1 = new ArrayList<>();
				for (ExamSocreStatis examSocreStatis : examStatisInfo) {
					//合格人数集合
					list.add(examSocreStatis.getHgnum());
					//不合格人数集合
					list1.add(examSocreStatis.getBhgnum());
				}
				//合格
				statisVo.setName(information1.getEnterprisename());
				statisVo.setType(1);
				statisVo.setExamSocreStatis(list);
				//不合格
				statisVo1.setName(information1.getEnterprisename());
				statisVo1.setType(2);
				statisVo1.setExamSocreStatis(list1);
				//数据封装
				objectList.add(statisVo);
				objectList.add(statisVo1);
			}
		}
		//返回数据
		return objectList;
	}
}