package com.qxgmat.service.extend;

import com.github.pagehelper.Page;
import com.nuliji.tools.AbstractService;
import com.nuliji.tools.PageResult;
import com.nuliji.tools.Tools;
import com.nuliji.tools.Transform;
import com.qxgmat.data.constants.enums.QuestionType;
import com.qxgmat.data.constants.enums.logic.ExerciseLogic;
import com.qxgmat.data.constants.enums.status.DirectionStatus;
import com.qxgmat.data.dao.entity.*;
import com.qxgmat.data.relation.ExercisePaperRelationMapper;
import com.qxgmat.data.relation.QuestionNoRelationMapper;
import com.qxgmat.data.relation.UserPaperRelationMapper;
import com.qxgmat.data.relation.UserReportRelationMapper;
import com.qxgmat.data.relation.entity.QuestionNoRelation;
import com.qxgmat.service.inline.ExercisePaperService;
import com.qxgmat.service.UserPaperService;
import com.qxgmat.service.inline.QuestionNoService;
import com.qxgmat.service.inline.QuestionService;
import com.qxgmat.service.inline.UserReportService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;

@Service
public class ExerciseService extends AbstractService {
    @Value("${paper.exerciseLength}")
    public Integer paperLength;

    @Value("${paper.irLength}")
    public Integer irLength;

    @Value("${paper.awaLength}")
    public Integer awaLength;

    @Resource
    private QuestionService questionService;

    @Resource
    private QuestionNoService questionNoService;

    @Resource
    private ExercisePaperService exercisePaperService;

    @Resource
    private QuestionNoRelationMapper questionNoRelationMapper;

    @Resource
    private ExercisePaperRelationMapper exercisePaperRelationMapper;

    @Resource
    private UserPaperRelationMapper userPaperRelationMapper;

    @Resource
    private UserPaperService userPaperService;

    @Resource
    private UserReportRelationMapper userReportRelationMapper;

    @Resource
    private UserReportService userReportService;

    private Map<String, String> adminMap = new HashMap<String, String>(){{
        put("updateTime", "q");
        put("no", "ep");
        put("", "qn");
    }};
    /**
     *
     * @param page
     * @param pageSize
     * @param questionType
     * @param structId
     * @param questionNo
     * @param paperId
     * @param place
     * @param difficult
     * @param startTime
     * @param endTime
     * @param order
     * @param direction
     * @return
     */
    public Page<QuestionNoRelation> listAdmin(int page, int pageSize, String questionType, Number structId, Number questionNo, Number paperId, String place, String difficult, String startTime, String endTime, String order, DirectionStatus direction){
        if(order == null || order.isEmpty()){
            order = "id";
        }
        if(adminMap.containsKey(order)){
            order = adminMap.get(order)+".`"+Tools.underscoreName(order)+"`";
        }else{
            order = adminMap.get("")+".`"+Tools.underscoreName(order)+"`";
        }
        if (direction == null){
            direction = DirectionStatus.DESC;
        }
        String finalOrder = order;
        DirectionStatus finalDirection = direction;

        Page<QuestionNoRelation> p = page(() -> {
            questionNoRelationMapper.listExerciseAdmin(questionType, structId, questionNo, paperId, place, difficult, startTime, endTime, finalOrder, finalDirection.key);
        }, page, pageSize);

        Collection ids = Transform.getIds(p, QuestionNoRelation.class, "id");

        // 获取详细数据
        List<QuestionNoRelation> list = questionNoService.relation(questionNoService.select(ids));
        Transform.replace(p, list, QuestionNoRelation.class, "id");

        return p;
    }

    /**
     * 查找练习组卷
     * @param page
     * @param size
     * @param structId
     * @param userId
     * @param logic
     * @param logicExtend
     * @param times
     * @return
     */
    public Page<ExercisePaper> list(int page, int size, Number structId, Number userId, ExerciseLogic logic, String logicExtend, Integer times){
        String logicKey = logic != null ? logic.key : "";
        Page<ExercisePaper> p = page(()->{
            exercisePaperRelationMapper.listWithUser(structId, userId, logicKey, logicExtend, times);
        },page, size);

        Collection ids = Transform.getIds(p, ExercisePaper.class, "id");
        // 获取详细数据
        List<ExercisePaper> list = exercisePaperService.select(ids);
        Transform.replace(p, list, QuestionNoRelation.class, "id");

        return p;
    }

    /**
     * 根据题目创建组卷序列
     * @param logic
     * @param questionList
     * @return
     */
    @Transactional
    public List<ExercisePaper> createPaper(String prefixTitle, QuestionType questionType, Integer three, Integer four, Integer length, ExerciseLogic logic, String extend, List<QuestionNoRelation> questionList){
        Integer no = 0;
        List<ExercisePaper> list = new ArrayList<>();
        if (questionList == null || questionList.size() == 0) return list;
        List<Integer> tmp = new ArrayList<>(length);
        for(QuestionNo question : questionList){
            tmp.add(question.getId());
            if (tmp.size() == length){
                no += 1;
                ExercisePaper paper = ExercisePaper.builder()
                        .logic(logic.key)
                        .logicExtend(extend)
                        .questionType(questionType.key)
                        .structThree(three)
                        .structFour(four)
                        .no(no)
                        .questionNumber(tmp.size())
                        .status(0)
                        .questionNoIds(tmp.toArray(new Integer[0])).build();
                paper.setTitle(exercisePaperService.generateTitle(prefixTitle, length, paper.getNo(), paper.getQuestionNumber()));
                paper = exercisePaperService.add(paper);
                list.add(paper);
                tmp.clear();
            }
        }
        if (tmp.size() > 0){
            no += 1;
            ExercisePaper paper = ExercisePaper.builder()
                    .logic(logic.key)
                    .logicExtend(extend)
                    .questionType(questionType.key)
                    .structThree(three)
                    .structFour(four)
                    .no(no)
                    .questionNumber(tmp.size())
                    .status(0)
                    .questionNoIds(tmp.toArray(new Integer[0])).build();
            paper.setTitle(exercisePaperService.generateTitle(prefixTitle, length, paper.getNo(), paper.getQuestionNumber()));
            paper = exercisePaperService.add(paper);
            list.add(paper);
        }
        return list;
    }

    /**
     * 切换新组卷
     * @param logic
     * @param ids
     */
    @Transactional
    public void switchPaper(Integer three, Integer four, ExerciseLogic logic, Collection ids){
        // 先将可用卷删除
        List<ExercisePaper> list = exercisePaperService.listByLogic(three, four, logic, null);
        Collection oldIds = Transform.getIds(list, ExercisePaper.class, "id");
        exercisePaperService.updatePaper(oldIds, 0);
        // 将新组卷启用
        exercisePaperService.updatePaper(ids, 1);
    }
}