package com.vci.web.controller;

import com.vci.file.pagemodel.VciFileObjectVO;
import com.vci.starter.web.annotation.bus.VciNoUseBaseResult;
import com.vci.starter.web.annotation.controller.VciUnCheckRight;
import com.vci.starter.web.annotation.log.VciBusinessLog;
import com.vci.starter.web.annotation.permission.VciReferPermission;
import com.vci.starter.web.exception.VciBaseException;
import com.vci.starter.web.pagemodel.*;
import com.vci.starter.web.util.ControllerUtil;
import com.vci.web.pageModel.*;
import com.vci.web.pageModel.KeyValue;
import com.vci.web.service.WebProcessDefineServiceI;
import com.vci.web.util.WebUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@VciBusinessLog(modelName="流程查询服务")
@Controller
@RequestMapping("/processDefineController")
public class WebProcessDefineController {
	
	@Autowired
	private WebProcessDefineServiceI proDefineService;
	
	@VciBusinessLog(operateName="获取待办事项")
	@RequestMapping("/getMyUndoTask")
	@ResponseBody
	public DataGrid getMyUndoTask(BaseQueryObject baseQueryObject){
		return proDefineService.getMyUndoProcessTask(baseQueryObject.getConditionMap(), baseQueryObject.getPageHelper());
	}


	@VciBusinessLog(operateName="查询当前用户发起的流程中正在执行中的流程")
	@RequestMapping("/getMyExecutingProcess")
	@ResponseBody
	public DataGrid getMyExecutingProcess(BaseQueryObject baseQueryObject){
		return proDefineService.getMyExecutingProcess(baseQueryObject.getConditionMap(), baseQueryObject.getPageHelper());
	}

	@VciBusinessLog(operateName="查询所有正在执行中的流程")
	@RequestMapping("/getAllExecutingProcess")
	@ResponseBody
	public DataGrid getAllExecutingProcess(BaseQueryObject baseQueryObject){
		return proDefineService.getAllExecutingProcess(baseQueryObject.getConditionMap(), baseQueryObject.getPageHelper());
	}

	@VciBusinessLog(operateName="查询当前用户发起的流程中已经完成的流程")
	@RequestMapping("/getMyFinishProcess")
	@ResponseBody
	public DataGrid getFinishProcess(BaseQueryObject baseQueryObject){
		return proDefineService.getMyCompletedProcess(baseQueryObject.getConditionMap(), baseQueryObject.getPageHelper());
	}

	@VciBusinessLog(operateName="查询所有已经完成的流程")
	@RequestMapping("/getAllFinishProcess")
	@ResponseBody
	public DataGrid getAllFinishProcess(BaseQueryObject baseQueryObject){
		return proDefineService.getAllCompletedProcess(baseQueryObject.getConditionMap(), baseQueryObject.getPageHelper());
	}

	@VciBusinessLog(operateName="查询当前用户发起的流程中已经终止的流程")
	@RequestMapping("/getMyEndProcess")
	@ResponseBody
	public DataGrid getEndProcess(BaseQueryObject baseQueryObject){
		return proDefineService.getMyObsoledtedProcess(baseQueryObject.getConditionMap(), baseQueryObject.getPageHelper());
	}

	@VciBusinessLog(operateName="查询所有已终止的流程")
	@RequestMapping("/getAllEndProcess")
	@ResponseBody
	public DataGrid getAllEndProcess(BaseQueryObject baseQueryObject){
			return proDefineService.getAllObsoledtedProcess(baseQueryObject.getConditionMap(),baseQueryObject.getPageHelper());
	}

	@VciBusinessLog(operateName="查询当前用户发起的流程中已经挂起的流程")
	@RequestMapping("/getMySuspendedProcess")
	@ResponseBody
	public DataGrid getMySuspendedProcess(BaseQueryObject baseQueryObject){
		return proDefineService.getMySuspendedProcess(baseQueryObject.getConditionMap(),baseQueryObject.getPageHelper());
	}

	@VciBusinessLog(operateName="查询当前用户发起的流程中已经挂起的流程")
	@RequestMapping("/getAllSuspendedProcess")
	@ResponseBody
	public DataGrid getAllSuspendedProcess(BaseQueryObject baseQueryObject){
		return proDefineService.getAllSuspendedProcess(baseQueryObject.getConditionMap(),baseQueryObject.getPageHelper());
	}

	@VciBusinessLog(operateName="查询当前用户已经处理的流程任务")
	@RequestMapping("/getMyDoneProcessTask")
	@ResponseBody
	public DataGrid getMyDoneProcessTask(BaseQueryObject baseQueryObject){
		return proDefineService.getMyDoneProcessTask(baseQueryObject.getConditionMap(),baseQueryObject.getPageHelper());
	}
	
