package cn.com.qmth.scancentral.service.impl;

import cn.com.qmth.scancentral.bean.card.CardFile;
import cn.com.qmth.scancentral.bean.card.CardPage;
import cn.com.qmth.scancentral.bean.card.FillArea;
import cn.com.qmth.scancentral.bean.card.FillItem;
import cn.com.qmth.scancentral.dao.PaperStructureDao;
import cn.com.qmth.scancentral.entity.PaperStructureEntity;
import cn.com.qmth.scancentral.enums.OmrField;
import cn.com.qmth.scancentral.service.PaperStructureService;
import cn.com.qmth.scancentral.vo.paperstructureinfo.PaperStructure;
import cn.com.qmth.scancentral.vo.paperstructureinfo.PaperStructureVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.qmth.boot.core.exception.ParameterException;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class PaperStructureServiceImpl extends ServiceImpl<PaperStructureDao, PaperStructureEntity>
        implements PaperStructureService {

    @Autowired
    private PaperStructureService paperStructureService;

    @Transactional
    @Override
    public void updateByAnswerCard(CardFile cardFile, Long examId, Integer cardNumber) {
        if (examId == null) {
            throw new ParameterException("考试ID不能为空");
        }
        if (cardNumber == null) {
            throw new ParameterException("卡格式编号不能为空");
        }
        paperStructureService.deleteByAnswerCard(examId, cardNumber);
        List<PaperStructureEntity> pss = parse(cardFile, examId, cardNumber);
        if (CollectionUtils.isNotEmpty(pss)) {
            this.saveOrUpdateBatch(pss);
        }
    }

    @Transactional
    @Override
    @CacheEvict(value = "PAPER_STRUCTURE", key = "#examId-#cardNumber", beforeInvocation = true)
    public void deleteByAnswerCard(Long examId, Integer cardNumber) {
        if (examId == null) {
            throw new ParameterException("考试ID不能为空");
        }
        if (cardNumber == null) {
            throw new ParameterException("卡格式编号不能为空");
        }
        QueryWrapper<PaperStructureEntity> wrapper = new QueryWrapper<>();
        LambdaQueryWrapper<PaperStructureEntity> lw = wrapper.lambda();
        lw.eq(PaperStructureEntity::getExamId, examId);
        lw.eq(PaperStructureEntity::getCardNumber, cardNumber);
        this.baseMapper.delete(wrapper);
    }

    private List<PaperStructureEntity> parse(CardFile cardFile, Long examId, Integer cardNumber) {
        List<PaperStructureEntity> pss = new ArrayList<>();
        if (cardFile.getPages() != null) {
            int pageCount = cardFile.getPages().size();
            int paperNumber = 0;
            int pageIndex = 0;
            for (int i = 0; i < pageCount; i++) {
                paperNumber = (i + 2) / 2;
                int mod = (i + 1) % 2;
                pageIndex = (mod == 0 ? 2 : mod);
                CardPage page = cardFile.getPages().get(i).getExchange();
                if (page.getFillArea() != null) {
                    // 提取客观题
                    buildStructEntity(examId, cardNumber, paperNumber, pageIndex, pss, OmrField.QUESTION,
                            page.getFillArea().stream().filter(fillArea -> fillArea.getField().equals("question"))
                                    .sorted(Comparator.comparingInt(FillArea::getIndex)).collect(Collectors.toList()));
                    // 提取选做题
                    buildStructEntity(examId, cardNumber, paperNumber, pageIndex, pss, OmrField.SELECTIVE,
                            page.getFillArea().stream().filter(fillArea -> fillArea.getField().equals("selective"))
                                    .sorted(Comparator.comparingInt(FillArea::getIndex)).collect(Collectors.toList()));
                }
            }
        }
        return pss;
    }

    @SuppressWarnings("unused")
    private void buildStructEntity(Long examId, Integer cardNumber, int paperNumber, int pageIndex,
            List<PaperStructureEntity> pss, OmrField omrField, List<FillArea> areaList) {
        int number = 0;
        for (FillArea fillArea : areaList) {
            for (FillItem item : fillArea.getItems()) {
                number++;
                PaperStructureEntity ps = new PaperStructureEntity();
                pss.add(ps);
                ps.setExamId(examId);
                ps.setCardNumber(cardNumber);
                ps.setPaperNumber(paperNumber);
                ps.setPageIndex(pageIndex);
                ps.setField(omrField);
                ps.setSingle(fillArea.isSingle());
                ps.setQuestionNumber(number);
            }
        }
    }

    @Override
    @Cacheable(value = "PAPER_STRUCTURE", key = "#examId-#cardNumber", unless = "#result == null")
    public PaperStructureVo getByAnswerCard(Long examId, Integer cardNumber) {
        if (examId == null) {
            throw new ParameterException("考试ID不能为空");
        }
        if (cardNumber == null) {
            throw new ParameterException("卡格式编号不能为空");
        }
        QueryWrapper<PaperStructureEntity> wrapper = new QueryWrapper<>();
        LambdaQueryWrapper<PaperStructureEntity> lw = wrapper.lambda();
        lw.eq(PaperStructureEntity::getExamId, examId);
        lw.eq(PaperStructureEntity::getCardNumber, cardNumber);
        List<PaperStructureEntity> list = this.list(wrapper);
        if (CollectionUtils.isEmpty(list)) {
            return null;
        }

        PaperStructureVo vo = new PaperStructureVo();
        List<PaperStructure> selective = new ArrayList<PaperStructure>();
        List<PaperStructure> question = new ArrayList<PaperStructure>();
        vo.setQuestion(question);
        vo.setSelective(selective);
        for (PaperStructureEntity e : list) {
            if (OmrField.QUESTION.equals(e.getField())) {
                question.add(PaperStructure.of(e));
            } else if (OmrField.SELECTIVE.equals(e.getField())) {
                question.add(PaperStructure.of(e));
            }
        }
        return vo;
    }

    @Override
    public PaperStructure getPaperStructure(Long examId, Integer cardNumber, Integer paperNumber, Integer pageIndex,
            Integer questionNumber, OmrField omrField) {
        if (examId == null) {
            throw new ParameterException("考试ID不能为空");
        }
        if (cardNumber == null) {
            throw new ParameterException("卡格式编号不能为空");
        }
        if (paperNumber == null) {
            throw new ParameterException("paperNumber不能为空");
        }
        if (pageIndex == null) {
            throw new ParameterException("pageIndex不能为空");
        }
        if (questionNumber == null) {
            throw new ParameterException("questionNumber不能为空");
        }
        if (omrField == null) {
            throw new ParameterException("omrField不能为空");
        }
        PaperStructureVo vo = paperStructureService.getByAnswerCard(examId, cardNumber);
        if (vo == null) {
            return null;
        }
        List<PaperStructure> question = null;
        if (OmrField.QUESTION.equals(omrField)) {
            question = vo.getQuestion();
        } else if (OmrField.SELECTIVE.equals(omrField)) {
            question = vo.getSelective();
        }
        if (CollectionUtils.isEmpty(question)) {
            return null;
        }
        for (PaperStructure ps : question) {
            if (paperNumber.intValue() == ps.getPaperNumber().intValue()
                    && pageIndex.intValue() == ps.getPageIndex().intValue()
                    && questionNumber.intValue() == ps.getQuestionNumber().intValue()) {
                return ps;
            }
        }
        return null;
    }
}