package com.highdatas.mdm.controller;


import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.highdatas.mdm.entity.Flows;
import com.highdatas.mdm.entity.Maintain;
import com.highdatas.mdm.entity.MaintainDetail;
import com.highdatas.mdm.entity.TUser;
import com.highdatas.mdm.mapper.TableInfoMapper;
import com.highdatas.mdm.pojo.ActivitiStatus;
import com.highdatas.mdm.pojo.CodeMsg;
import com.highdatas.mdm.pojo.Operate;
import com.highdatas.mdm.pojo.Result;
import com.highdatas.mdm.service.IFlowsService;
import com.highdatas.mdm.service.IMaintainDetailService;
import com.highdatas.mdm.service.IMaintainService;
import com.highdatas.mdm.service.ITUserService;
import com.highdatas.mdm.util.Constant;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author kimi
 * @since 2019-12-16
 */
@RestController
@RequestMapping("/maintain")
public class MaintainController {
    @Autowired
    IMaintainService maintainService;
    @Autowired
    ITUserService userService;
    @Autowired
    IMaintainDetailService maintainDetailService;
    @Autowired
    TableInfoMapper tableInfoMapper;
    @Autowired
    IFlowsService  flowsService;

    @RequestMapping(value = "/get/{id}", method = RequestMethod.GET)
    public Result get(@PathVariable String id) {
        Maintain maintain = maintainService.selectById(id);
        if (maintain == null) {
            return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
        }
        return Result.success(maintain);
    }

    @RequestMapping(value = "{tableName}/unSubmit/{pageNo}", method = RequestMethod.GET)
    public Result unSubmit(@PathVariable String tableName, @PathVariable Integer pageNo, HttpServletRequest request) throws UnsupportedEncodingException {
        String pageSize = request.getParameter("pageSize");
        String whereSegment = request.getParameter("whereSegment");

        if (StringUtils.isEmpty(whereSegment)) {
            whereSegment = Constant.WHERE_DEFAULT;
        }else  {
            whereSegment = URLDecoder.decode(whereSegment, "UTF-8");
        }
        return maintainService.getUnSubmitData(tableName, pageNo, pageSize, whereSegment);
    }

    @RequestMapping(value = "{tableName}/unflow/{pageNo}", method = RequestMethod.GET)
    public Result unflow(@PathVariable String tableName, @PathVariable Integer pageNo, HttpServletRequest request) throws UnsupportedEncodingException {
        String pageSize = request.getParameter("pageSize");
        String whereSegment = request.getParameter("whereSegment");

        if (StringUtils.isEmpty(whereSegment)) {
            whereSegment = Constant.WHERE_DEFAULT;
        }else  {
            whereSegment = URLDecoder.decode(whereSegment, "UTF-8");
        }
        if (StringUtils.isEmpty(pageSize)) {
            return maintainService.getInvalidVerionData(tableName, whereSegment, pageNo, null);
        } else {
            return maintainService.getInvalidVerionData(tableName, whereSegment, pageNo, Integer.valueOf(pageSize));
        }
    }

    @RequestMapping(value = "/version/{tableName}", method = RequestMethod.GET)
    public Result getHistory(@PathVariable String tableName) {

        Maintain nowVersion = maintainService.getNowVersion(tableName);
        if (nowVersion == null) {
            return Result.error(new CodeMsg(100001,"无当前版本"));
        }
        List<Maintain> maintainList = maintainService.selectList(new EntityWrapper<Maintain>().eq("table_name", tableName).orderBy("order_no",false));
        List<Maintain> result = new ArrayList<>();
        for (Maintain maintain : maintainList) {
            String flowId = maintain.getFlowId();
            if (StringUtils.isEmpty(flowId)) {
                continue;
            }

            Flows flows = flowsService.selectById(maintain.getFlowId());
            if (flows.getStatus().equals(ActivitiStatus.close)) {
                continue;
            }
            if (flows.getStatus().equals(ActivitiStatus.working) || flows.getStatus().equals(ActivitiStatus.refuse)) {
                maintain.setMaintainType(-1);
            }else if(flows.getStatus().equals(ActivitiStatus.open)){
                maintain.setMaintainType(1);
            }
            if (maintain.getId().equalsIgnoreCase(nowVersion.getId())) {
                maintain.setMaintainType(0);
            }
            result.add(maintain);
        }

        return Result.success(result);
    }

