package com.highdatas.srs.web;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.highdatas.srs.entity.*;
import com.highdatas.srs.pojo.CodeMsg;
import com.highdatas.srs.pojo.Result;
import com.highdatas.srs.service.IProjectDealService;
import com.highdatas.srs.service.ISchemeDetailService;
import com.highdatas.srs.service.ISchemeService;
import com.highdatas.srs.service.ISysUserService;
import com.highdatas.srs.util.DbUtils;
import com.highdatas.srs.util.FileUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.io.UnsupportedEncodingException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author kimi
 * @since 2020-01-15
 */
@RestController
@RequestMapping("/scheme")
public class SchemeController {
    @Autowired
    ISchemeService schemeService;
    @Autowired
    ISysUserService userService;
    @Autowired
    ISchemeDetailService iSchemeDetailService;
    @Autowired
    IProjectDealService projectDealService;
    @Value("${base.file.path}")
    String basePath;

    @RequestMapping(value = "/daywork/{id}", method = RequestMethod.GET)
    public Result dayByUser(@PathVariable String id, HttpServletRequest request)  {
        String userId = request.getParameter("userId");

        Date now = new Date();
        Calendar instance = Calendar.getInstance();
        instance.setTime(now);
        instance.set(Calendar.HOUR_OF_DAY, 0 );
        instance.set(Calendar.MINUTE, 0 );
        instance.set(Calendar.SECOND, 0);
        now = instance.getTime();
        instance.add(Calendar.DAY_OF_YEAR,-1);
        Date yesterday = instance.getTime();
        instance.add(Calendar.DAY_OF_YEAR,2);
        Date tomorrow = instance.getTime();
        EntityWrapper<SchemeDetail> schemeDetailEntityWrapper = new EntityWrapper<>();
        EntityWrapper<SchemeDetail> dealWrapper = new EntityWrapper<>();
        schemeDetailEntityWrapper.eq("parent_id", id);
        dealWrapper.eq("parent_id", id);
        dealWrapper.eq("finish",true);
        int total = iSchemeDetailService.selectCount(schemeDetailEntityWrapper);
        int deal = iSchemeDetailService.selectCount(dealWrapper);

        EntityWrapper<SchemeDetail> yesEntityWrapper = new EntityWrapper<>();
        EntityWrapper<SchemeDetail> yesDealWrapper = new EntityWrapper<>();
        yesEntityWrapper.eq("parent_id", id);
        yesDealWrapper.eq("parent_id", id);
        yesDealWrapper.eq("finish",true);

        if (!StringUtils.isEmpty(userId)) {
            schemeDetailEntityWrapper.eq("user_id", userId);
            dealWrapper.eq("user_id", userId);
            yesDealWrapper.eq("user_id", userId);
            yesEntityWrapper.eq("user_id", userId);
        }

        schemeDetailEntityWrapper.le("start_time", now);
        schemeDetailEntityWrapper.gt("end_time", now);

        dealWrapper.ge("update_time",now);
        dealWrapper.lt("update_time",tomorrow);

        int nowTotal = iSchemeDetailService.selectCount(schemeDetailEntityWrapper);

        yesEntityWrapper.le("start_time", yesterday);
        yesEntityWrapper.gt("end_time", yesterday);
        int yesTotal = iSchemeDetailService.selectCount(yesEntityWrapper);

        int nowDeal = iSchemeDetailService.selectCount(dealWrapper);

        yesDealWrapper.ge("update_time",yesterday);
        yesDealWrapper.lt("update_time",now);
        int yestDeal = iSchemeDetailService.selectCount(yesDealWrapper);
        JSONObject object = new JSONObject();
        object.fluentPut("total",total);
        object.fluentPut("nowTotal",nowTotal);
        object.fluentPut("yesTotal",yesTotal);
        object.fluentPut("deal",deal);
        object.fluentPut("nowDeal",nowDeal);
        object.fluentPut("yesDeal",yestDeal);

        return Result.success(object);
    }

    @RequestMapping(value = "/get/{id}", method = RequestMethod.GET)
    public Result get(@PathVariable String id)  {
        Scheme scheme = schemeService.selectById(id);
        return Result.success(scheme);
    }

