package com.jevon.controller;

import com.jevon.enums.DifficultEnums;
import com.jevon.enums.DimensionalEnums;
import com.jevon.model.*;
import com.jevon.service.*;
import com.jevon.utils.HttpClientUtils;
import com.jevon.utils.RedisUtils;
import com.jevon.vo.BaseVo;
import com.jevon.vo.excel.ExamExcelVo;
import com.jevon.vo.excel.ScoreExcelVo;
import com.jevon.vo.rep.GetLeague;
import com.jevon.vo.rep.GetLeagueRepVo;
import com.jevon.vo.req.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.InputStream;
import java.util.*;

/**
 * @author chen
 * @version 1.0
 * @date 2019/10/17 0017 13:33
 */
@RestController
@RequestMapping(value = "/learn")
@Api(value = "学情分析")
public class LearnController {

    @Autowired
    AnalyseService analyseService;

    @Autowired
    DimensionalService dimensionalService;

    @Autowired
    AnalyseDimensionalService analyseDimensionalService;

    @Autowired
    AnalyseDetailService analyseDetailService;

    @Autowired
    StudentDetailService studentDetailService;

    @Autowired
    StudentService studentService;

    @Autowired
    LeagueService leagueService;

    @Autowired
    ChapterService chapterService;

    @Autowired
    KnowledgeService knowledgeService;

    @ApiOperation("获取列表")
    @RequestMapping(value = "getList", method = RequestMethod.POST)
    public List<Analyse> getList(){
        List<Analyse> list = analyseService.select(new Analyse());
        return  list;
    }

    @ApiOperation("获取详情,微信入口")
    @RequestMapping(value = "getDetail", method = RequestMethod.GET)
    public Analyse getAnalyseId(String grade , String schoolName){
        Analyse result = null ;
        Analyse search = new Analyse();
        search.setGrade(grade);
        List<Analyse> analyseList = analyseService.select(search);
        if(analyseList != null && analyseList.size() > 0){
            List<League> leagues = leagueService.selectByAnalyseId(analyseList.get(0).getId());
            for(League league : leagues){
                if(league.getSchoolName().equals(schoolName)){
                    result = analyseList.get(0);
                    break;
                }
            }
        }
        if(result == null){
            Analyse searchAnalyse = new Analyse();
            searchAnalyse.setExamName("顺治中学模板考试");
            analyseList = analyseService.select(searchAnalyse);
            if(analyseList != null && analyseList.size() > 0){
                result = analyseList.get(0);
            }
        }

        return  result ;
    }

    @ApiOperation("创建考试")
    @RequestMapping(value = "createExam", method = RequestMethod.POST)
    public BaseVo createExam(@RequestBody CreateExamReqVo createExamReqVo){
        BaseVo baseVo = new BaseVo();
        Analyse analyse = new Analyse();
        analyse.setCourseName(createExamReqVo.getCourseName());
        analyse.setExamName(createExamReqVo.getExamName());
        analyse.setExamTime(createExamReqVo.getExamTime());
        analyse.setCreateTime(new Date());
        analyse.setGrade(createExamReqVo.getGrade());
        analyseService.insert(analyse);
        baseVo.setMessage(analyse.getId()+"");
        return baseVo;
    }

    @ApiOperation("更新考试信息")
    @RequestMapping(value = "updateExam", method = RequestMethod.POST)
    public BaseVo updateExam(@RequestBody UpdateExamReqVo updateExamReqVo){
        BaseVo baseVo = new BaseVo();
        Analyse analyse = analyseService.selectById(updateExamReqVo.getAnalyseId());
        if(analyse == null){
            baseVo.setMessage("考试不存在");
            baseVo.setSuccess(false);
            return baseVo;
        }
        analyse.setExamTime(updateExamReqVo.getExamTime());
        analyse.setExamName(updateExamReqVo.getExamName());
        analyse.setCourseName(updateExamReqVo.getCourseName());
        analyse.setGrade(updateExamReqVo.getGrade());
        analyseService.update(analyse);
        return baseVo;
    }

    @ApiOperation("试卷信息导入")
    @RequestMapping(value = "initAnalyse", method = RequestMethod.POST)
    public BaseVo initAnalyse(@RequestBody InitAnalyseReqVo initAnalyseReqVo){
        BaseVo baseVo = new BaseVo();
        Analyse analyse = analyseService.selectById(initAnalyseReqVo.getAnalyseId());
        List<AnalyseDetail> analyseDetails = analyseDetailService.selectByAnalyseId(analyse.getId());
        if(analyseDetails != null & analyseDetails.size() > 0){
            baseVo.setMessage("已经导入");
            baseVo.setSuccess(false);
        }else {
            RedisUtils.flushAll();
            analysisExcel(initAnalyseReqVo);
        }
        return baseVo;
    }