	@VciBusinessLog(operateName="获取数据展示所需表格的定义",notStore=true)
	@RequestMapping("/getDataDefine")
	@ResponseBody
	public BaseResult getDataDefine(String executionid, String taskOid, HttpServletRequest request) {
		if(StringUtils.isNotBlank(executionid)){

		}
		Map<String, Object> map =  proDefineService.getDataTableDefine(executionid,taskOid);
		if(!map.isEmpty()) {
			return BaseResult.success(map);
		}else {
			return BaseResult.fail("没有找到定义");
		}
	}

	@VciBusinessLog(operateName="根据任务主键获取任务对象",notStore=true)
	@RequestMapping("/getTaskByOid")
	@ResponseBody
	public BaseResult getTaskByOid(String taskOid){
		return BaseResult.success(proDefineService.getTaskByOid(taskOid));
	}
	
	@VciBusinessLog(operateName="获取任务关联的数据",notStore=true)
	@RequestMapping("/getDataByTask")
	@ResponseBody
	public DataGrid getDataByTask(BaseQueryObject baseQueryObject,String referColumn){
		if(baseQueryObject == null || baseQueryObject.getConditionMap() == null ||
				(!baseQueryObject.getConditionMap().containsKey("taskOid") && !baseQueryObject.getConditionMap().containsKey("processOid"))){
			return new DataGrid();
		}
		String taskOid = "";
		if(baseQueryObject.getConditionMap().containsKey("taskOid")){
			taskOid = baseQueryObject.getConditionMap().get("taskOid");
		}
		String processOid = "";
		if(baseQueryObject.getConditionMap().containsKey("processOid")){
			processOid = baseQueryObject.getConditionMap().get("processOid");
		}
		return proDefineService.getDataInProcess(taskOid,processOid,referColumn);
	}

	@VciBusinessLog(operateName="获取流程中业务数据关联文件",notStore=true)
	@RequestMapping("/dataGridFileInProcess")
	@ResponseBody
	public DataGrid dataGridFileInProcess(BaseQueryObject baseQueryObject,String dataOid,String executionid){
		return proDefineService.getFilesInProcess((baseQueryObject != null ? baseQueryObject.getConditionMap() : (new HashMap<String, String>())), dataOid, executionid,baseQueryObject.getPageHelper());
	}
	
	@VciBusinessLog(operateName="获取历史记录",notStore=true)
	@RequestMapping("/getHistory")
	@ResponseBody
	public DataGrid getHistory(String executionId,boolean showCurrentNode){
		return proDefineService.getHistory(executionId, showCurrentNode);
	}
	//应该使用ResonseEntity，但是不知为何前台没有获取到值，暂时使用流输出的方式
	@VciBusinessLog(operateName="获取流程图片",notStore=true)
	@GetMapping("/getProcessPic")
	public void getProcessPic(String executionId,String taskOid,HttpServletResponse response){
		try {
			byte[] picData = proDefineService.getProcessPicture(executionId, taskOid);
			if(picData!=null&& picData.length>0){
				response.setContentType(MediaType.IMAGE_PNG.toString());
				OutputStream os = response.getOutputStream();
				os.write(picData);
				os.flush();
				os.close();
				return;
			}
		} catch (Exception e) {
			try {
				ControllerUtil.writeDataToResponse(response,WebUtil.getErrorMsg(e).getBytes(),null);
			} catch (IOException ioException) {
				ioException.printStackTrace();
			}
		}
	}
	
	@VciBusinessLog(operateName="校验流程任务是否使用相同的模板",notStore=true)
	@RequestMapping("/checkUseSameTemplate")
	@ResponseBody
	public BaseResult checkUseSameTemplate(String taskOids){
		try {
			 return BaseResult.success(proDefineService.checkUseSameTemplate(taskOids));
		} catch (Exception e) {
			return BaseResult.fail(WebUtil.getErrorMsg(e));
		}
	}
	
	@VciBusinessLog(operateName="获取任务的路由",notStore=true)
	@RequestMapping("/getOutcomes")
	@ResponseBody
	public BaseResult getOutcomes(String taskOid){
		 List<ProcessOutcomeVO> allOutcomes = proDefineService.getOutCome(taskOid, true);
		BaseResult result = BaseResult.success();
		result.setData(allOutcomes);
		 if(allOutcomes !=null && allOutcomes.size()>0){
			 result.setSuccess(true);
		 }else{
			 result.setSuccess(false);
			 result.setMsg("获取的路由为空");
		 }
		 return result;
	}

