package com.gkhy.exam.system.service.impl;

import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.domain.entity.SysUser;
import com.gkhy.exam.common.enums.QuestionTypeEnum;
import com.gkhy.exam.common.enums.UserTypeEnum;
import com.gkhy.exam.common.exception.ApiException;
import com.gkhy.exam.common.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.ExExamPaper;
import com.gkhy.exam.system.domain.ExPaperStudent;
import com.gkhy.exam.system.domain.ExPhaseStudent;
import com.gkhy.exam.system.domain.ExStudent;
import com.gkhy.exam.system.mapper.*;
import com.gkhy.exam.system.service.ExPaperStudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 学员与考试题目关系表 服务实现类
 * </p>
 *
 * @author kzy
 * @since 2024-06-06 13:53:17
 */
@Service
public class ExPaperStudentServiceImpl extends ServiceImpl<ExPaperStudentMapper, ExPaperStudent> implements ExPaperStudentService {
    @Autowired
    private ExExamPaperMapper examPaperMapper;
    @Autowired
    private ExStudentAnswerMapper studentAnswerMapper;
    @Autowired
    private ExStudentMapper studentMapper;
    @Autowired
    private ExPhaseStudentMapper phaseStudentMapper;


    @Override
    public CommonPage selectPaperStudentListForStudent(ExPaperStudent paperStudent) {
        SysUser user= SecurityUtils.getLoginUser().getUser();
        if(!Objects.equals(user.getUserType(), UserTypeEnum.STUDENT.getCode())){
            throw new ApiException("非学员用户，不能查看");
        }
        paperStudent.setStudentId(user.getId());
        PageUtils.startPage();
        List<ExPaperStudent> paperList=baseMapper.selectPaperStudentList(paperStudent);
        return CommonPage.restPage(paperList);
    }

    @Override
    public ExPaperStudent selectPaperStudentById(Long paperStudentId) {
        return baseMapper.selectPaperStudentById(paperStudentId);
    }

    @Override
    public ExPaperStudent selectPaperStudentById(ExPaperStudent paperStudent) {
        return baseMapper.selectByPaperStudentId(paperStudent);
    }

    @Override
    public int addPaperStudent(ExPaperStudent paperStudent) {
        checkUserAllowed(paperStudent);
        checkStudentUnique(Collections.singletonList(paperStudent));
        paperStudent.setCreateId(SecurityUtils.getUserId());
        int row=baseMapper.insert(paperStudent);
        if(row<1){
            throw new ApiException("分配学员失败");
        }
        return row;
    }

    @Override
    public int batchAddPaperStudent(Map<String,Object> paperStudentMap) {
        List<Long> phaseIds= (List<Long>) paperStudentMap.get("phaseIds");
        List<Long> studentIds= (List<Long>) paperStudentMap.get("studentIds");
        if(ObjectUtil.isEmpty(phaseIds) && ObjectUtil.isEmpty(studentIds)){
            throw new ApiException("批次id与学员id不能同时为空");
        }
        Long paperId= (Long) paperStudentMap.get("paperId");
        if(paperId==null){
            throw new ApiException("考卷id不能为空");
        }
        //按批次绑定用户
        if(phaseIds.size()>0){
            List<ExPhaseStudent> phaseStudentList=phaseStudentMapper.selectList( Wrappers.<ExPhaseStudent>lambdaQuery()
                    .in(ExPhaseStudent::getPhaseId, phaseIds));
            studentIds=phaseStudentList.stream().map(item -> item.getStudentId()).distinct().collect(Collectors.toList());
        }
        List<ExPaperStudent> paperStudents=studentIds.stream().map(item -> {
            return new ExPaperStudent().setPaperId(paperId).setStudentId(item);
        }).collect(Collectors.toList());
        checkStudentUnique(paperStudents);
        int row=baseMapper.batchInsert(paperStudents);
        if(row<1){
            throw new ApiException("批量分配学员失败");
        }
        return row;
    }