    private void analysisExcel(InitAnalyseReqVo initAnalyseReqVo){
        try{
            List<AnalyseDetail> analyseDetails = new ArrayList<>();
            List<AnalyseDimensional> analyseDimensionals = new ArrayList<>();
            Float maxScore = 0f;
            Analyse analyse = analyseService.selectById(initAnalyseReqVo.getAnalyseId());
            File excelFile = new File(initAnalyseReqVo.getUrl());
            // 获得工作簿
            String file = excelFile.getName();
            Workbook workbook = null;
            InputStream inputStream = HttpClientUtils.GetFileInputStream(initAnalyseReqVo.getUrl());
            if(inputStream == null){
                return;
            }
            if (file.endsWith("xls")) {
                workbook = new HSSFWorkbook(inputStream);
            } else {
                workbook = new XSSFWorkbook(inputStream);
            }
            // 获得工作表
            Sheet sheet = workbook.getSheetAt(0);
            Date date = new Date();
            int rows = sheet.getPhysicalNumberOfRows();
            for (int i = 0; i < rows; i++) {
                // 获取第i行数据
                Row sheetRow = sheet.getRow(i);
                if (i == 0) {
                    //获取标题
                    String title = sheetRow.getCell(0).getStringCellValue().trim();
                }else if(i == 1){
                    //获取表头
                } else {
                    ExamExcelVo examExcelVo = new ExamExcelVo(sheetRow);
                    if(examExcelVo.getScore() != null){
                        maxScore = maxScore + new Float(examExcelVo.getScore());
                        AnalyseDetail analyseDetail = new AnalyseDetail();
                        String questionNumber = null ;
                        if(StringUtils.isNotBlank(examExcelVo.getQuestionSmallNumber())){
                            questionNumber = examExcelVo.getQuestionNumber()+"("+examExcelVo.getQuestionSmallNumber()+")";
                        }else {
                            questionNumber = examExcelVo.getQuestionNumber() ;
                        }
                        analyseDetail.setQuestionNumber(questionNumber);
                        analyseDetail.setAnalyseId(analyse.getId());
                        analyseDetail.setQuestionType(examExcelVo.getQuestionType());
                        analyseDetail.setDifficult(DifficultEnums.getDifficultType(examExcelVo.getDifficult()));
                        analyseDetail.setScore(new Double(examExcelVo.getScore()));
                        analyseDetail.setCreateTime(date);
                        analyseDetails.add(analyseDetail);
                        initAnalyseDimensional(analyse,questionNumber,examExcelVo.getScore(),examExcelVo.getKnowledge(),DimensionalEnums.knowledge.getDimensionalType(),analyseDimensionals);
                        initAnalyseDimensional(analyse,questionNumber,examExcelVo.getScore(),examExcelVo.getAbility(),DimensionalEnums.ability.getDimensionalType(),analyseDimensionals);
                        initAnalyseDimensional(analyse,questionNumber,examExcelVo.getScore(),examExcelVo.getSkill(),DimensionalEnums.skill.getDimensionalType(),analyseDimensionals);
                        initAnalyseDimensional(analyse,questionNumber,examExcelVo.getScore(),examExcelVo.getThink(),DimensionalEnums.think.getDimensionalType(),analyseDimensionals);
                    }
                }
            }
            analyseDetailService.insertBatch(analyseDetails);
            analyseDimensionalService.insertBatch(analyseDimensionals);
            analyse.setMaxScore(new Double(maxScore));
            analyseService.update(analyse);
        }catch (Exception e){
           e.printStackTrace();
        }
    }

    private void initAnalyseDimensional(Analyse analyse ,String questionNumber , String score , String dimensionalMessage , int dimensionalType , List<AnalyseDimensional> analyseDimensionals){
        if(StringUtils.isNotBlank(dimensionalMessage)){
            String[] message =dimensionalMessage.split("、");
            for (int j = 0; j < message.length ; j++) {
                if(StringUtils.isNotBlank(message[j])){
                    Dimensional dimensional = new Dimensional();
                    dimensional.setDimensionalType(dimensionalType);
                    dimensional.setDimensionalName(message[j]);
                    //查数据库是否已存在该四维诊断  不存在则导入
                    Dimensional result = dimensionalService.selectByTypeAndName(dimensionalType,message[j]);
                    int dimensionalId = 0 ;
                    if(result == null || result.getId() == 0){
                        dimensional.setCreateTime(new Date());
                        dimensionalService.insert(dimensional);
                        dimensionalId = dimensional.getId();
                    }else{
                        dimensionalId = result.getId();
                    }
                    AnalyseDimensional analyseDimensional = new AnalyseDimensional();
                    analyseDimensional.setAnalyseId(analyse.getId());
                    analyseDimensional.setDimensionalId(dimensionalId);
                    analyseDimensional.setQuestionNumber(questionNumber);
                    analyseDimensional.setScore(new Double(score));
                    analyseDimensional.setCreateTime(new Date());
                    analyseDimensionals.add(analyseDimensional);
                }
            }
        }
    }

