package com.mindskip.xzs.controller.admin;

import com.mindskip.xzs.base.BaseApiController;
import com.mindskip.xzs.base.RestResponse;
import com.mindskip.xzs.base.SystemCode;
import com.mindskip.xzs.domain.Question;
import com.mindskip.xzs.domain.Subject;
import com.mindskip.xzs.domain.TextContent;
import com.mindskip.xzs.domain.enums.QuestionSourceEnum;
import com.mindskip.xzs.domain.enums.QuestionTypeEnum;
import com.mindskip.xzs.domain.question.QuestionObject;
import com.mindskip.xzs.repository.DepartmentMapper;
import com.mindskip.xzs.repository.SubjectMapper;
import com.mindskip.xzs.service.*;
import com.mindskip.xzs.utility.*;
import com.mindskip.xzs.utility.convert.QuestionClassConvert;
import com.mindskip.xzs.utility.excel.ExcelUtils;
import com.mindskip.xzs.viewmodel.admin.education.SubjectPageRequestVM;
import com.mindskip.xzs.viewmodel.admin.question.*;
import com.github.pagehelper.PageInfo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.validation.Valid;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@RestController("AdminQuestionController")
@RequestMapping(value = "/api/admin/question")
public class QuestionController extends BaseApiController {

    private final QuestionService questionService;
    private final TextContentService textContentService;

    private final SubjectMapper subjectMapper;

    private final DepartmentMapper departmentMapper;

    private final QuestionSubjectService questionSubjectService;

    @Autowired
    public QuestionController(QuestionService questionService, TextContentService textContentService, SubjectMapper subjectMapper, DepartmentMapper departmentMapper, QuestionSubjectService questionSubjectService) {
        this.questionService = questionService;
        this.textContentService = textContentService;
        this.subjectMapper = subjectMapper;
        this.departmentMapper = departmentMapper;
        this.questionSubjectService = questionSubjectService;
    }

    @RequestMapping(value = "/page", method = RequestMethod.POST)
    public RestResponse<PageInfo<QuestionResponseVM>> pageList(@RequestBody @Valid QuestionPageRequestVM model) {
        PageInfo<Question> pageInfo = questionService.page(model);
        PageInfo<QuestionResponseVM> page = PageInfoHelper.copyMap(pageInfo, q -> {
            QuestionResponseVM vm = modelMapper.map(q, QuestionResponseVM.class);
            vm.setCreateTime(DateTimeUtil.dateFormat(q.getCreateTime()));
            vm.setScore(ExamUtil.scoreToVM(q.getScore()));
            TextContent textContent = textContentService.selectById(q.getInfoTextContentId());
            QuestionObject questionObject = JsonUtil.toJsonObject(textContent.getContent(), QuestionObject.class);
            String clearHtml = HtmlUtil.clear(questionObject.getTitleContent());
            vm.setShortTitle(clearHtml);
            vm.setQuestionSubjects(questionSubjectService.getQuestion(vm.getId()).stream().map(e -> {
                SubjectPageRequestVM subjectPageRequestVM = new SubjectPageRequestVM();
                subjectPageRequestVM.setId(e.getSubjectId());
                e.setSubName(subjectMapper.page(subjectPageRequestVM).get(0).getName());
                return e;
            }).collect(Collectors.toList()));
            return vm;
        });
        return RestResponse.ok(page);
    }

    @RequestMapping(value = "/edit", method = RequestMethod.POST)
    public RestResponse edit(@RequestBody @Valid QuestionEditRequestVM model) {
        RestResponse validQuestionEditRequestResult = validQuestionEditRequestVM(model);
        if (validQuestionEditRequestResult.getCode() != SystemCode.OK.getCode()) {
            return validQuestionEditRequestResult;
        }

        if (null == model.getId()) {
            questionService.insertFullQuestion(model, getCurrentUser().getId());
        } else {
            questionService.updateFullQuestion(model);
        }

        return RestResponse.ok();
    }

    @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
    public RestResponse<QuestionEditRequestVM> select(@PathVariable Integer id) {
        QuestionEditRequestVM newVM = questionService.getQuestionEditRequestVM(id);
        return RestResponse.ok(newVM);
    }


