package com.skua.modules.process.controller;

import java.util.*;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.skua.core.api.vo.Result;
import com.skua.core.aspect.annotation.AutoLog;
import com.skua.core.query.QueryGenerator;
import com.skua.core.util.ConvertUtils;
import com.skua.modules.process.entity.FProcessCfg;
import com.skua.modules.process.entity.FProcessNode;
import com.skua.modules.process.entity.FProcessNodeApprover;
import com.skua.modules.process.entity.FProcessNodePercfg;
import com.skua.modules.process.service.IFProcessCfgService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.skua.modules.process.service.IFProcessNodeApproverService;
import com.skua.modules.process.service.IFProcessNodePercfgService;
import com.skua.modules.process.service.IFProcessNodeService;
import lombok.extern.slf4j.Slf4j;

import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

 /**
 * 报表-流程管理
 */
@Slf4j
@Api(tags="报表-流程管理")
@RestController
@RequestMapping("/process/fProcessCfg")
public class FProcessCfgController {
	@Autowired
	private IFProcessCfgService fProcessCfgService;
	@Autowired
	private IFProcessNodeService fProcessNodeService;
	@Autowired
	private IFProcessNodeApproverService fProcessNodeApproverService;
	@Autowired
	private IFProcessNodePercfgService fProcessNodePercfgService;

	/**
	  * 分页列表查询
	 * @param fProcessCfg
	 * @param pageNo
	 * @param pageSize
	 * @param req
	 * @return
	 */
	@AutoLog(value = "报表-流程管理-分页列表查询")
	@ApiOperation(value="报表-流程管理-分页列表查询", notes="报表-流程管理-分页列表查询")
	@GetMapping(value = "/list")
	public Result<IPage<FProcessCfg>> queryPageList(FProcessCfg fProcessCfg,
													@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
													@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
													HttpServletRequest req) {
		fProcessCfg.setDelFlag(1);
		Result<IPage<FProcessCfg>> result = new Result<IPage<FProcessCfg>>();
		QueryWrapper<FProcessCfg> queryWrapper = QueryGenerator.initQueryWrapper(fProcessCfg, req.getParameterMap());
		Page<FProcessCfg> page = new Page<FProcessCfg>(pageNo, pageSize);
		IPage<FProcessCfg> pageList = fProcessCfgService.page(page, queryWrapper);
		result.setSuccess(true);
		result.setResult(pageList);
		return result;
	}

	@AutoLog(value = "报表-流程管理-new分页列表查询")
    @ApiOperation(value="报表-流程管理-new分页列表查询", notes="报表-流程管理-new分页列表查询")
    @GetMapping(value = "/list_new")
    public Result<List<FProcessCfg>> getPageList(FProcessCfg fProcessCfg,
                                                     @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                                     @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                                     HttpServletRequest request) {
	    Result<List<FProcessCfg>> result = new Result();
	    String processName = fProcessCfg.getProName();
        Integer start = (pageNo - 1)*pageSize;
        Integer limit = pageSize;
        List<FProcessCfg> pageList = fProcessCfgService.getList(start,limit,processName);
	    result.setSuccess(true);
	    result.setResult(pageList);
	    return result;
	}

	/**
	  *   添加
	 * @param fProcessCfg
	 * @return
	 */
	@AutoLog(value = "报表-流程管理-添加")
	@ApiOperation(value="报表-流程管理-添加", notes="报表-流程管理-添加")
	@PostMapping(value = "/add")
	public Result<FProcessCfg> add(@RequestBody FProcessCfg fProcessCfg) {
		Result<FProcessCfg> result = new Result<FProcessCfg>();
        List<FProcessCfg> list = new ArrayList<>();
		try {
			String reportId = fProcessCfg.getReportId();
			list = fProcessCfgService.getListByReportId(reportId);
			if(list.size()>0){
                result.error500("所选择报表已关联流程【"+list.get(0).getProName()+"】！");
            }else{
				fProcessCfg.setVersion("1");
                fProcessCfgService.save(fProcessCfg);
                result.success("添加成功！");
            }
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			result.error500("操作失败");
		}
		return result;
	}

