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

import cn.com.qmth.scancentral.bean.ImportSubjectDomain;
import cn.com.qmth.scancentral.bean.SubjectConfigDomain;
import cn.com.qmth.scancentral.bean.User;
import cn.com.qmth.scancentral.dao.SubjectDao;
import cn.com.qmth.scancentral.entity.SubjectEntity;
import cn.com.qmth.scancentral.service.SubjectService;
import cn.com.qmth.scancentral.vo.SubjectConfigVo;
import cn.com.qmth.scancentral.vo.examinfo.SubjectConfig;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
import com.qmth.boot.core.exception.ParameterException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@Service
public class SubjectServiceImpl extends MppServiceImpl<SubjectDao, SubjectEntity> implements SubjectService {

    @Transactional
    @Override
    public int cleanByExamId(Long examId) {
        QueryWrapper<SubjectEntity> wrapper = new QueryWrapper<>();
        LambdaQueryWrapper<SubjectEntity> lw = wrapper.lambda();
        lw.eq(SubjectEntity::getExamId, examId);
        return this.baseMapper.delete(wrapper);
    }

    @Override
    public List<SubjectEntity> listByExamId(Long examId) {
        QueryWrapper<SubjectEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(SubjectEntity::getExamId, examId);
        queryWrapper.lambda().orderByDesc(SubjectEntity::getCode);
        return this.list(queryWrapper);
    }

    @Override
    public SubjectEntity findByExamIdAndCode(Long examId, String code) {
        QueryWrapper<SubjectEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(SubjectEntity::getExamId, examId);
        queryWrapper.lambda().eq(SubjectEntity::getCode, code);
        return this.getOne(queryWrapper);
    }

    @Override
    public int countByExamId(Long examId) {
        QueryWrapper<SubjectEntity> wrapper = new QueryWrapper<>();
        LambdaQueryWrapper<SubjectEntity> lw = wrapper.lambda();
        lw.eq(SubjectEntity::getExamId, examId);
        return this.count(wrapper);
    }

    @Transactional
    @Override
    public int importSubject(List<ImportSubjectDomain> subjects) {
        Map<Long, Set<String>> map = new HashMap<Long, Set<String>>();
        List<SubjectEntity> list = this.list();
        for (SubjectEntity subjectEntity : list) {
            Set<String> set = map.get(subjectEntity.getExamId());
            if (set == null) {
                set = new HashSet<String>();
            }
            set.add(subjectEntity.getCode());
            map.put(subjectEntity.getExamId(), set);
        }

        List<SubjectEntity> saveList = new ArrayList<SubjectEntity>();
        for (ImportSubjectDomain importSubjectDomain : subjects) {
            Set<String> set = map.get(importSubjectDomain.getExamId());
            if (set != null) {
                if (!set.contains(importSubjectDomain.getSubjectCode())) {
                    SubjectEntity subjectEntity = new SubjectEntity(importSubjectDomain.getExamId(),
                            importSubjectDomain.getSubjectCode(), importSubjectDomain.getSubjectName());
                    set.add(importSubjectDomain.getSubjectCode());
                    saveList.add(subjectEntity);
                }
            } else {
                set = new HashSet<String>();
                SubjectEntity subjectEntity = new SubjectEntity(importSubjectDomain.getExamId(),
                        importSubjectDomain.getSubjectCode(), importSubjectDomain.getSubjectName());
                set.add(importSubjectDomain.getSubjectCode());
                saveList.add(subjectEntity);
            }
            map.put(importSubjectDomain.getExamId(), set);
        }
        this.saveOrUpdateBatchByMultiId(saveList);
        return saveList.size();
    }

    @Transactional
    @Override
    public SubjectConfigVo config(User user, SubjectConfigDomain domain) {
        SubjectEntity s = this.findByExamIdAndCode(domain.getExamId(), domain.getSubjectCode());
        if (s == null) {
            throw new ParameterException("找不到对应的科目");
        }
        s.setPaperTypeBarcodeContent(domain.getPaperTypeBarcodeContent());
        this.saveOrUpdateByMultiId(s);
        return new SubjectConfigVo(s);
    }

    @Override
    public List<SubjectConfig> listConfigByExamId(Long examId) {
        QueryWrapper<SubjectEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(SubjectEntity::getExamId, examId);
        queryWrapper.lambda().isNotNull(SubjectEntity::getPaperTypeBarcodeContent);
        List<SubjectEntity> list = this.list(queryWrapper);
        List<SubjectConfig> result = new ArrayList<SubjectConfig>();
        for (SubjectEntity subjectEntity : list) {
            result.add(new SubjectConfig(subjectEntity));
        }
        return result;
    }

}