package com.sipai.controller.administration;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

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

import net.sf.json.JSONArray;

import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.sipai.entity.activiti.WorkTask;
import com.sipai.entity.administration.IndexWork;
import com.sipai.entity.business.BusinessUnit;
import com.sipai.entity.business.BusinessUnitAudit;
import com.sipai.entity.business.BusinessUnitHandle;
import com.sipai.entity.business.BusinessUnitRecord;
import com.sipai.entity.user.Company;
import com.sipai.entity.user.User;
import com.sipai.service.activiti.WorkflowProcessDefinitionService;
import com.sipai.service.activiti.WorkflowService;
import com.sipai.service.administration.IndexWorkService;
import com.sipai.service.business.BusinessUnitAuditService;
import com.sipai.service.business.BusinessUnitHandleService;
import com.sipai.service.user.UnitService;
import com.sipai.service.user.UserService;
import com.sipai.tools.ActivitiUtil;
import com.sipai.tools.CommString;
import com.sipai.tools.CommUtil;

@Controller
@RequestMapping("/administration/indexWork")
public class IndexWorkController {
    @Resource
    private IndexWorkService indexWorkService;
    @Resource
    private UnitService unitService;
    @Resource
    private WorkflowProcessDefinitionService workflowProcessDefinitionService;
    @Resource
    private BusinessUnitHandleService businessUnitHandleService;
    @Resource
    private BusinessUnitAuditService businessUnitAuditService;
    @Resource
    private WorkflowService workflowService;
    @Resource
    private RuntimeService runtimeService;
    @Resource
    private TaskService taskService;
    @Resource
    private UserService userService;
    
    @RequestMapping("/showList.do")
    public String showList(HttpServletRequest request, Model model) {
    	return "/administration/indexWorkList";
    }
    
    @RequestMapping("/getList.do")
    public ModelAndView getList(HttpServletRequest request,Model model,
    		@RequestParam(value = "page") Integer page,
    		@RequestParam(value = "rows") Integer rows,
    		@RequestParam(value = "sort", required = false) String sort,
    		@RequestParam(value = "order", required = false) String order) {
    	User cu = (User) request.getSession().getAttribute("cu");
    	if (sort==null || sort.equals("id")) {
			sort = " insdt ";
		}
    	if (order == null) {
			order = " desc ";
		}
    	String orderstr = " order by "+sort+" "+order;
    	String wherestr = " where 1=1 ";
    	if (request.getParameter("search_code")!= null && !request.getParameter("search_code").isEmpty()) {
			wherestr += " and unit_id = '"+request.getParameter("search_code")+"'";
		}
    	PageHelper.startPage(page, rows);
    	List<IndexWork> list = this.indexWorkService.selectListByWhere(wherestr+orderstr);
    	PageInfo<IndexWork> pInfo = new PageInfo<IndexWork>(list);
    	JSONArray jsonArray = JSONArray.fromObject(list);
    	String result = "{\"total\":"+pInfo.getTotal()+",\"rows\":"+jsonArray+"}";
    	model.addAttribute("result",result);
    	return new ModelAndView("result");
    }
    
    @RequestMapping("/add.do")
    public String doadd (HttpServletRequest request,Model model) {
    	String companyId = request.getParameter("companyId");
    	Company company = this.unitService.getCompById(companyId);
    	String id = company.getEname()+"-ZBKZ-"+CommUtil.nowDate().replaceAll("[[\\s-:punct:]]","");
    	model.addAttribute("id",id);
    	model.addAttribute("company",company);
    	return "/administration/indexWorkAdd";
    }
    
    @RequestMapping("/save.do")
    public String dosave(HttpServletRequest request,Model model,
    		@ModelAttribute IndexWork indexWork) {
    	User cu = (User) request.getSession().getAttribute("cu");
    	indexWork.setInsdt(CommUtil.nowDate());
    	indexWork.setInsuser(cu.getId());
    	int result = this.indexWorkService.save(indexWork);
    	String resultstr = "{\"res\":\""+result+"\",\"id\":\""+indexWork.getId()+"\"}";
    	model.addAttribute("result",resultstr);
    	return "result";
    }
    
    @RequestMapping("/delete.do")
    public String dodelete(HttpServletRequest request,Model model,
    		@RequestParam(value = "id") String id) {
    	int result = this.indexWorkService.deleteById(id);
    	model.addAttribute("result",result);
    	return "result";
    }
    