    @RequestMapping(value = "/typesCnt", method = RequestMethod.GET)
    public Result typesCnt()  {
        EntityWrapper<Scheme> editWrapper = new EntityWrapper<>();
        editWrapper.eq("status", "edit");
        int edit = schemeService.selectCount(editWrapper);
        EntityWrapper<Scheme> workingWrapper = new EntityWrapper<>();
        workingWrapper.eq("status", "working");
        int working = schemeService.selectCount(workingWrapper);
        EntityWrapper<Scheme> finishWrapper = new EntityWrapper<>();
        finishWrapper.eq("status", "finish");
        int finish = schemeService.selectCount(finishWrapper);

        EntityWrapper<Scheme> delayWrapper = new EntityWrapper<>();
        delayWrapper.eq("status", "delay");
        int delay = schemeService.selectCount(delayWrapper);

        int total = schemeService.selectCount(null);




        ArrayList<Integer> result = new ArrayList<>();
        result.add(edit);
        result.add(working);
        result.add(delay);
        result.add(finish);

        JSONObject object = new JSONObject();
        object.fluentPut("total", total);
        object.fluentPut("typeCnt", result);
        return Result.success(object);
    }

    @RequestMapping(value = "/getSchemeInfo/{id}", method = RequestMethod.GET)
    public Result getSchemeInfo(@PathVariable String id) throws UnsupportedEncodingException {
        Scheme scheme = schemeService.selectById(id);
        List<SchemeDetail> schemeDetailList = iSchemeDetailService.selectList(new EntityWrapper<SchemeDetail>().eq("parent_id", id));
        HashMap<String, SysUser> userSet = new HashMap<>();
        for (SchemeDetail detail : schemeDetailList) {
            String userId = detail.getUserId();
            SysUser sysUser = userService.selectById(userId);
            if (sysUser == null || userSet.containsKey(sysUser.getId())) {
                continue;
            }

            userSet.put(sysUser.getId(), sysUser);
        }
        List<ProjectDeal> dealList = projectDealService.selectList(new EntityWrapper<ProjectDeal>().eq("scheme_id", id));
        String rootPath = basePath + "/" + scheme.getName();
        ArrayList<JSONObject> childrenFiles = FileUtils.getChildrenFiles(rootPath);

        Date startTime = scheme.getStartTime();
        Date endTime = scheme.getEndTime();
        Calendar start = Calendar.getInstance();
        start.setTime(startTime);

        List<String> time = new ArrayList<>();
        List<Integer> totalList = new ArrayList<>();
        List<Integer> todoList = new ArrayList<>();
        SimpleDateFormat dateFormat = new SimpleDateFormat("MM-dd");
        int preTotal = 0;
        int preTodo = 0;

        while (startTime.before(endTime)) {
            startTime = start.getTime();
            time.add(dateFormat.format(startTime));
            EntityWrapper<SchemeDetail> schemeDetailEntityWrapper = new EntityWrapper<>();
            schemeDetailEntityWrapper.le("start_time", startTime);
            schemeDetailEntityWrapper.gt("end_time", startTime);

            schemeDetailEntityWrapper.eq("edit", false);
            int cnt = iSchemeDetailService.selectCount(schemeDetailEntityWrapper);
            int totalCnt = preTotal + cnt;
            totalList.add(totalCnt);
            preTotal = totalCnt;
            schemeDetailEntityWrapper.eq("finish", false);
            int todo = iSchemeDetailService.selectCount(schemeDetailEntityWrapper);
            int todoCnt = totalCnt - (preTodo + todo);
            todoList.add(todoCnt);
            preTodo = todoCnt;
            start.add(Calendar.DAY_OF_YEAR, 1);
        }
        Collections.reverse(totalList);
        Collections.reverse(todoList);

        JSONObject result = new JSONObject();
        JSONObject option = new JSONObject();
        option.fluentPut("xAxis", time);
        option.fluentPut("yAxis1", todoList);
        option.fluentPut("yAxis2", totalList);

        // 图
        result.fluentPut("option", option);
        // 记录
        result.fluentPut("record", dealList);
        // 人员
        result.fluentPut("users", userSet.values());

        // 详情
        JSONArray array = new JSONArray();
        for (SchemeDetail detail : schemeDetailList) {
            JSONObject o = (JSONObject) JSON.toJSON(detail);
            SchemeDetailType type = detail.getType();
            o.fluentPut("name", type.covert());
            array.add(o);
        }
        result.fluentPut("scheme", array);
        //目录
        result.fluentPut("paths",childrenFiles );
        return Result.success(result);
    }



    @RequestMapping(value = "/working/{id}", method = RequestMethod.GET)
    public Result working(@PathVariable String id)  {
        Scheme scheme = schemeService.selectById(id);
        List<SchemeDetail> schemeDetailList = iSchemeDetailService.selectList(new EntityWrapper<SchemeDetail>().eq("parent_id", id));
        for (SchemeDetail detail : schemeDetailList) {
            detail.setEdit(false);
            detail.updateById();
        }
        scheme.setStatus("working");
        boolean b = scheme.updateById();
        if (b) {
            return Result.success(CodeMsg.UPDATE_SUCCESS);
        } else {
            return Result.error(CodeMsg.UPDATE_ERROR);
        }

    }
    @RequestMapping(value = "/all", method = RequestMethod.GET)
    public Result all()  {
        List<Scheme> schemes = schemeService.selectList(null);
        return Result.success(schemes);
    }