    @Override
    public void checkStudentUnique(List<ExPaperStudent> paperStudents){
        for(ExPaperStudent paperStudent:paperStudents) {
            Integer existCount = baseMapper.selectCountByPaperStudentId(paperStudent.getPaperId(), paperStudent.getStudentId());
            if (existCount > 0) {
                ExStudent student = studentMapper.selectById(paperStudent.getStudentId());
                throw new ApiException(String.format("待分配学员<%s>已存在", student.getName()));
            }
        }
    }

    @Override
    public CommonPage selectPaperStudentList(ExPaperStudent paperStudent) {
        if(paperStudent.getPaperId()==null){
            throw new ApiException("考卷id不能为空");
        }
        PageUtils.startPage();
        List<ExPaperStudent> paperStudentList=baseMapper.selectPaperStudentList(paperStudent);
        return CommonPage.restPage(paperStudentList);
    }

    @Override
    public int deletePaperStudent(Long paperStudentId) {
        ExPaperStudent paperStudent=baseMapper.selectPaperStudentById(paperStudentId);
        if(ObjectUtil.isNull(paperStudent)){
            throw new ApiException(String.format("该试卷下不存在该学员<>",paperStudent.getStudentName()));
        }
        checkUserAllowed(paperStudent);
        int studentAnswerCount=studentAnswerMapper.countByPaperId(paperStudent.getPaperId(),paperStudent.getStudentId());
        if(studentAnswerCount>0){
            throw new ApiException(String.format("学员<%s>已进行答题，不能删除",paperStudent.getStudentName()));
        }
        //删除学员与试卷关系
        return baseMapper.deleteById(paperStudentId);
    }

    @Override
    @Transactional(rollbackFor = RuntimeException.class)
    public void batchDeletePaperStudent(List<Long> paperStudentIds) {
        for(Long paperStudentId:paperStudentIds){
            deletePaperStudent(paperStudentId);
        }
    }


    public void checkUserAllowed(ExPaperStudent paperStudent) {
        SysUser currentUser= SecurityUtils.getLoginUser().getUser();
        if(currentUser.getUserType().equals(UserTypeEnum.SYSTEM_USER.getCode())){
            return;
        }
        if(currentUser.getUserType().equals(UserTypeEnum.STUDENT.getCode())){
            throw new ApiException("没有权限操作");
        }
        ExExamPaper examPaper=examPaperMapper.selectById(paperStudent.getPaperId());
        if(!currentUser.getCompanyId().equals(examPaper.getCompanyId())){
            throw new ApiException("没有权限操作其他企业考卷");
        }

    }

    @Override
    public void endExam(ExPaperStudent paperStudent) {
        Long endTime=System.currentTimeMillis();
        //异步计算
        //计算考试成绩
        ExExamPaper paper=examPaperMapper.selectById(paperStudent.getPaperId());
        int singleCount=studentAnswerMapper.selectPassCount(paperStudent.getPaperId(),paperStudent.getStudentId(), QuestionTypeEnum.SINGLE.getCode());
        int multiCount=studentAnswerMapper.selectPassCount(paperStudent.getPaperId(),paperStudent.getStudentId(), QuestionTypeEnum.MULTI.getCode());
        int judgeCount=studentAnswerMapper.selectPassCount(paperStudent.getPaperId(),paperStudent.getStudentId(), QuestionTypeEnum.JUDGE.getCode());
        int score=singleCount*paper.getSingleScore()+multiCount*paper.getMultiScore()+judgeCount*paper.getJudgeScore();
        ExPaperStudent exPaperStudent = new ExPaperStudent()
                .setPaperId(paperStudent.getPaperId())
                .setStudentId(paperStudent.getStudentId())
                .setCompleted(1)
                .setEndTime(endTime)
                .setScore(score);
        if(score>=paper.getPassScore()){
            exPaperStudent.setPassed(1);
        }else{
            exPaperStudent.setPassed(0);
        }
        int row=baseMapper.updateById(exPaperStudent);
        if(row<1){
            throw new ApiException("提交考试失败");
        }
    }



}