package cn.ksource.web.controller.business.pages.workflow;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import cn.ksource.core.util.ConvertUtil;
import cn.ksource.core.util.JsonUtil;
import cn.ksource.core.util.ParamsMapUtil;
import cn.ksource.core.util.StringUtil;
import cn.ksource.core.web.SysInfo;
import cn.ksource.core.web.WebUtil;
import cn.ksource.web.Constants;
import cn.ksource.web.facade.workflow.TemplateFacade;
/**
 * 系统管理--流程配置控制器
 * @author liusen
 * @date Jun 30,2016 11:34:20 AM
 */
@Controller
@RequestMapping("/business/pages/workflow/template")
public class TemplateController {
	@Autowired
    private TemplateFacade templateFacade;
	
	/**
     * 事件管理流转策略模板配置
     */
    @RequestMapping(value="incidentNodeDealConfig.html",method=RequestMethod.GET)
    public ModelAndView incidentNodeDealConfig(HttpServletRequest request,HttpServletResponse response) {
    	ModelAndView modelAndView = new ModelAndView("/business/pages/workflow/template/incidentNodeDealConfig");
    	Map<String, String> param = ParamsMapUtil.getParameterMap(request);
    	Map config = templateFacade.queryIncidentNodeDealConfig(param);
    	
    	Map kfry = new HashMap();
    	Map ycjszc = new HashMap();
    	Map yxgcs = new HashMap();
    	Map exgcs = new HashMap();
    	Map sxgcs = new HashMap();
    	
    	if(null!=config && config.size()>0) {
    		String kf = ConvertUtil.obj2StrBlank(config.get("KFRY"));
    		if(StringUtil.notEmpty(kf)) {
    			List<Map> kfs = JsonUtil.json2List(kf);
    			for(Map map : kfs) {
    				kfry.put(map.get("nodeId"), map);
    			}
    		}
    		
    		String yc = ConvertUtil.obj2StrBlank(config.get("YCJSZC"));
    		if(StringUtil.notEmpty(yc)) {
    			List<Map> ycs = JsonUtil.json2List(yc);
    			for(Map map : ycs) {
    				ycjszc.put(map.get("nodeId"), map);
    			}
    		}
    		
    		String yx = ConvertUtil.obj2StrBlank(config.get("YXGCS"));
    		if(StringUtil.notEmpty(yx)) {
    			List<Map> yxs = JsonUtil.json2List(yx);
    			for(Map map : yxs) {
    				yxgcs.put(map.get("nodeId"), map);
    			}
    		}
    		
    		
    		
    		String ex = ConvertUtil.obj2StrBlank(config.get("EXGCS"));
    		if(StringUtil.notEmpty(ex)) {
    			List<Map> exs = JsonUtil.json2List(ex);
    			for(Map map : exs) {
    				exgcs.put(map.get("nodeId"), map);
    			}
    		}
    		
    		
    		String sx = ConvertUtil.obj2StrBlank(config.get("SXGCS"));
    		if(StringUtil.notEmpty(sx)) {
    			List<Map> sxs = JsonUtil.json2List(sx);
    			for(Map map : sxs) {
    				sxgcs.put(map.get("nodeId"), map);
    			}
    		}
    		
    		
    	}
    	
    	List kfryNode = new ArrayList();
    	List ycjszcNode = new ArrayList();
    	List yxgcsNode = new ArrayList();
    	List exgcsNode = new ArrayList();
    	List sxgcsNode = new ArrayList();
    	
    	
    	
    	
    	//查询所有节点
		Map<String, String> nodeMap = Constants.incidentNode;
		List nodes = new ArrayList();
		for (Map.Entry<String, String> entry : nodeMap.entrySet()) {  
			String key = entry.getKey();
			String value = entry.getValue();
			Map map1 = new HashMap();
			Map map2 = new HashMap();
			Map map3 = new HashMap();
			Map map4 = new HashMap();
			Map map5 = new HashMap();
			
			Map map = new HashMap();
			map.put("nodeId", key);
			map.put("nodeName", value);
			
			
			if(kfry.containsKey(key)) {
				map1.put("type", 1);
			}
			
			
			if(ycjszc.containsKey(key)) {
				map2.put("type", 1);
			}
			
			
			if(yxgcs.containsKey(key)) {
				map3.put("type", 1);
			}
			
			if(exgcs.containsKey(key)) {
				map4.put("type", 1);
			}
			
			if(sxgcs.containsKey(key)) {
				map5.put("type", 1);
			}
			
			map1.putAll(map);
			map2.putAll(map);
			map3.putAll(map);
			map4.putAll(map);
			map5.putAll(map);
			
			kfryNode.add(map1);
	    	ycjszcNode.add(map2);
	    	yxgcsNode.add(map3);
	    	exgcsNode.add(map4);
	    	sxgcsNode.add(map5);
		}
		modelAndView.addObject("kfryNode", kfryNode);
		modelAndView.addObject("ycjszcNode", ycjszcNode);
		modelAndView.addObject("yxgcsNode", yxgcsNode);
		modelAndView.addObject("exgcsNode", exgcsNode);
		modelAndView.addObject("sxgcsNode", sxgcsNode);
    	modelAndView.addObject("config", config);
		
		
    	return modelAndView;
    }
    
