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

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.collections4.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.qmth.boot.core.exception.StatusException;

import cn.com.qmth.am.bean.ImagePosition;
import cn.com.qmth.am.bean.OcrDto;
import cn.com.qmth.am.bean.StudentScoreVo;
import cn.com.qmth.am.bean.StudentVo;
import cn.com.qmth.am.bean.TrackPosition;
import cn.com.qmth.am.config.SysProperty;
import cn.com.qmth.am.entity.QuestionEntity;
import cn.com.qmth.am.enums.AnswerRangeType;
import cn.com.qmth.am.enums.DataStatus;
import cn.com.qmth.am.service.QuestionService;
import cn.com.qmth.am.service.StmmsService;
import cn.com.qmth.am.service.StudentScoreService;
import cn.com.qmth.am.service.StudentService;

@Service
public class StudentServiceImpl implements StudentService {

    private static final Logger log = LoggerFactory.getLogger(StudentService.class);

    @Autowired
    private StudentService studentService;

    @Autowired
    private SysProperty sysProperty;

    @Autowired
    private StmmsService stmmsService;

    @Autowired
    private StudentScoreService studentScoreService;

    @Autowired
    private QuestionService questionService;

    @Override
    public void importStudent() {
        List<QuestionEntity> qs = questionService.findToDispose();
        if (CollectionUtils.isEmpty(qs)) {
            return;
        }
        Map<String, List<QuestionEntity>> qmap = new LinkedHashMap<>();
        for (QuestionEntity q : qs) {
            String key = q.getExamId() + "-" + q.getSubjectCode();
            List<QuestionEntity> tem = qmap.get(key);
            if (tem == null) {
                tem = new ArrayList<>();
                qmap.put(key, tem);
            }
            tem.add(q);
        }
        for (List<QuestionEntity> qlist : qmap.values()) {
            List<StudentVo> students = stmmsService.getUploadStudent(qlist.get(0).getExamId(),
                    qlist.get(0).getSubjectCode(), sysProperty.getStudentCount());
            if (CollectionUtils.isEmpty(students)) {
                continue;
            }
            updateQuestionsStatus(qlist, DataStatus.PROCESSING);
            try {
                studentScoreService.saveByQuestion(qlist, students);
                updateQuestionsStatus(qlist, DataStatus.SUCCESS);
            } catch (Exception e) {
                log.error("同步考生出错", e);
                updateQuestionsStatus(qlist, DataStatus.FAILED);
            }
        }
    }

    private void updateQuestionsStatus(List<QuestionEntity> qlist, DataStatus st) {
        for (QuestionEntity q : qlist) {
            questionService.updateStatus(q.getId(), st);
        }
    }

    @Override
    public void buildImage(OcrDto ocrDto) {
        if (DataStatus.WAITING.equals(ocrDto.getScore().getAnswerStatus())
                || DataStatus.FAILED.equals(ocrDto.getScore().getAnswerStatus())) {
            if (AnswerRangeType.TRACK.equals(ocrDto.getQuetion().getAnswerRangeType())
                    && CollectionUtils.isEmpty(ocrDto.getScore().getImagePosition())) {
                return;
            } else if (AnswerRangeType.ALL.equals(ocrDto.getQuetion().getAnswerRangeType())
                    && ocrDto.getScore().getSheetCount() == null) {
                return;
            }
            studentService.createSlice(ocrDto);
        }
    }

    @Override
    public void createSlice(OcrDto ocrDto) {
        if (ocrDto.getQuetion() == null) {
            studentScoreService.updateAnswerErr(ocrDto.getScore().getId(), "未找到试题信息");
            return;
        }
        try {
            studentScoreService.createSlice(ocrDto);
        } catch (Exception e) {
            if (e instanceof StatusException) {
                studentScoreService.updateAnswerErr(ocrDto.getScore().getId(), e.getMessage());
            } else {
                log.error("系统异常", e);
                studentScoreService.updateAnswerErr(ocrDto.getScore().getId(), "系统异常");
            }
        }
    }

    @Transactional
    @Override
    public void reset(Long examId, String subjectCode) {
        studentScoreService.removeBy(examId, subjectCode);
    }

    @Transactional
    @Override
    public void clear(Long examId, String subjectCode) {
        studentScoreService.removeBy(examId, subjectCode);
        questionService.removeBy(examId, subjectCode);
    }

    @Override
    public void updateMarkingScore(QuestionEntity q, StudentScoreVo score) {
        List<Double> list = stmmsService.getMarkScore(score.getStudentId(), q.getMainNumber(), q.getSubNumber());
        if (CollectionUtils.isEmpty(list)) {
            return;
        }
        score.setMarkingScore(list.get(0));
        if (AnswerRangeType.TRACK.equals(q.getAnswerRangeType())) {
            score.setIps(getImagePosition(score.getStudentId(), q.getMainNumber() + "." + q.getSubNumber()));
            studentScoreService.updateMarkingScoreAndTrack(score);
        } else {
            studentScoreService.updateMarkingScore(score);
        }
    }

    private List<ImagePosition> getImagePosition(Long studentId, String questionNumber) {
        List<ImagePosition> ret = new ArrayList<>();
        List<TrackPosition> tps = stmmsService.getTrackPosition(studentId, questionNumber);
        Set<String> set = new HashSet<>();
        for (TrackPosition tp : tps) {
            Boolean left = tp.getPositionX() < 0.5;
            String key = left.toString() + tp.getOffsetIndex();
            if (!set.contains(key)) {
                ImagePosition ip = new ImagePosition();
                ip.setLeft(left);
                ip.setPageIndex(tp.getOffsetIndex());
                ret.add(ip);
            }
        }
        return ret;
    }
}