    @RequestMapping(value = "/page/{pageNo}", method = RequestMethod.GET)
    public Result get(@PathVariable Integer pageNo, HttpServletRequest request)  {
        String pageSize = request.getParameter("pageSize");
        String name = request.getParameter("name");
        String status = request.getParameter("status");
        String type = request.getParameter("type");
        String userId = request.getParameter("userId");

        EntityWrapper<Scheme> schemeEntityWrapper = new EntityWrapper<>();
        if (!StringUtils.isEmpty(name)) {
            schemeEntityWrapper.like("name", name);
        }
        if (!StringUtils.isEmpty(userId)) {
            schemeEntityWrapper.eq("user_id", userId);
        }
        if (!StringUtils.isEmpty(type)) {
            schemeEntityWrapper.eq("reseach_type", type);
        }
        if (!StringUtils.isEmpty(status)) {
            schemeEntityWrapper.eq("status", status);
        }

        Page<Scheme> schemePage;

        if (StringUtils.isEmpty(pageSize)) {
            schemePage = new Page<>(pageNo, 15);
        }
        else {
            schemePage = new Page<>(pageNo, Integer.valueOf(pageSize));
        }

        Page<Scheme> page = schemeService.selectPage(schemePage, schemeEntityWrapper);
        List<Scheme> records = page.getRecords();
        Page<JSONObject> jsonObjectPage = new Page<>();
        jsonObjectPage.setTotal(page.getTotal());
        jsonObjectPage.setCurrent(page.getCurrent());
        jsonObjectPage.setSize(page.getSize());
        List<JSONObject> result = new ArrayList<>();
        for (Scheme scheme : records) {
            JSONObject json = (JSONObject) JSON.toJSON(scheme);
            Wrapper<SchemeDetail> delayWrapper = new EntityWrapper<SchemeDetail>().eq("parent_id", scheme.getId());
            Wrapper<SchemeDetail> finishWrapper = new EntityWrapper<SchemeDetail>().eq("parent_id", scheme.getId());
            int total = iSchemeDetailService.selectCount(delayWrapper);
            int delayInt = iSchemeDetailService.selectCount(delayWrapper.eq("delay", true));

            int finishInt = iSchemeDetailService.selectCount(finishWrapper.eq("finish", true));
            json.fluentPut("totalCnt", total);
            json.fluentPut("delayCnt", delayInt);
            json.fluentPut("finishCnt", finishInt);

            result.add(json);
        }
        jsonObjectPage.setRecords(result);
        return Result.success(jsonObjectPage);
    }

    @RequestMapping(value = "/addOrUpdate", method = RequestMethod.GET)
    public Result add(@RequestParam String reseachType, @RequestParam String name, @RequestParam Date startTime, @RequestParam Date endTime, HttpServletRequest request)  {

        String id = request.getParameter("id");
        String desp = request.getParameter("desp");
        String userId = request.getParameter("userId");

        Scheme scheme;
        if (StringUtils.isEmpty(id)) {
            scheme = new Scheme();
        }else{
            scheme = schemeService.selectById(id);
        }
        if (scheme == null) {
            return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
        }
        // reseachType to enum
        if (StringUtils.isEmpty(scheme.getId())) {
            scheme.setId(DbUtils.getUUID());
        }
        boolean insert = scheme.setUserId(userId).setCreateTime(new Date()).setName(name).setStartTime(startTime).setEndTime(endTime)
                .setDesp(desp).setReseachType(reseachType).insertOrUpdate();
        if (insert) {
            return Result.success(scheme.getId());
        } else {
            return Result.error(CodeMsg.INSERT_ERROR);
        }
    }

    @RequestMapping(value = "/update/{id}", method = RequestMethod.GET)
    public Result add(@PathVariable String id, HttpServletRequest request) throws JsonProcessingException {
        String data = request.getParameter("data");
        Scheme scheme = DbUtils.json2Bean(data, Scheme.class);
        boolean b = scheme.insertOrUpdate();
        // reseachType to enum

        if (b) {
            return Result.success(CodeMsg.UPDATE_SUCCESS);
        } else {
            return Result.error(CodeMsg.UPDATE_ERROR);
        }
    }

    @RequestMapping(value = "/del/{id}", method = RequestMethod.GET)
    public Result del(@PathVariable String id, HttpServletRequest request) throws JsonProcessingException {
        Scheme scheme = schemeService.selectById(id);
        boolean delete = scheme.deleteById();

        if (delete) {
            return Result.success(CodeMsg.DELETE_SUCCESS);
        } else {
            return Result.error(CodeMsg.DELETE_ERROR);
        }
    }
}