package com.ld.igds.oa.view;

import com.bstek.bdf2.core.model.DefaultDept;
import com.bstek.bdf2.core.model.DefaultUser;
import com.bstek.dorado.annotation.DataProvider;
import com.bstek.dorado.annotation.DataResolver;
import com.bstek.dorado.annotation.Expose;
import com.ld.igds.constant.OrderStatus;
import com.ld.igds.constant.OrderType;
import com.ld.igds.door.dto.DoorAccessParam;
import com.ld.igds.door.service.CoreDoorService;
import com.ld.igds.file.CoreFileService;
import com.ld.igds.models.ApplyOrder;
import com.ld.igds.models.DoorConf;
import com.ld.igds.models.FileInfo;
import com.ld.igds.oa.service.HOrderServiceImpl;
import com.ld.igds.sys.service.SysDeptService;
import com.ld.igds.sys.service.SysUserService;
import com.ld.igds.util.ContextUtil;
import com.ld.igds.warn.service.CoreWarnService;
import com.ld.igds.work.dto.ApplyOrderParam;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 工单管理接口:包含申请及审核
 * 
 * @author: chen
 * @description:
 * @version:
 * @data:2021年7月16日
 *
 */
@Slf4j
@Component
public class OrderPR {

	@Autowired
	private HOrderServiceImpl hOrderService;
	@Autowired
	private CoreDoorService coreDoorService;
	@Autowired
	private SysUserService sysUserService;
	@Autowired
	private CoreWarnService warnService;
	@Autowired
	private CoreFileService fileService;
	@Autowired
	private SysDeptService sysDeptService;

