package com.mooctest.controller;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.mooctest.data.BugDTO;
import com.mooctest.data.SimpleResponse;
import com.mooctest.data.TaskDTO;
import com.mooctest.model.BugData;
import com.mooctest.model.MasterReport;
import com.mooctest.model.Task;
import com.mooctest.service.*;
import com.mooctest.util.ReportUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.toMap;

@Controller
public class TaskController {

    @Autowired
    TaskService taskService;

    @Autowired
    BugReportService bugReportService;

    @Autowired
    HistoryService historyService;

    @Autowired
    MasterReportService masterReportService;

    @Autowired
    BugDataService bugDataService;
    @Autowired
    JobService jobService;

    @Value("${report.host}")
    String reportHost;

    @Value("${useOss}")
    boolean useOss;
    @Value("${urlPath}")
    String urlPrefix;

    @GetMapping("/crowdTask")
    public String home(Model model) {
        // 获得所有taskDTO，包括本地和慕测端
        List<TaskDTO> tasks = taskService.getAllTasks();
        List<TaskDTO> localTasks = taskService.findTask();
        tasks.addAll(localTasks);
        Collections.sort(tasks,(o1,o2)->{
            return (int)(o2.getExamId()-o1.getExamId());
        });
        // 将获得任务传给前端
        model.addAttribute("tasks", tasks);
        // 转到task_list页面
        return "task_list";
    }

    @GetMapping("/home")
    public String home2(Model model ){
        // 获得所有taskDTO，包括本地和慕测端
        List<TaskDTO> tasks = taskService.getAllTasks();
        List<TaskDTO> localTasks = taskService.findTask();
        tasks.addAll(localTasks);
        Collections.sort(tasks,(o1,o2)->{
            return (int)(o2.getExamId()-o1.getExamId());
        });
        JSONArray jsonArray = jobService.getJobs(); // 所有的数据
        List<Object> list = new ArrayList<>();
        for (Object single : jsonArray){
            changeTime2Long(single); // 修改创建时间的格式  以便前段展示
            list.add(single);
        }
        model.addAttribute("jobs",list.subList(0,Math.min(15,list.size())));
        model.addAttribute("tasks", tasks.subList(0,Math.min(15,tasks.size())));
        return "home";
    }

    @GetMapping("/taskDashBoard")
    public String dashBoard ( @RequestParam("taskId") long taskId ,
                              @RequestParam("caseId") long caseId ,
                              Model model){
        JSONObject data = taskService.getAllTaskDashboard(caseId, taskId);
        model.addAttribute("task",data);
        return "crowdTaskDashboard";
    }

    // TODO: 2020/4/1 sweager崩了没有测试
    @GetMapping("/distribute")
    @ResponseBody
    public String distributePeople (@RequestParam("examId") String examId,
                                    @RequestParam("caseId")String caseId){
        if(caseId == null || caseId.length()==0) return "fail";

        return taskService.distribute(examId,caseId)?"success":"fail";
    }


    @GetMapping("/")
    public String root(Model model) {
        return "redirect:/home";
    }

    @GetMapping("/task_detail")
    public String taskDetail(@RequestParam("examId") long examId,
                             @RequestParam("caseId") long caseId,
                             Model model) {

        // first check is there some data in bugData document
        // 将bug表中的信息同步到BugData中
        bugDataService.importBugData(examId, caseId);//  访问任务的时候同步报告信息
        // after import the bug data
        // 在MasterReport表中查找融合报告的数量，若大于0，则认为已经融合
        boolean aggregated = masterReportService.isAggregated(examId, caseId); // 检查报告是否已经聚合
        // 在bug表中查找所有的bug报告数
        List<BugDTO> allReports = bugReportService.getAllBugs(examId, caseId); // 得到所有的报告
        // 在BugData表中查找bug数据，<bugid,BugData>
        Map<String , BugData> bugIds2Data = bugDataService.bugId2BugData(examId, caseId);
        // 将单一状报告转化成树状
        Map<String,String> single2rootMap = historyService.getSingle2Root(caseId, examId);
        // 若被融合
        if (aggregated) { // add the information that where present when reports have been aggregated
            List<String> bugIds = allReports.stream().map(BugDTO::getId).collect(Collectors.toList());
            // MasterReport表中获得所有的报告
            List<MasterReport> mrs = masterReportService.getByBugIds(bugIds);
            Map<String, MasterReport> mrMap = mrs.stream().collect(toMap(MasterReport::getBugId, Function.identity()));
            allReports.forEach(bug -> {
                bug.setMasterId(mrMap.get(bug.getId()).getMasterId());
            });
        }
        allReports.forEach(bug->{
            String te = single2rootMap.get(bug.getId());
            bug.setTreeId(te==null?"null":te);
            bug.setStatus(bugIds2Data.get(bug.getId()).getStatus());
            bug.setReviewerId(bugIds2Data.get(bug.getId()).getReviewerId());
        });

        // 从json中获得的task数据保存到TaskDTO中返回
        TaskDTO task = taskService.getByExamIdAndCaseId(examId, caseId);
        String encodedUrl = taskService.getEncodeTaskReportUrl(examId, caseId) ;
        model.addAttribute("aggregated", aggregated);
        // allReport是ButDTO集合
        model.addAttribute("allReports", allReports);
        model.addAttribute("severity2String", ReportUtil.severity2String);
        model.addAttribute("recurrent2String", ReportUtil.recurrent2String);
        model.addAttribute("task", task);
        model.addAttribute("reviewMap", ReportUtil.reviewerMap);
        model.addAttribute("examId", examId);
        model.addAttribute("caseId", caseId);
        model.addAttribute("reportHost",reportHost);
        model.addAttribute("encodedUrl",encodedUrl);
        return "task_detail";
    }

    private void changeTime2Long ( Object input){
        JSONObject temp = (JSONObject) input;
        temp.put("create_time",new Timestamp(Long.parseLong(temp.get("create_time").toString()))); // 修改创建时间的格式  以便前段展示
    }

    @GetMapping("/addCrowdTask")
    public String addCrowdTask(Model model){
        model.addAttribute("templateUrl",useOss?"http://mooctest-site.oss-cn-shanghai.aliyuncs.com/excel-template.xlsx":urlPrefix+"excel-template.xlsx");
        return "addCrowdTask";
    }

    @GetMapping("/importTask")
    public String importTask(Model model){
        return "importTask";
    }

    @PostMapping("/addCrowdTask")
    @ResponseBody
    public SimpleResponse addCrowdTask2(@RequestParam("name")String name, @RequestParam("description")String description,
                                        @RequestParam("time")String time, @RequestParam("type")String type,
                                        @RequestParam("os")String os, @RequestParam("threePage") MultipartFile threePage,
                                        Model model){

        return taskService.addCrowdTask(name, description, time, type, os, threePage);
    }

    @PostMapping("/importTask")
    @ResponseBody
    public String importTask2(@RequestParam("number")String number,@RequestParam("number")String originId,
                              @RequestParam("zipFile") MultipartFile zipFile,@RequestParam("jsonFile") MultipartFile jsonFile){


        return taskService.importTask(number, originId, zipFile, jsonFile)?"success":"导出失败";
    }

    @PostMapping("/exportTask")
    @ResponseBody
    public String exportTask(@RequestParam("caseId") String caseId) {

        return taskService.exportTask(caseId) ? "success" : "导出失败";
    }
}