	 @AutoLog(value = "报表-流程管理-存为新版本")
	 @ApiOperation(value="报表-流程管理-存为新版本", notes="报表-流程管理-存为新版本")
	 @PutMapping(value = "/saveToNewVersion")
	 public Result<FProcessCfg> saveNewVersion(@RequestBody JSONObject jsonObject) {
	 Result<FProcessCfg> result = new Result<FProcessCfg>();
		 String id = jsonObject.getString("id");//旧版ID
		 FProcessCfg oldBean = fProcessCfgService.getById(id);
		 String reportId = oldBean.getReportId();
		 oldBean.setId(null);
		 oldBean.setDelFlag(0);
		 fProcessCfgService.save(oldBean);

		 int newVersion = Integer.parseInt(oldBean.getVersion().toString())+1;
		 String newId = oldBean.getId();//新版本ID
		 try {
			 FProcessCfg fProcessCfgEntity = fProcessCfgService.getById(id);//储存新的版本号
			 fProcessCfgEntity.setVersion(String.valueOf(newVersion));
			 fProcessCfgService.updateById(fProcessCfgEntity);
			 //复制节点
			 //获取新的节点列表
			 List<FProcessNode> newList = fProcessNodeService.getListByProcessId(newId);
			 for (int i = 0; i < newList.size(); i++) {
				 FProcessNode newNode = newList.get(i);
				 FProcessNode oldNode = newList.get(i);
				 String newNodeId = newNode.getId();
				 oldNode.setId(null);
				 oldNode.setProId(id);
				 fProcessNodeService.save(oldNode);
				 String oldNodeId = oldNode.getId();

				 //复制审批人
				 //获取新的审批人
				 List<FProcessNodeApprover> persionList = fProcessNodeApproverService.getByNodeId(newNodeId);
				 FProcessNodeApprover fProcessNodeApprover = persionList.get(0);
				 fProcessNodeApprover.setId(null);
				 fProcessNodeApprover.setNodeId(oldNodeId);
				 fProcessNodeApproverService.save(fProcessNodeApprover);

				 //复制报表权限
				 //获取新的报表权限
				 List<Map<String,Object>> reportList = fProcessNodePercfgService.getByNodeIdAndReportId(newNodeId,reportId);
				 for (int j = 0; j < reportList.size(); j++) {
				 	 String repitId = reportList.get(j).get("repit_id").toString();
					 int readsWrite = Integer.parseInt(reportList.get(j).get("reads_write").toString());
					 String remark = reportList.get(j).get("remark").toString();
					 /*`node_id` varchar(11) DEFAULT NULL COMMENT '节点id',*/
					 FProcessNodePercfg fProcessNodePercfg = new FProcessNodePercfg();
					 fProcessNodePercfg.setRepitId(repitId);
					 fProcessNodePercfg.setReadsWrite(readsWrite);
					 fProcessNodePercfg.setRemark(remark);
					 fProcessNodePercfg.setNodeId(oldNodeId);
					 fProcessNodePercfgService.save(fProcessNodePercfg);
				 }
			 }
			 result.success("添加成功！");
		 } catch (Exception e) {
			 log.error(e.getMessage(),e);
			 result.error500("操作失败");
		 }
		 return result;
	 }

	 /**
	  *  编辑
	 * @param fProcessCfg
	 * @return
	 */
	@AutoLog(value = "报表-流程管理-编辑")
	@ApiOperation(value="报表-流程管理-编辑", notes="报表-流程管理-编辑")
	@PutMapping(value = "/edit")
	public Result<FProcessCfg> edit(@RequestBody FProcessCfg fProcessCfg) {
		Result<FProcessCfg> result = new Result<FProcessCfg>();
		List<FProcessCfg> list = new ArrayList<>();
		String reportId = fProcessCfg.getReportId();
		FProcessCfg fProcessCfgEntity = fProcessCfgService.getById(fProcessCfg.getId());
		if(fProcessCfgEntity==null) {
			result.error500("未找到对应实体");
		}else {
            list = fProcessCfgService.getListByReportId(reportId);
		    if(list.size()>0){
                for (int i = 0; i < list.size(); i++) {
                    FProcessCfg bean = list.get(i);
                    if(bean.getId().equals(fProcessCfg.getId())){
                        fProcessCfgService.updateById(fProcessCfg);
                        result.success("修改成功!");
                        break;
                    }else{
                        result.error500("修改失败，所选报表已关联其他流程【"+bean.getProName()+"】!");
                        break;
                    }
                }
            }else{
                boolean ok = fProcessCfgService.updateById(fProcessCfg);
                if(ok) {
                    result.success("修改成功!");
                }
            }
		}
		return result;
	}