	/*-----------------申请相关----------------*/
	/**
	 * orderPR#getTitle 根据报表类型，获取默认查询信息，比如表头信息等
	 *
	 * @param
	 * @return
	 */
	@DataProvider
	public Map<String, Object> getTitle(Map<String, Object> param) {
		Map<String, Object> result = new HashMap<String, Object>();

		//获取参数中分库编码
		String deptId = (String)param.get("deptId");
		if (StringUtils.isEmpty(deptId)) {
			deptId = ContextUtil.subDeptId(null);
		}
		//获取分库编码对应的分库名称
		String deptName = "";
		DefaultDept dept = sysDeptService.getCacheDept(ContextUtil.getCompanyId(), ContextUtil.subDeptId(null));
		deptName = dept.getName();

		result.put("title", "工单申请表");
		if (StringUtils.isNotEmpty(deptName)) {
			result.put("title", deptName + "工单申请表");
			result.put("deptId", deptId);
		}
		result.put("unit", ContextUtil.getLoginUserCName());
		result.put("timeDesc", DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm"));

		return result;
	}

	/**
	 * orderPR#listApplyOrders 查询登录人的工单申请列表
	 *
	 * @param param
	 */
	@DataProvider
	public List<ApplyOrder> listApplyOrders(Map<String, Object> param) {

		return hOrderService.listApplyOrders(param);
	}

	/**
	 * orderPR#saveApplyOrder
	 *
	 * @param data
	 */
	@DataResolver
	public void saveApplyOrder(ApplyOrder data) {

		//设置门禁类型处理人
		List<DoorConf> list = coreDoorService.getDoorSysConf(ContextUtil.getCompanyId(), ContextUtil.subDeptId(null));
		if(null != list && list.size() > 0){
			DoorConf doorSysConf = list.get(0);
			String str = "";
			if(StringUtils.isNotEmpty(doorSysConf.getAudit1())){
				str += doorSysConf.getAudit1() + ",";
			}
			if(StringUtils.isNotEmpty(doorSysConf.getAudit2())){
				str += doorSysConf.getAudit2() + ",";
			}
			if(StringUtils.isNotEmpty(doorSysConf.getAudit3())){
				str += doorSysConf.getAudit3() + ",";
			}
			data.setConductUser(str);
		}

		//保存数据到数据库
		String orderId =  hOrderService.saveApplyOrder(data);

		// 附件
		List<FileInfo> files = data.getFiles();
		fileService.saveFiles(files, orderId,null);

		//判断处理人不为空，则进行微信推送
		if(StringUtils.isNotEmpty(data.getConductUser())){
			//申请推送微信
			this.pushApply(data);
		}
	}

    /**
     * orderPR#delApplyOrder
     *
     * @param data
     * @return
     */
    @Expose
    public String delApplyOrder(ApplyOrder data) {

        return hOrderService.delApplyOrder(data);
    }

	/*-----------------审核相关----------------*/
	/**
	 * orderPR#listAuditOrders 查询登录人的工单申请列表
	 *
	 * @param param
	 */
	@DataProvider
	public List<ApplyOrder> listAuditOrders(Map<String, Object> param) {
		return hOrderService.listAuditOrders(param);
	}

	/**
     * 审核通过
	 * orderPR#passAuditOrder
	 *
	 * @param data
	 * @return
	 */
	@Expose
	public void passAuditOrder(ApplyOrder data) {
	    //设置通过状态
        data.setStatus(OrderStatus.Status_20.getCode());

		String newToken = "";
		if(OrderType.Type_10.getCode().equals(data.getType())){
			newToken = coreDoorService.getNewToken(null);
			data.setRecord("门禁权限码为：" + newToken);
		}

		hOrderService.auditApplyOrder(data);

		//判断申请单类型，是门禁类型，则新增一条门禁权限信息
		if(OrderType.Type_10.getCode().equals(data.getType())){
			DoorAccessParam param = new DoorAccessParam();
			param.setId(ContextUtil.getTimeId());
			param.setCompanyId(data.getCompanyId());
			param.setDeptId(data.getDeptId());
			param.setDepotId(data.getDepotId());
			param.setUser(data.getApplyUser());
			param.setToken(newToken);
			param.setStart(data.getStart());
			param.setEnd(data.getEnd());
			coreDoorService.addDoorAccess(param);

			//审核推送微信
			this.pushAudit(data, param.getToken());
		}
	}

	/**
     * 审核拒绝
	 * orderPR#rejectAuditOrder
	 *
	 * @param data
	 * @return
	 */
	@Expose
	public void rejectAuditOrder(ApplyOrder data) {
        //设置拒绝状态
        data.setStatus(OrderStatus.Status_30.getCode());

		hOrderService.auditApplyOrder(data);

		//判断申请单类型，是门禁类型，则根据条件删除门禁权限信息
		if(OrderType.Type_10.getCode().equals(data.getType())){
			DoorAccessParam param = new DoorAccessParam();
			param.setCompanyId(data.getCompanyId());
			param.setDeptId(data.getDeptId());
			param.setDepotId(data.getDepotId());
			param.setUser(data.getApplyUserName());
			coreDoorService.delDoorAccess(param);
		}
	}

	/**
     * 审核退回
	 * orderPR#backAuditOrder
	 * 	 *
	 * @param data
	 * @return
	 */
	@Expose
	public void backAuditOrder(ApplyOrder data) {
        //设置退回状态
        data.setStatus(OrderStatus.Status_40.getCode());

		hOrderService.auditApplyOrder(data);
	}

	/**
	 * 门禁申请推送
	 * @param data
	 */
	private void pushApply(ApplyOrder data){

		try{
			String conductUser = data.getConductUser();
			String[] users = conductUser.split(",");
			String phone = "";
			DefaultUser user;
			for (String username : users) {
				if(StringUtils.isNotEmpty(username)){
					user = sysUserService.loadUser(username);
					if(null != user && StringUtils.isNotEmpty(user.getMobile())){
						phone += user.getMobile() + ",";
					}
				}
			}

			//判断推送人电话是否存在
			if(StringUtils.isEmpty(phone)){
				return;
			}

			//推送到微信
			ApplyOrderParam param = new ApplyOrderParam();
			param.setPhone(phone);
			param.setType(OrderType.getMsg(data.getType()) + "工单");

			param.setRecord("来新工单了");
			String info = "有新工单提交，请及时进行处理。" ;

			param.setId(data.getId());
			param.setInfo(info);

			//调用推送接口
			warnService.noticeOrder(param);
		}catch (Exception e){
			log.error("-----后台异常:{}-----", e);
		}
	}

	/**
	 * 门禁审核推送
	 * @param data
	 */
	private void pushAudit(ApplyOrder data, String token){

		try{
			//推送微信
			DefaultUser user = sysUserService.loadUser(data.getApplyUser());
			if(null == user || StringUtils.isEmpty(user.getMobile())){
				return;
			}
			ApplyOrderParam applyOrderParam = new ApplyOrderParam();
			applyOrderParam.setPhone(user.getMobile());
			applyOrderParam.setRecord("您的工单审核已通过");
			applyOrderParam.setId(data.getId());
			applyOrderParam.setType(OrderType.getMsg(data.getType()) + "权限码=" + token);
			String info = "您申请的工单已通过，注意查看！" ;
			applyOrderParam.setInfo(info);

			//调用推送接口
			warnService.noticeOrder(applyOrderParam);
		}catch (Exception e){
			log.error("-----后台异常:{}-----", e);
		}
	}

}