    /**
     * 事件管理流转策略模板配置
     */
    @RequestMapping(value="incidentNodeDealConfig.html",method=RequestMethod.POST)
    public ModelAndView saveIncidentNodeDealConfig(HttpServletRequest request,HttpServletResponse response) {
    	Map<String, String> param = ParamsMapUtil.getParameterMap(request);
    	
    	String[] kfry = request.getParameterValues("kfry"); 
    	if(null!=kfry && kfry.length>0) {
    		param.put("kfry",arrayToString(kfry));
    	}else{
    		param.put("kfry","");
    	}
    	
    	String[] ycjszc = request.getParameterValues("ycjszc");
    	if(null!=ycjszc && ycjszc.length>0) {
    		param.put("ycjszc",arrayToString(ycjszc));
    	}else{
    		param.put("ycjszc","");
    	}
    	
    	
    	String[] yxgcs = request.getParameterValues("yxgcs");
    	if(null!=yxgcs && yxgcs.length>0) {
    		param.put("yxgcs",arrayToString(yxgcs));
    	}else{
    		param.put("yxgcs","");
    	}
    	
    	
    	String[] exgcs = request.getParameterValues("exgcs");
    	if(null!=exgcs && exgcs.length>0) {
    		param.put("exgcs",arrayToString(exgcs));
    	}else{
    		param.put("exgcs","");
    	}
    	
    	
    	String[] sxgcs = request.getParameterValues("sxgcs");
    	if(null!=sxgcs && sxgcs.length>0) {
    		param.put("sxgcs",arrayToString(sxgcs));
    	}else{
    		param.put("sxgcs","");
    	}
    	
    	
    	templateFacade.saveIncidentNodeDealConfig(param);
        return WebUtil.sysInfoPage(request, "操作成功！", "", SysInfo.Success, "");
    }
    
    private String arrayToString(String[] kfry) {
		String result = new String(); 
    	for (String string : kfry) {
    		result += string+",";
		}
    	result = result.substring(0, result.length()-1);
    	return result;
	}
    