    @ApiOperation("考生成绩导入")
    @RequestMapping(value = "initScore", method = RequestMethod.POST)
    public BaseVo initScore(@RequestBody InitScoreReqVo initScoreReqVo){
        BaseVo baseVo = new BaseVo();
        boolean success = analysisScoreExcel(initScoreReqVo);
        if(!success){
            baseVo.setSuccess(false);
            baseVo.setMessage("一个学校不能在两个联盟下");
        }
        return baseVo;
    }

    private boolean analysisScoreExcel(InitScoreReqVo initScoreReqVo){
        try{
            Analyse analyse = analyseService.selectById(initScoreReqVo.getAnalyseId());
            List<AnalyseDetail> analyseDetails = analyseDetailService.selectByAnalyseId(analyse.getId());
            Map<String , Double> scoreMap = new HashMap<>();
            for(AnalyseDetail analyseDetail : analyseDetails){
                scoreMap.put(analyseDetail.getQuestionNumber(),analyseDetail.getScore());
            }
            File excelFile = new File(initScoreReqVo.getUrl());
            // 获得工作簿
            String file = excelFile.getName();
            Workbook workbook = null;
            InputStream inputStream = HttpClientUtils.GetFileInputStream(initScoreReqVo.getUrl());
            if(inputStream == null){
                return false ;
            }
            if (file.endsWith("xls")) {
                workbook = new HSSFWorkbook(inputStream);
            } else {
                workbook = new XSSFWorkbook(inputStream);
            }
            // 获得工作表
            for(int number = 0 ; number < workbook.getNumberOfSheets() ; number++){
                Sheet sheet = workbook.getSheetAt(number);
                List<StudentDetail> studentDetails = new ArrayList<>();
                List<Student> students = new ArrayList<>();
                Date date = new Date();
                int rows = sheet.getPhysicalNumberOfRows();
                Map<Integer , String> map = new HashMap<>();
                int column = 0 ;
                for (int i = 0; i < rows; i++) {
                    // 获取第i行数据
                    Row sheetRow = sheet.getRow(i);
                    if (i == 0) {
                        //获取标题
                    }else if(i == 1){
                        //获取表头
                        int j = 7 ;
                        while (sheetRow.getCell(j) != null){
                            Cell cell = sheetRow.getCell(j);
                            cell.setCellType(CellType.STRING);
                            map.put(j,cell.getStringCellValue().trim().replace("（","(").replace("）",")"));
                            j++;
                        }
                        column = j ;
                    } else {
                        ScoreExcelVo scoreExcelVo = new ScoreExcelVo(sheetRow);
                       if(StringUtils.isNotBlank(scoreExcelVo.getStudentName())){
                           Student student = new Student(scoreExcelVo);
                           student.setAnalyseId(analyse.getId());
                           student.setCreateTime(date);
                           students.add(student);
                           for(int j = 7 ; j < column ; j++){
                               Cell cell = sheetRow.getCell(j);
                               StudentDetail studentDetail = new StudentDetail(scoreExcelVo);
                               studentDetail.setAnalyseId(analyse.getId());
                               studentDetail.setExamNumber(map.get(j));
                               studentDetail.setScore(new Double(cell.getNumericCellValue()));
                               Double score = scoreMap.get((map.get(j))) ;
                               Double studentScore = studentDetail.getScore() ;
                               if(Double.doubleToLongBits(score) == Double.doubleToLongBits(studentScore) ){
                                   studentDetail.setCorrect(1);
                               }else {
                                   studentDetail.setCorrect(0);
                               }
                               studentDetail.setCreateTime(date);
                               studentDetails.add(studentDetail);
                           }
                       }
                    }
                }
                int i = leagueService.initLeagueSchool(initScoreReqVo.getLeagueId(),students.get(0).getSchoolName());
                if(i > 0){
                    studentService.insertBatch(students);
                    studentDetailService.insertBatch(studentDetails);
                    return true ;
                }else {
                    return  false ;
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            System.out.println(e.toString());
        }
        return false ;
    }

    @ApiOperation("获取该次考试联盟学校信息")
    @RequestMapping(value = "getLeague", method = RequestMethod.GET)
    public GetLeagueRepVo getLeague(int analyseId){
        GetLeagueRepVo getLeagueRepVo = new GetLeagueRepVo();
        List<League> leagues = leagueService.selectByAnalyseId(analyseId);
        List<GetLeague> getLeagues = new ArrayList<>();
        for(League league : leagues){
            boolean isExist = false ;
            for(GetLeague getLeague : getLeagues){
                if(getLeague.getLeagueName().equals(league.getLeague())){
                    isExist = true ;
                    List<League> list = getLeague.getLeagues();
                    list.add(league);
                    getLeague.setLeagues(list);
                }
            }
            if(!isExist){
                GetLeague getLeague = new GetLeague();
                getLeague.setLeagueName(league.getLeague());
                List<League> list = new ArrayList<>();
                list.add(league);
                getLeague.setLeagues(list);
                getLeagues.add(getLeague);
            }
        }
        getLeagueRepVo.setData(getLeagues);
        return getLeagueRepVo;
    }

    @ApiOperation("创建联盟")
    @RequestMapping(value = "createLeague", method = RequestMethod.POST)
    public BaseVo createLeague(@RequestBody CreateLeagueReqVo createLeagueReqVo){
        BaseVo baseVo = new BaseVo();
        League league = new League();
        Analyse analyse = analyseService.selectById(createLeagueReqVo.getAnalyseId());
        league.setAnalyseId(analyse.getId());
        league.setLeague(createLeagueReqVo.getLeague());
        leagueService.insert(league);
        baseVo.setMessage(league.getId() +"");
        return baseVo;
    }

    @ApiOperation("基础信息输入")
    @RequestMapping(value = "createChapter", method = RequestMethod.POST)
    public BaseVo createChapter(@RequestBody ChapterReqVo chapterReqVo){
        BaseVo baseVo = new BaseVo();
        analyseService.updateChapter(chapterReqVo.getAnalyseId(),chapterReqVo.getExamTime(),chapterReqVo.getExamScope());
        List<Chapter> list = new ArrayList<>();
        for(ChapterReq chapterReq :chapterReqVo.getList()){
            Chapter chapter = new Chapter();
            chapter.setAnalyseId(chapterReqVo.getAnalyseId());
            chapter.setChapterNumber(chapterReq.getChapterNumber());
            chapter.setChapterName(chapterReq.getChapterName());
            chapter.setChapterScore(chapterReq.getScore());
            list.add(chapter);
        }
        chapterService.insertBatch(list);
        return baseVo;
    }

    @ApiOperation("获取导入的学校列表")
    @RequestMapping(value = "getSchoolName", method = RequestMethod.GET)
    public List<String> getSchoolName(int analyseId){
        return studentService.selectSchoolNameByAnalyse(analyseId);
    }

    @ApiOperation("导入中考数据")
    @RequestMapping(value = "initKnowledge", method = RequestMethod.POST)
    public void initKnowledge(@RequestParam("file") MultipartFile file){
        InputStream fis = null;
        Workbook workBook = null;
        try {
            fis = file.getInputStream();
            String fileName = file.getOriginalFilename();
            if (fileName.endsWith("xls")) {
                workBook = new HSSFWorkbook(fis);
            } else {
                workBook = new XSSFWorkbook(fis);
            }
            List<Knowledge> list = new ArrayList<>();
            for(int number = 0 ; number < workBook.getNumberOfSheets() ; number++) {
                Sheet sheet = workBook.getSheetAt(number);
                Date date = new Date();
                int rows = sheet.getPhysicalNumberOfRows();
                for (int i = 1; i < rows; i++) {
                    // 获取第i行数据
                    Row sheetRow = sheet.getRow(i);
                    if(sheetRow != null){
                        Cell cell1 = sheetRow.getCell(0);
                        Cell cell2 = sheetRow.getCell(1);
                        Cell cell3 = sheetRow.getCell(2);
                        Cell cell4 = sheetRow.getCell(3);
                        if(cell1 != null){
                            Knowledge knowledge = new Knowledge();
                            knowledge.setKnowledge(cell1.getStringCellValue());
                            knowledge.setDetail(cell2.getStringCellValue());
                            cell3.setCellType(CellType.STRING);
                            cell4.setCellType(CellType.STRING);
                            knowledge.setRate(cell3.getStringCellValue());
                            knowledge.setAvg(cell4.getStringCellValue());
                            knowledge.setUpdateTime(date);
                            list.add(knowledge);
                        }
                    }
                }
                knowledgeService.insertBatch(list);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}