    @RequestMapping(value = "/delete/{id}", method = RequestMethod.POST)
    public RestResponse delete(@PathVariable Integer id) {
        return RestResponse.ok(questionService.remove(id));
    }

    private RestResponse validQuestionEditRequestVM(QuestionEditRequestVM model) {
        int qType = model.getQuestionType().intValue();
        boolean requireCorrect = qType == QuestionTypeEnum.SingleChoice.getCode() || qType == QuestionTypeEnum.TrueFalse.getCode();
        if (requireCorrect) {
            if (StringUtils.isBlank(model.getCorrect())) {
                String errorMsg = ErrorUtil.parameterErrorFormat("correct", "不能为空");
                return new RestResponse<>(SystemCode.ParameterValidError.getCode(), errorMsg);
            }
        }

        if (qType == QuestionTypeEnum.GapFilling.getCode()) {
            Integer fillSumScore = model.getItems().stream().mapToInt(d -> ExamUtil.scoreFromVM(d.getScore())).sum();
            Integer questionScore = ExamUtil.scoreFromVM(model.getScore());
            if (!fillSumScore.equals(questionScore)) {
                String errorMsg = ErrorUtil.parameterErrorFormat("score", "空分数和与题目总分不相等");
                return new RestResponse<>(SystemCode.ParameterValidError.getCode(), errorMsg);
            }
        }
        return RestResponse.ok();
    }

    @PostMapping("/import")
    public RestResponse importUser(@RequestPart("file") MultipartFile file) throws Exception {
        List<QuestionEditVO> questionEditVOS = ExcelUtils.readMultipartFile(file, QuestionEditVO.class)
                .stream().map(e -> {
                    e.setQuestionType(QuestionTypeEnum.get(e.getType()));
//                    e.setSubjectId(subjectMapper.getName(e.getSbNames()).getId());
//                    e.setGradeLevel(departmentMapper.getName(e.getDepartment()).getId());
                    return e;
                }).collect(Collectors.toList());

        List<QuestionEditRequestVM> list = QuestionClassConvert.INSTANCE.QuestionEditVOListToQuestionEditRequestVMList(questionEditVOS);

        List<QuestionEditItemVM> questionEditItemVMS = new ArrayList<>();
        QuestionEditItemVM questionEditItemVM = new QuestionEditItemVM();

        //组装题目
        for (QuestionEditRequestVM vm : list) {
            questionEditItemVM.setPrefix("A");
            questionEditItemVM.setContent(vm.getA());

            questionEditItemVMS.add(questionEditItemVM);
            questionEditItemVM = new QuestionEditItemVM();
            questionEditItemVM.setPrefix("B");
            questionEditItemVM.setContent(vm.getB());
            questionEditItemVMS.add(questionEditItemVM);
            if(!"".equals(vm.getC()) && vm.getC()!=null){
                questionEditItemVM = new QuestionEditItemVM();
                questionEditItemVM.setPrefix("C");
                questionEditItemVM.setContent(vm.getC());
                questionEditItemVMS.add(questionEditItemVM);
            }
            if(!"".equals(vm.getD()) && vm.getD()!=null){
                questionEditItemVM = new QuestionEditItemVM();
                questionEditItemVM.setPrefix("D");
                questionEditItemVM.setContent(vm.getD());
                questionEditItemVMS.add(questionEditItemVM);
            }
            vm.setItems(questionEditItemVMS);
            List<String> str = Arrays.asList(vm.getCorrect().split(","));

            List<Subject> subjectList = subjectMapper.getNames(vm.getSbNames().split(","));

            Integer[] arr =subjectList.stream()
                    .map(Subject::getId).toArray(Integer[]::new);

            vm.setSubjectIds(arr);
            //多选
            if (str.size() > 1) {
                vm.setCorrectArray(str);
                vm.setCorrect(null);
            }
            vm.setScore(QuestionSourceEnum.fromType(vm.getQuestionType()).toString());
            vm.setDifficult(4);

            questionService.insertFullQuestion(vm, getCurrentUser().getId());
            questionEditItemVMS.clear();
        }
        return RestResponse.ok();
    }
}