    /**
     * 问题管理流转策略模板配置
     */
    @RequestMapping(value="questionNodeDealConfig.html",method=RequestMethod.GET)
    public ModelAndView questionNodeDealConfig(HttpServletRequest request,HttpServletResponse response) {
    	ModelAndView modelAndView = new ModelAndView("/business/pages/workflow/template/questionNodeDealConfig");
    	Map<String, String> param = ParamsMapUtil.getParameterMap(request);
    	Map config = templateFacade.queryQuestionNodeDealConfig(param);
    	
    	Map wtfq = new HashMap();
    	Map wtsl = new HashMap();
    	Map wtsh = new HashMap();
    	Map wtzd = new HashMap();
    	Map fasp = new HashMap();
    	Map fass = new HashMap();
    	Map wthg = new HashMap();
    	Map isclose = new HashMap();
    	Map isback = new HashMap();
    	
    	if(null!=config && config.size()>0) {
    		String fq = ConvertUtil.obj2StrBlank(config.get("WTFQ"));
    		if(StringUtil.notEmpty(fq)) {
    			List<Map> fqs = JsonUtil.json2List(fq);
    			for(Map map : fqs) {
    				wtfq.put(map.get("nodeId"), map);
    			}
    		}
    		
    		String sl = ConvertUtil.obj2StrBlank(config.get("WTSL"));
    		if(StringUtil.notEmpty(sl)) {
    			List<Map> sls = JsonUtil.json2List(sl);
    			for(Map map : sls) {
    				wtsl.put(map.get("nodeId"), map);
    			}
    		}
    		
    		String sh = ConvertUtil.obj2StrBlank(config.get("WTSH"));
    		if(StringUtil.notEmpty(sh)) {
    			List<Map> shs = JsonUtil.json2List(sh);
    			for(Map map : shs) {
    				wtsh.put(map.get("nodeId"), map);
    			}
    		}
    		
    		
    		
    		String zd = ConvertUtil.obj2StrBlank(config.get("WTZD"));
    		if(StringUtil.notEmpty(zd)) {
    			List<Map> zds = JsonUtil.json2List(zd);
    			for(Map map : zds) {
    				wtzd.put(map.get("nodeId"), map);
    			}
    		}
    		
    		
    		String sp = ConvertUtil.obj2StrBlank(config.get("FASP"));
    		if(StringUtil.notEmpty(sp)) {
    			List<Map> sps = JsonUtil.json2List(sp);
    			for(Map map : sps) {
    				fasp.put(map.get("nodeId"), map);
    			}
    		}
    		
    		String fa = ConvertUtil.obj2StrBlank(config.get("FASS"));
    		if(StringUtil.notEmpty(fa)) {
    			List<Map> fas = JsonUtil.json2List(fa);
    			for(Map map : fas) {
    				fass.put(map.get("nodeId"), map);
    			}
    		}
    		
    		String hg = ConvertUtil.obj2StrBlank(config.get("WTHG"));
    		if(StringUtil.notEmpty(hg)) {
    			List<Map> hgs = JsonUtil.json2List(hg);
    			for(Map map : hgs) {
    				wthg.put(map.get("nodeId"), map);
    			}
    		}
    		String close = ConvertUtil.obj2StrBlank(config.get("CLOSEJD"));
    		if(StringUtil.notEmpty(hg)) {
    			List<Map> closes = JsonUtil.json2List(close);
    			for(Map map : closes) {
    				isclose.put(map.get("nodeId"), map);
    			}
    		}
    		String back = ConvertUtil.obj2StrBlank(config.get("GOBACKJD"));
    		if(StringUtil.notEmpty(back)) {
    			List<Map> backs = JsonUtil.json2List(back);
    			for(Map map : backs) {
    				isback.put(map.get("nodeId"), map);
    			}
    		}
    		
    		
    	}
    	
    	List wtfqNode = new ArrayList();
    	List wtslNode = new ArrayList();
    	List wtshNode = new ArrayList();
    	List wtzdNode = new ArrayList();
    	List faspNode = new ArrayList();
    	List fassNode = new ArrayList();
    	List wthgNode = new ArrayList();
    	List closeNode = new ArrayList();
    	List backNode = new ArrayList();
    	
    	
    	
    	//查询所有节点
		Map<String, String> nodeMap = Constants.questionNode;
		List nodes = new ArrayList();
		for (Map.Entry<String, String> entry : nodeMap.entrySet()) {  
			String key = entry.getKey();
			String value = entry.getValue();
			Map map1 = new HashMap();
			Map map2 = new HashMap();
			Map map3 = new HashMap();
			Map map4 = new HashMap();
			Map map5 = new HashMap();
			Map map6 = new HashMap();
			Map map7 = new HashMap();
			Map map8 = new HashMap();
			Map map9 = new HashMap();
			
			Map map = new HashMap();
			map.put("nodeId", key);
			map.put("nodeName", value);
			
			if(wtfq.containsKey(key)) {
				map1.put("type", 1);
			}
			
			
			if(wtsl.containsKey(key)) {
				map2.put("type", 1);
			}
			
			
			if(wtsh.containsKey(key)) {
				map3.put("type", 1);
			}
			
			if(wtzd.containsKey(key)) {
				map4.put("type", 1);
			}
			
			if(fasp.containsKey(key)) {
				map5.put("type", 1);
			}
			
			if(fass.containsKey(key)) {
				map6.put("type", 1);
			}
			
			if(wthg.containsKey(key)) {
				map7.put("type", 1);
			}
			if(isclose.containsKey(key)) {
				map8.put("type", 1);
			}
			if(isback.containsKey(key)) {
				map9.put("type", 1);
			}
			
			map1.putAll(map);
			map2.putAll(map);
			map3.putAll(map);
			map4.putAll(map);
			map5.putAll(map);
			map6.putAll(map);
			map7.putAll(map);
			map8.putAll(map);
			map9.putAll(map);
			
			
	    	wtfqNode.add(map1);
	    	wtslNode.add(map2);
	    	wtshNode.add(map3);
	    	wtzdNode.add(map4);
	    	faspNode.add(map5);
	    	fassNode.add(map6);
	    	wthgNode.add(map7);
	    	closeNode.add(map8);
	    	backNode.add(map9);
		}
		modelAndView.addObject("wtfqNode", wtfqNode);
		modelAndView.addObject("wtslNode", wtslNode);
		modelAndView.addObject("wtshNode", wtshNode);
		modelAndView.addObject("wtzdNode", wtzdNode);
		modelAndView.addObject("faspNode", faspNode);
		modelAndView.addObject("fassNode", fassNode);
		modelAndView.addObject("wthgNode", wthgNode);
		modelAndView.addObject("closeNode", closeNode);
		modelAndView.addObject("backNode", backNode);
    	modelAndView.addObject("config", config);

		
		
    	return modelAndView;
    }
    