	/**
	  *   通过id删除
	 * @param id
	 * @return
	 */
	@AutoLog(value = "报表-流程管理-通过id删除")
	@ApiOperation(value="报表-流程管理-通过id删除", notes="报表-流程管理-通过id删除")
	@DeleteMapping(value = "/delete")
	public Result<?> delete(@RequestParam(name="id",required=true) String id) {
		try {
			fProcessCfgService.removeById(id);
		} catch (Exception e) {
			log.error("删除失败",e.getMessage());
			return Result.error("删除失败!");
		}
		return Result.ok("删除成功!");
	}

	/**
	  *  批量删除
	 * @param ids
	 * @return
	 */
	@AutoLog(value = "报表-流程管理-批量删除")
	@ApiOperation(value="报表-流程管理-批量删除", notes="报表-流程管理-批量删除")
	@DeleteMapping(value = "/deleteBatch")
	public Result<FProcessCfg> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
		Result<FProcessCfg> result = new Result<FProcessCfg>();
		if(ids==null || "".equals(ids.trim())) {
			result.error500("参数不识别！");
		}else {
			this.fProcessCfgService.removeByIds(Arrays.asList(ids.split(",")));
			result.success("删除成功!");
		}
		return result;
	}

	@AutoLog(value = "报表-流程管理-添加审批人和报表权限")
	@ApiOperation(value="报表-流程管理-添加审批人和报表权限", notes="报表-流程管理-添加审批人和报表权限")
	@PostMapping(value = "/addNodeInfo")
	public Result<FProcessNode> addNodeInfo(@RequestBody JSONObject jsonObject) {
		Result<FProcessNode> result = new Result<FProcessNode>();
		String nodeId = jsonObject.getString("id");
		String nodeName = jsonObject.getString("nodeName");
		FProcessNode node = fProcessNodeService.getById(nodeId);
		Map map = jsonObject.getObject("approver",Map.class);
		if(map.get("monitorClass")!=null){
			node.setMonitorClass(map.get("monitorClass").toString());
		}
		if(map.get("nodeButtonName")!=null){
			node.setNodeButtonName(map.get("nodeButtonName").toString());
		}else {
			node.setNodeButtonName("审批");
		}
		node.setNodeName(nodeName);
		fProcessNodeService.updateById(node);

		FProcessNodeApprover fProcessNodeApprover = jsonObject.getObject("approver",FProcessNodeApprover.class);

		fProcessNodeApprover.setNodeId(nodeId);
		if(fProcessNodeApprover.getId()==null||fProcessNodeApprover.getId().equals("")){
			fProcessNodeApproverService.save(fProcessNodeApprover);
		}else{
			fProcessNodeApproverService.updateById(fProcessNodeApprover);
		}

		JSONArray reportJson = jsonObject.getJSONArray("percfg");
		List<FProcessNodePercfg> reportList = JSONObject.parseArray(reportJson.toJSONString(), FProcessNodePercfg.class);
		for (int i = 0; i < reportList.size(); i++) {
			FProcessNodePercfg fProcessNodePercfg = reportList.get(i);
			fProcessNodePercfg.setNodeId(nodeId);
			if(fProcessNodePercfg.getId()==null||fProcessNodePercfg.getId().equals("")){
				fProcessNodePercfgService.save(fProcessNodePercfg);
			}else{
				fProcessNodePercfgService.updateById(fProcessNodePercfg);
			}

		}
		return result.success("操作成功");
	}

	@AutoLog(value = "报表-删除流程节点审批人和报表权限")
	@ApiOperation(value="报表-删除流程节点审批人和报表权限", notes="报表-删除流程节点审批人和报表权限")
	@DeleteMapping(value = "/deleteNodeInfo")
	public Result<?> deleteNodeData(@RequestBody JSONObject jsonObject) {
		String nodeId = jsonObject.getString("nodeId");
		fProcessNodeApproverService.deleteByNodeId(nodeId);
		fProcessNodePercfgService.deleteByNodeId(nodeId);
		return Result.ok("删除成功!");
	}

	@AutoLog(value = "报表-流程管理-通过reportId获取全部信息")
	@ApiOperation(value="报表-流程管理-通过reportId获取全部信息", notes="报表-流程管理-通过reportId获取全部信息")
	@GetMapping(value = "/getAllByReportId")
	public Result<Map<String,Object>> getAllByReportId(@RequestParam(name="reportId",required=true) String reportId) {
		Result<Map<String,Object>> result = new Result<Map<String,Object>>();
		Map<String,Object> lcMap = new HashMap<>();
		List<Map<String,Object>> allList = new ArrayList<>();
		List<Map<String,Object>> reportlist = fProcessNodePercfgService.getByReportId(reportId);
		try {
			FProcessCfg fProcessCfg = fProcessCfgService.getByReportId(reportId);

			if(fProcessCfg == null){
				FProcessCfg bean = new FProcessCfg();
				bean.setReportId(reportId);
				bean.setProName(reportId.substring(0,4) + "报表流程");
				bean.setVersion("1");
				bean.setSortNum(1);
				boolean ok = fProcessCfgService.save(bean);
				if(ok){
					fProcessCfg = fProcessCfgService.getByReportId(reportId);
				}
			}

			String processCfgId = fProcessCfg.getId();
			List<FProcessNode> nodeList = fProcessNodeService.getListByProcessId(processCfgId);
			if(nodeList.size() > 0){
				for (int i = 1; i < nodeList.size(); i++) {
					Map<String,Object> map = new HashMap();
					String nodeId = nodeList.get(i).getId();
					map.put("id",nodeId);
					map.put("nodeName",nodeList.get(i).getNodeName());
					map.put("nodeValue",nodeList.get(i).getNodeValue());
					map.put("proId",nodeList.get(i).getProId());
					map.put("proVer",nodeList.get(i).getProVer());
					List<FProcessNodeApprover> approverList = fProcessNodeApproverService.getByNodeId(nodeId);
					if(approverList.size() > 0){
						map.put("approver",approverList.get(0));
					}else{
						FProcessNodeApprover approver = new FProcessNodeApprover();
						approver.setNodeId(nodeId);
						map.put("approver",approver);
					}
					List<Map<String,Object>> percfgList = fProcessNodePercfgService.getByNodeIdAndReportId(nodeId,reportId);
					if(percfgList.size() > 0){
						map.put("percfg",percfgList);
					}else{
						map.put("percfg",reportlist);
					}
					allList.add(map);
				}
				Map<String,Object> bjMap = new HashMap();
				String nodeId_bj = nodeList.get(0).getId();
				bjMap.put("id",nodeId_bj);
				bjMap.put("nodeName",nodeList.get(0).getNodeName());
				bjMap.put("nodeValue",nodeList.get(0).getNodeValue());
				bjMap.put("proId",nodeList.get(0).getProId());
				bjMap.put("proVer",nodeList.get(0).getProVer());
				List<FProcessNodeApprover> lastApproverList = fProcessNodeApproverService.getByNodeId(nodeId_bj);
				if(lastApproverList.size() > 0){
					bjMap.put("approver",lastApproverList.get(0));
				}else{
					FProcessNodeApprover approver = new FProcessNodeApprover();
					approver.setNodeId(nodeId_bj);
					bjMap.put("approver",approver);
				}
				List<Map<String,Object>> lastPercfgList = fProcessNodePercfgService.getByNodeIdAndReportId(nodeId_bj,reportId);
				if(lastPercfgList.size() > 0){
					bjMap.put("percfg",lastPercfgList);
				}else{
					bjMap.put("percfg",reportlist);
				}
				allList.add(bjMap);
			}else{
				//发起-节点
				FProcessNode nodeStart = new FProcessNode();
				nodeStart.setNodeName("发起");
				nodeStart.setNodeValue(0);
				nodeStart.setProId(processCfgId);
				fProcessNodeService.save(nodeStart);
				//办结-节点
				FProcessNode nodeEnd = new FProcessNode();
				nodeEnd.setNodeName("办结");
				nodeEnd.setNodeValue(-1);
				nodeEnd.setProId(processCfgId);
				fProcessNodeService.save(nodeEnd);
				List<FProcessNode> list = fProcessNodeService.getListByProcessId(processCfgId);
				for (int i = 0; i < list.size(); i++) {
					Map<String,Object> map = new HashMap();
					FProcessNodeApprover approver = new FProcessNodeApprover();
					map.put("id",list.get(i).getId());
					map.put("nodeName",list.get(i).getNodeName());
					map.put("nodeValue",list.get(i).getNodeValue());
					map.put("proId",list.get(i).getProId());
					map.put("proVer",list.get(i).getProVer());
					approver.setNodeId(list.get(i).getId());
					map.put("approver",approver);
					map.put("percfg",reportlist);
					allList.add(map);
				}
			}
			lcMap.put("id",processCfgId);
			lcMap.put("data",allList);
			result.setResult(lcMap);
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			result.error500("操作失败");
		}
		return result;
	}

	/**
	  * 通过id查询
	 * @param id
	 * @return
	 */
	@AutoLog(value = "报表-流程管理-通过id查询")
	@ApiOperation(value="报表-流程管理-通过id查询", notes="报表-流程管理-通过id查询")
	@GetMapping(value = "/queryById")
	public Result<FProcessCfg> queryById(@RequestParam(name="id",required=true) String id) {
		Result<FProcessCfg> result = new Result<FProcessCfg>();
		FProcessCfg fProcessCfg = fProcessCfgService.getById(id);
		if(fProcessCfg==null) {
			result.error500("未找到对应实体");
		}else {
			result.setResult(fProcessCfg);
			result.setSuccess(true);
		}
		return result;
	}

  /**
      * 导出excel
   *
   * @param request
   * @param response
   */
  @RequestMapping(value = "/exportXls")
  public ModelAndView exportXls(HttpServletRequest request, HttpServletResponse response) {
      // Step.1 组装查询条件
      QueryWrapper<FProcessCfg> queryWrapper = null;
      try {
          String paramsStr = request.getParameter("paramsStr");
          if (ConvertUtils.isNotEmpty(paramsStr)) {
              String deString = URLDecoder.decode(paramsStr, "UTF-8");
              FProcessCfg fProcessCfg = JSON.parseObject(deString, FProcessCfg.class);
              queryWrapper = QueryGenerator.initQueryWrapper(fProcessCfg, request.getParameterMap());
          }
      } catch (UnsupportedEncodingException e) {
          e.printStackTrace();
      }

      //Step.2 AutoPoi 导出Excel
      ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
      List<FProcessCfg> pageList = fProcessCfgService.list(queryWrapper);
      //导出文件名称
      mv.addObject(NormalExcelConstants.FILE_NAME, "报表-流程管理列表");
      mv.addObject(NormalExcelConstants.CLASS, FProcessCfg.class);
      mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("报表-流程管理列表数据", "导出人:Jeecg", "导出信息"));
      mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
      return mv;
  }

  /**
      * 通过excel导入数据
   *
   * @param request
   * @param response
   * @return
   */
  @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
  public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
      MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
      Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
      for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
          MultipartFile file = entity.getValue();// 获取上传文件对象
          ImportParams params = new ImportParams();
          params.setTitleRows(2);
          params.setHeadRows(1);
          params.setNeedSave(true);
          try {
              List<FProcessCfg> listFProcessCfgs = ExcelImportUtil.importExcel(file.getInputStream(), FProcessCfg.class, params);
              fProcessCfgService.saveBatch(listFProcessCfgs);
              return Result.ok("文件导入成功！数据行数:" + listFProcessCfgs.size());
          } catch (Exception e) {
              log.error(e.getMessage(),e);
              return Result.error("文件导入失败:"+e.getMessage());
          } finally {
              try {
                  file.getInputStream().close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
      return Result.ok("文件导入失败！");
  }

}