	/**
	 * 获取某个分类下的userid可以使用的流程模板
	 * @param type 流程分类
	 * @param filterTemplate 指定模板
	 * @return 可用的流程模版
	 */
	@ResponseBody
	@RequestMapping("/getTemplateByType")
	@VciBusinessLog(operateName="获取流程模板",notStore=true)
	public BaseResult getTemplateByType(String type,String filterTemplate){
		List<ProcessTemplateVO> myTemplate = proDefineService.getMyTemplates(type, filterTemplate,false);
		List<KeyValue> allCombox = new ArrayList<KeyValue>();
		if(myTemplate!=null && myTemplate.size()>0){
			for(ProcessTemplateVO pt : myTemplate){
				KeyValue kv = new KeyValue();
				kv.setKey(pt.getOid());
				kv.setValue(pt.getName() + "-" + pt.getVersion());
				kv.setAttributes(WebUtil.objectToMap(pt));
				allCombox.add(kv);
			}
			BaseResult result = BaseResult.success();
			result.setData(allCombox);
			return result;
		}else{
			return BaseResult.fail("没有可用的版本");
		}
	}

	/**
	 * 获取流程中定义的所有任务节点
	 * @param processOid 流程模版的主键
	 * @param maxSecret 数据中的最大密级值
	 * @return 该流程模版中所有的任务节点,其中包含所有可以选择的用户
	 */
	@ResponseBody
	@RequestMapping("/getAllProcessNode")
	@VciBusinessLog(operateName="获取流程的节点",notStore=true)
	public BaseResult getAllProcessNode(String processOid,int maxSecret){
		try{
			List<ProcessNodeVO> allNode = proDefineService.getAllProcessNode(processOid, true,maxSecret);
			if(allNode!=null && allNode.size()>0){
				BaseResult baseResult = BaseResult.success();
				baseResult.setData(allNode);
				return baseResult;
			}else{
				return BaseResult.fail("数据有误，没找到流程的节点");
			}
		}catch(Exception e){
			return BaseResult.fail(WebUtil.getErrorMsg(e));
		}
	}

	@ResponseBody
	@RequestMapping("/getVariableByKey")
	@VciBusinessLog(operateName="获取流程中参数",notStore=true)
	@VciReferPermission(referedKey = "getVariableByKeyInProcess")
	public BaseResult getVariableByKey(String executionId,String keys){
		if(StringUtils.isBlank(executionId) || StringUtils.isBlank(keys)){
			return BaseResult.fail("没有获取到流程的信息，无法查询变量");
		}
		return BaseResult.success(proDefineService.getVariablesInProcess(executionId, keys));
	}

	@ResponseBody
	@RequestMapping("/listAuditSuggestFile")
	@VciBusinessLog(operateName = "获取流程中的审批意见",notStore = true)
	public DataGrid<VciFileObjectVO> listAuditSuggestFile(String taskOids){
		return proDefineService.listAuditSuggestFile(taskOids);
	}


	/**
	 * 参照流程分类列表
	 * @param queryObject 查询对象
	 * @return 分类的信息
	 */
	@ResponseBody
	@RequestMapping(value = "/referGridProcessClassify",method = RequestMethod.GET)
	@VciBusinessLog(operateName = "参照流程分类")
	public DataGrid<ProcessClassifyVO> referGridProcessClassify(BaseQueryObject queryObject){
		return proDefineService.referGridProcessClassify(queryObject.getConditionMap(),queryObject.getPageHelper());
	}

	/**
	 * 参照流程分类树
	 * @param queryObject 查询对象
	 * @return 分类的信息
	 */
	@ResponseBody
	@RequestMapping(value = "/referTreeProcessClassify",method = RequestMethod.GET)
	@VciBusinessLog(operateName = "参照流程分类树")
	public List<Tree> referTreeProcessClassify(TreeQueryObject queryObject){
		return proDefineService.referTreeProcessClassify(queryObject);
	}

	/**
	 * 参照流程的模板列表
	 * @param processClassifyId 流程分类的名称
	 * @param name 模板名称
	 * @return 模板的信息
	 */
	@ResponseBody
	@RequestMapping(value = "/referGridProcessTemplate",method = RequestMethod.GET)
	@VciBusinessLog(operateName = "参照流程模板")
	public DataGrid<ProcessTemplateVO> referGridProcessTemplate(String processClassifyId,String name){
		return proDefineService.referGridProcessTemplate(processClassifyId,name);
	}

	@VciNoUseBaseResult
	@RequestMapping("/getUndoTaskCount")
	@VciUnCheckRight
	@VciBusinessLog(operateName = "外部系统查询待办的总数")
	public void getUndoTaskCount(String username,HttpServletResponse response){
		String count =  String.valueOf(proDefineService.getUndoTaskCount(username));
		try {
			ControllerUtil.writeDataToResponse(response,count.getBytes(StandardCharsets.UTF_8),"text/html");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}


}