    /**
     * 问题管理流转策略模板配置
     */
    @RequestMapping(value="questionNodeDealConfig.html",method=RequestMethod.POST)
    public ModelAndView saveQuestionNodeDealConfig(HttpServletRequest request,HttpServletResponse response) {
    	Map<String, String> param = ParamsMapUtil.getParameterMap(request);
    	
    	String[] wtfq = request.getParameterValues("wtfq");
    	if(null!=wtfq && wtfq.length>0) {
    		param.put("wtfq",arrayToString(wtfq));
    	}else{
    		param.put("wtfq","");
    	}
    	
    	String[] wtsl = request.getParameterValues("wtsl");
    	if(null!=wtsl && wtsl.length>0) {
    		param.put("wtsl",arrayToString(wtsl));
    	}else{
    		param.put("wtsl","");
    	}
    	
    	
    	String[] wtsh = request.getParameterValues("wtsh");
    	if(null!=wtsh && wtsh.length>0) {
    		param.put("wtsh",arrayToString(wtsh));
    	}else{
    		param.put("wtsh","");
    	}
    	
    	
    	String[] wtzd = request.getParameterValues("wtzd");    	
    	if(null!=wtzd && wtzd.length>0) {
    		param.put("wtzd",arrayToString(wtzd));
    	}else{
    		param.put("wtzd","");
    	}
    	
    	String[] fasp = request.getParameterValues("fasp");
    	if(null!=fasp && fasp.length>0) {
    		param.put("fasp",arrayToString(fasp));
    	}else{
    		param.put("fasp","");
    	}
    	
    	
    	String[] fass = request.getParameterValues("fass");
    	if(null!=fass && fass.length>0) {
    		param.put("fass",arrayToString(fass));
    	}else{
    		param.put("fass","");
    	}
    	
    	 
    	String[] wthg = request.getParameterValues("wthg");
    	if(null!=wthg && wthg.length>0) {
    		param.put("wthg",arrayToString(wthg));
    	}else{
    		param.put("wthg","");
    	}
    	
    	
    	String[] isclose = request.getParameterValues("isclose");
    	if(null!=isclose && isclose.length>0) {
    		param.put("isclose",arrayToString(isclose));
    	}else{
    		param.put("isclose","");
    	}
    	
    	
    	String[] isback = request.getParameterValues("isback");
    	if(null!=isback && isback.length>0) {
    		param.put("isback",arrayToString(isback));
    	}else{
    		param.put("isback","");
    	}
    	
    	
    	templateFacade.saveQuestionNodeDealConfig(param);       
    	 return WebUtil.sysInfoPage(request, "操作成功！", "", SysInfo.Success, "");
    }
}