    @RequestMapping(value = "/detail/{id}/{pageNo}", method = RequestMethod.GET)
    public Result detail(@PathVariable String id, @PathVariable int pageNo) {
        Maintain maintain = maintainService.selectById(id);
        String tableName = maintain.getTableName();
        String tableTempName = tableName + Constant.RECORD;

        List<MaintainDetail> maintainDetailList = maintainDetailService.selectList(new EntityWrapper<MaintainDetail>().eq("parent_id", id));

        return Result.success(maintain);
    }

    @RequestMapping(value = "/all/{pageno}", method = RequestMethod.GET)
    public Result all(@PathVariable int pageno, HttpServletRequest request) {
        String tableName = request.getParameter("tableName");
        String s = tableInfoMapper.selectTableByName(tableName);

        Page<Maintain> result;
        String pageSize = request.getParameter("pageSize");
        Page<Maintain> maintainPage;
        if (StringUtils.isEmpty(pageSize)) {
            maintainPage = new Page<Maintain>(pageno, 20);

        } else {
            maintainPage = new Page<Maintain>(pageno, Integer.valueOf(pageSize));
        }
        if (StringUtils.isEmpty(tableName)) {
            result = maintainService.selectPage(maintainPage);
        } else {
            Wrapper<Maintain> tableNameWrapper = new EntityWrapper<Maintain>().eq("table_name", tableName);
            tableNameWrapper.orderBy("order_no desc");
            result = maintainService.selectPage(maintainPage, tableNameWrapper);
        }
        List<Maintain> records = result.getRecords();
        List<Maintain> resultObj = new ArrayList<>();

        for (Maintain record : records) {
            String flowId = record.getFlowId();
            if (StringUtils.isEmpty(flowId)) {
                continue;
            }
            Flows flows = flowsService.selectById(flowId);
            if (flows == null || !flows.getStatus().equals(ActivitiStatus.open)) {
                continue;
            }
            String chargeId = record.getChargeId();
            TUser user = userService.selectOne(new EntityWrapper<TUser>().eq("user_id", chargeId));
            record.setChargeId(user.getUserName());
            resultObj.add(record);
        }
        result.setRecords(resultObj);
        return  Result.success(result);
    }

    @RequestMapping(value = "/compare/{maintainId1}/{maintainId2}", method = RequestMethod.GET)
    public Result compare(@PathVariable String maintainId1, @PathVariable String maintainId2) {
        HashMap<Operate, Object> compare = maintainService.compare(maintainId1, maintainId2);
        return Result.success(compare);
    }

    @RequestMapping(value = "/detail/{pageNo}", method = RequestMethod.GET)
    public Result setFlowId(@RequestParam String flowId,@PathVariable Integer pageNo, HttpServletRequest request) {
        String whereSegment = request.getParameter("whereSegment");
        String pageSize = request.getParameter("pageSize");
        if (StringUtils.isEmpty(whereSegment)) {
            whereSegment = Constant.WHERE_DEFAULT;
        }
        if (StringUtils.isEmpty(pageSize)) {
            return maintainService.tempDataByVersionByFlow(flowId, whereSegment, pageNo, null);
        }
        return maintainService.tempDataByVersionByFlow(flowId, whereSegment, pageNo, Integer.valueOf(pageSize));
    }


    @RequestMapping(value = "/set/{id}", method = RequestMethod.GET)
    public Result setFlowId(@PathVariable String id, @RequestParam String flowid) {
        Maintain maintain = maintainService.selectById(id);
        if (maintain == null) {
            return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
        }
        maintain.setFlowId(flowid);
        maintain.updateById();
        return Result.success(maintain);
    }
}