    @RequestMapping("/deletes.do")
    public String dodeletes(HttpServletRequest request,Model model,
    		@RequestParam(value = "ids") String ids){
    	ids = ids.replace(",","','");
    	int result = this.indexWorkService.deleteByWhere("where id in ('"+ids+"')");
    	model.addAttribute("result",result);
    	return "result";
    }
    
    @RequestMapping("/edit.do")
    public String doedit(HttpServletRequest request,Model model,
    		@RequestParam(value = "id") String id) {
    	IndexWork indexWork = this.indexWorkService.selectById(id);
    	model.addAttribute("indexWork", indexWork);
    	return "/administration/indexWorkEdit";
    }
    
    @RequestMapping("/update.do")
    public String doupdate(HttpServletRequest request,Model model,
    		@ModelAttribute IndexWork indexWork) {
    	User cu = (User) request.getSession().getAttribute("cu");
    	indexWork.setInsdt(CommUtil.nowDate());
    	indexWork.setInsuser(cu.getId());
    	int result = this.indexWorkService.update(indexWork);
    	String resstr="{\"res\":\""+result+"\",\"id\":\""+indexWork.getId()+"\"}";
		model.addAttribute("result", resstr);
		return "result";
    }
    
    @RequestMapping("/view.do")
	public String doview(HttpServletRequest request,Model model,
			@RequestParam(value = "id") String id){
		IndexWork indexWork = this.indexWorkService.selectById(id);
    	model.addAttribute("indexWork", indexWork);
    	return "/administration/indexWorkView";
	}
    /**
	 * 更新,启动指标审核流程
	 * */
	@RequestMapping("/startProcess.do")
	public String dostartProcess(HttpServletRequest request,Model model,
			@ModelAttribute IndexWork indexWork){
		User cu= (User)request.getSession().getAttribute("cu");
		indexWork.setInsuser(cu.getId());
		indexWork.setInsdt(CommUtil.nowDate());
		indexWorkService.update(indexWork);
		indexWork = indexWorkService.selectById(indexWork.getId());
		int result=0;
		try {
			result =this.indexWorkService.startProcess(indexWork);
        } catch (Exception e) {
	        // TODO: handle exception
        	e.printStackTrace();
        }
		String resstr="{\"res\":\""+result+"\",\"id\":\""+indexWork.getId()+"\"}";
		model.addAttribute("result", resstr);
		return "result";
	}
	/**
	 * 查看指标处理流程详情
	 * @param request
	 * @param model
	 * @return
	 */
	@RequestMapping("/showProcessIndexWorkView.do")
	public String showProcessIndexWorkView(HttpServletRequest request,Model model){
		String indexWorkId = request.getParameter("id");
		IndexWork indexWork = this.indexWorkService.selectById(indexWorkId);
		request.setAttribute("business", indexWork);
		List<BusinessUnitRecord> businessUnitRecords = new ArrayList<>();
		BusinessUnitRecord businessUnitRecord = new BusinessUnitRecord(indexWork);
		businessUnitRecords.add(businessUnitRecord);
		
		List<WorkTask> workTasks=workflowProcessDefinitionService.getAllPDTask(indexWork.getProcessdefid(), "desc");
		List<String> keys=new ArrayList<>();
		for (WorkTask workTask : workTasks) {
			keys.add(workTask.getTaskKey());
        }
		Set set = new HashSet();
		set.addAll(keys);
		keys=new ArrayList<>();
		keys.addAll(set);
		for (String item : keys) {
	        switch (item) {
			case BusinessUnit.UNIT_IndexWork_HANDLE:
				List<BusinessUnitHandle> list = businessUnitHandleService.selectListByWhere("where businessid='"+indexWorkId+"' ");
				for (BusinessUnitHandle businessUnitHandle : list) {
					businessUnitRecord = new BusinessUnitRecord(businessUnitHandle);
					businessUnitRecords.add(businessUnitRecord);
                }
				break;
			case BusinessUnit.UNIT_IndexWork_AUDIT:
				List<BusinessUnitAudit> list_audit = businessUnitAuditService.selectListByWhere("where businessid='"+indexWorkId+"' ");
				for (BusinessUnitAudit businessUnitAudit : list_audit) {
					businessUnitRecord = new BusinessUnitRecord(businessUnitAudit);
					businessUnitRecords.add(businessUnitRecord);
                }
				break;
			default:
				break;
			}
        }
		//展示最新任务是否签收
		String processId = indexWork.getProcessid();
		List<HistoricTaskInstance> list=this.workflowService.getHistoryService() // 历史相关Service
	            .createHistoricTaskInstanceQuery() // 创建历史任务实例查询
	            .processInstanceId(processId) // 用流程实例id查询
	            .list(); 
		for (HistoricTaskInstance task : list) {
			if (task.getAssignee()==null || task.getClaimTime()==null) {
	            continue;
            }
			businessUnitRecord = new BusinessUnitRecord(task);
			businessUnitRecords.add(businessUnitRecord);
        }
		Collections.sort(businessUnitRecords, new Comparator<BusinessUnitRecord>() {
            public int compare(BusinessUnitRecord o1, BusinessUnitRecord o2) {
            	SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            	try{
            		Date dt1 = df.parse(o1.getInsdt());
                    Date dt2 = df.parse(o2.getInsdt());
                    if (dt1.getTime() > dt2.getTime()) {
                        return 1;
                    } else if (dt1.getTime() < dt2.getTime()) {
                        return -1;
                    } else {
                        return 0;
                    }
            	}catch(Exception e){
            		e.printStackTrace();
            		return 0;
            	}
            	
            }
        });
		
		JSONArray jsonArray =JSONArray.fromObject(businessUnitRecords);
		model.addAttribute("businessUnitRecords",jsonArray);
		//检测流程实例是否结束，结束则历史记录最后节点变化
		long num =runtimeService.createProcessInstanceQuery().processInstanceId(indexWork.getProcessid()).count();
		if(num>0){
			model.addAttribute("finishFlag", false);
		}else{
			model.addAttribute("finishFlag", true);
		}
		
		if(request.getParameter("inModal")!=null){
            //判断显示在流程处理模态框右侧
            return "administration/indexWorkExecuteViewInModal";
        }else{
            return "administration/indexWorkExecuteView";
        }
	}
	/**
	 * 显示指标审核
	 * */
	@RequestMapping("/showAuditIndexWork.do")
	public String showAuditIndexWork(HttpServletRequest request,Model model){
		String taskId = request.getParameter("taskId");
		String processInstanceId = request.getParameter("processInstanceId");
		BusinessUnitAudit businessUnitAudit=new BusinessUnitAudit();
		
		Task task = this.taskService.createTaskQuery().taskId(taskId).singleResult();
		model.addAttribute("taskName", task.getName());
		
		businessUnitAudit.setId(CommUtil.getUUID());
		businessUnitAudit.setProcessid(processInstanceId);
		businessUnitAudit.setTaskid(taskId);
		ProcessInstance pInstance=runtimeService.createProcessInstanceQuery()
                 .processInstanceId(processInstanceId)
                 .singleResult();
		businessUnitAudit.setBusinessid(pInstance.getBusinessKey());
		businessUnitAudit.setTaskdefinitionkey(task.getTaskDefinitionKey());
		model.addAttribute("businessUnitAudit", businessUnitAudit);
		String indexWorkId= pInstance.getBusinessKey();
		IndexWork indexWork = this.indexWorkService.selectById(indexWorkId);
		model.addAttribute("indexWork", indexWork);
		
		//获取任务下一节点，若为任务节点，则显示目标用户div，否则不显示
		List<ActivityImpl> activityImpls=workflowProcessDefinitionService.getNEXTActivities(task.getProcessDefinitionId(), task.getTaskDefinitionKey());
		if (activityImpls.size()>0) {
			model.addAttribute("showTargetUsersFlag", true);
	    }else{
	    	model.addAttribute("showTargetUsersFlag", false);
	    }
		return "administration/indexWorkAudit";
	}
	/**
	 * 流程流转
	 * */
	@RequestMapping("/AuditIndexWork.do")
	public String doAuditIndexWork(HttpServletRequest request,Model model,
			@ModelAttribute BusinessUnitAudit businessUnitAudit){
		User cu= (User)request.getSession().getAttribute("cu");
		int result=0;
		businessUnitAudit.setInsuser(cu.getId());
		businessUnitAudit.setInsdt(CommUtil.nowDate());
		result =this.indexWorkService.doAudit(businessUnitAudit);
		String resstr="{\"res\":\""+result+"\",\"id\":\""+businessUnitAudit.getId()+"\"}";
		model.addAttribute("result", resstr);
		return "result";
	}
	/**
	 * 显示指标业务处理
	 * */
	@RequestMapping("/showIndexWorkHandle.do")
	public String showIndexWorkHandle(HttpServletRequest request,Model model){
		String taskId = request.getParameter("taskId");
		String processInstanceId = request.getParameter("processInstanceId");
		String unitId = request.getParameter("unitId");
		ProcessInstance pInstance=runtimeService.createProcessInstanceQuery()
                .processInstanceId(processInstanceId)
                .singleResult();
		BusinessUnitHandle businessUnitHandle = new BusinessUnitHandle();
		Task task = this.taskService.createTaskQuery().taskId(taskId).singleResult();
		model.addAttribute("taskName", task.getName());
		List<BusinessUnitHandle> businessUnitHandles = this.businessUnitHandleService.selectListByWhere("where processid='"+processInstanceId+"' and taskId='"+taskId+"'");
		if(businessUnitHandles!= null && businessUnitHandles.size()>0){
			businessUnitHandle = businessUnitHandles.get(0);
			//若任务退回后，需更新新的任务id
			businessUnitHandle.setTaskid(taskId);
		}else{
			businessUnitHandle.setId(CommUtil.getUUID());
			businessUnitHandle.setProcessid(processInstanceId);
			businessUnitHandle.setTaskid(taskId);
			businessUnitHandle.setBusinessid(pInstance.getBusinessKey());
			businessUnitHandle.setTaskdefinitionkey(task.getTaskDefinitionKey());
			businessUnitHandle.setUnitid(unitId);
		}
		String userIds = businessUnitHandle.getTargetusers();
		if(userIds!= null && !userIds.isEmpty()){
			List<User> users = userService.selectListByWhere("where id in('"+userIds.replace(",", "','")+"')");
			String targetUsersName ="";
			for (User user : users) {
	            if(!targetUsersName.isEmpty()){
	            	targetUsersName+=",";
	            }
	            targetUsersName+=user.getCaption();
            }
			model.addAttribute("targetUsersName", targetUsersName);
		}
		
		model.addAttribute("businessUnitHandle", businessUnitHandle);
		model.addAttribute("nowDate", CommUtil.nowDate());
		String indexWorkId = pInstance.getBusinessKey();
		IndexWork indexWork = this.indexWorkService.selectById(indexWorkId);
		List<BusinessUnitAudit> list = this.businessUnitAuditService.selectListByWhere("where businessId = '"+indexWorkId+"' order by insdt desc ");
		if(list!=null && list.size()>0){
	        model.addAttribute("businessUnitAudit", list.get(0));
		}
		model.addAttribute("indexWork", indexWork);
		return "administration/indexWorkHandle";
	}
	/**
	 * 流程流程，指标业务处理提交
	 * */
	@RequestMapping("/submitIndexWorkHandle.do")
	public String dosubmitIndexWorkHandle(HttpServletRequest request,Model model,
			@ModelAttribute BusinessUnitHandle businessUnitHandle){
		String routeNum=request.getParameter("routeNum");
		User cu= (User)request.getSession().getAttribute("cu");
		int result=0;
		if(!this.businessUnitHandleService.checkExit(businessUnitHandle)) {
			businessUnitHandle.setInsuser(cu.getId());
			businessUnitHandle.setInsdt(CommUtil.nowDate());
			result =this.businessUnitHandleService.save(businessUnitHandle);
        }else {
        	result =this.businessUnitHandleService.update(businessUnitHandle);
		}
		try {
			Map<String, Object> variables = new HashMap<String, Object>();
			variables =ActivitiUtil.fixVariableWithRoute(variables, true, routeNum);
			variables.put(CommString.ACTI_KEK_Candidate_Users, businessUnitHandle.getTargetusers());
			variables.put(CommString.ACTI_KEK_Assignee, null);
            taskService.complete(businessUnitHandle.getTaskid(), variables);
            //发送消息
            if(businessUnitHandle.getTargetusers()!=null && !businessUnitHandle.getTargetusers().isEmpty()){
            	//补全所有字段信息
            	businessUnitHandle = businessUnitHandleService.selectById(businessUnitHandle.getId());
            	BusinessUnitRecord businessUnitRecord = new BusinessUnitRecord(businessUnitHandle);
				businessUnitRecord.sendMessage(businessUnitHandle.getTargetusers(),"");
            }
            this.indexWorkService.updateStatus(businessUnitHandle.getBusinessid());
        } catch (Exception e) {
            // TODO: handle exception
        	e.printStackTrace();
        	result=0;
        }
		String resstr="{\"res\":\""+result+"\",\"id\":\""+businessUnitHandle.getId()+"\"}";
		model.addAttribute("result", resstr);
		return "result";
	}
}