package com.fuzamei.service;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.fuzamei.constant.OperationTypeId;
import com.fuzamei.constant.Role;
import com.fuzamei.constant.StatusId;
import com.fuzamei.dao.ContractManagementDao;
import com.fuzamei.entity.ContractRecord;
import com.fuzamei.entity.ContractStatusTracking;
import com.fuzamei.entity.UserDetail;
import com.fuzamei.utils.PageDTO;

@Service
public class ContractManagementService {
	
	@Autowired
	private ContractManagementDao contractManagementDao;

	/**
	 * 
	* @Title: queryContractStatusTracking
	* @Description: TODO(将所有的合同跟踪记录信息全部返还给前端)
	* @param @param map
	* @param @return    设定文件
	* @return PageDTO    返回类型
	* @author ylx
	* @date 2018年1月9日 下午4:15:03
	* @throws
	 */
	public PageDTO queryContractStatusTracking(Map<String, Object> map) {
		PageDTO pageDTO = new PageDTO();
		//分页信息
		List<ContractStatusTracking> list = contractManagementDao.queryContractStatusTracking(map);
		//查询符合map中条件的条数
		int count = contractManagementDao.findAllContractStatusTrackingInformation(map);
		pageDTO.setRows(list);
		pageDTO.setTotal(count);
		return pageDTO;
	}

	/**
	 * 
	* @Title: queryContractRecord
	* @Description: TODO(将某个业务id号下的合同记录表的全部信息返回给Action)
	* @param @param map
	* @param @return    设定文件
	* @return PageDTO    返回类型
	* @author ylx
	* @date 2018年1月9日 下午4:14:20
	* @throws
	 */
	public PageDTO queryContractRecord(Map<String, Object> map) {
		UserDetail userDetail = (UserDetail) map.get("userDetail");
		String roleName = userDetail.getRole_name().get(0);
		PageDTO pageDTO = new PageDTO();
		//分页信息
		List<ContractRecord> list = contractManagementDao.queryContractRecord(map);
		for (ContractRecord contractRecord : list) {
			//获取未确认部门的信息
			String unconfirmed = contractRecord.getUnconfirm_department();
			Integer statusId = contractRecord.getStatus_id();
			//如果状态为已生效或废弃直接置为null
			if(statusId==StatusId.VALID||statusId==StatusId.DUMPED){
				contractRecord.setIfChecked(null);//按钮全部失效
				continue;
			}
			//如果未确认部门里面不包含当前用户的角色信息,说明该用户已经对该信息进行过了确认，因此将按钮置灰
			if(!unconfirmed.contains(roleName)&&statusId==StatusId.INVALID){
				contractRecord.setIfChecked(true);//按钮显示已确认并置灰
			}else{
				contractRecord.setIfChecked(false);//表示确认按钮还存在
			}
		}
		//查询符合map中条件的条数
		int count = contractManagementDao.findAllContractRecordInformation(map);
		pageDTO.setRows(list);
		pageDTO.setTotal(count);
		return pageDTO;
	}

	/**
	 * 
	* @Title: getContractStatusTrackingByBusinessId
	* @Description: TODO(通过业务id获取合同状态跟踪表中的全部详细信息)
	* @param @param businessId
	* @param @return    设定文件
	* @return ContractStatusTracking    返回类型
	* @author ylx
	* @date 2018年1月9日 上午10:33:08
	* @throws
	 */
	public ContractStatusTracking getContractStatusTrackingByBusinessId(Integer businessId) {
		if(businessId==null){
			throw new RuntimeException("业务id不能为空");
		}
		return contractManagementDao.getContractStatusTrackingByBusinessId(businessId);
	}

	/**
	 * 
	* @Title: uploadContractByUser
	* @Description: TODO(上传新合同时，需要在附件表插数据，合同记录表插入一条数据，合同状态跟踪表更新数据，操作记录表插入一条数据)
	* @param @param map    设定文件
	* @return void    返回类型
	* @author ylx
	* @date 2018年1月9日 上午11:56:04
	* @throws
	 */
	@Transactional(rollbackFor=Exception.class)
	public void uploadContractByUser(Map<String, Object> map) {
		long currentTime = System.currentTimeMillis();
		UserDetail userDetail =(UserDetail) map.get("userDetail");
		ContractStatusTracking contractStatusTracking =(ContractStatusTracking) map.get("contractStatusTracking");
		ContractRecord contractRecord =(ContractRecord) map.get("contractRecord");
		Integer contractId = (Integer) map.get("contractId");
		String contractName = (String) map.get("contractName");
		String url = (String) map.get("url");
		Integer version = contractRecord.getVersion()+1;//获取最新的版本信息号，并加1表示当前要插入的合同信息的最新版本号
		String modifyOpinion = (String) map.get("modifyOpinion");
		String hash=(String) map.get("hash");
		//将数据插入到合同记录表contractRecord
		Map<String, Object> mapToContractRecord=new LinkedHashMap<String, Object>();
		mapToContractRecord.put("businessId", contractStatusTracking.getBusiness_id());
		mapToContractRecord.put("contractId", contractId);
		mapToContractRecord.put("contractName", contractName);
		mapToContractRecord.put("version", version);						//版本号写活♥
		mapToContractRecord.put("contractParty", contractStatusTracking.getContract_party());
		mapToContractRecord.put("uploadDepartment", userDetail.getOrganization_name());
		mapToContractRecord.put("uploadPerson", userDetail.getPerson_name());
		mapToContractRecord.put("modifyOpinion", modifyOpinion);			//这个根据前台传过来的进入插入
		//这个按照这个格式【管理人&省分行业务主管部门&省分行法律部】先写死新上传的肯定待审核部门是三个
		mapToContractRecord.put("uncomfirmDepartment", Role.ADMIN+"&"+Role.BUSINESS_CHIEF_DEP_OF_PBB+"&"+Role.LAW_DEP_OF_PBB);
		mapToContractRecord.put("statusId", StatusId.INVALID);						//刚刚提交必定是未生效(19)
		mapToContractRecord.put("commitTime", currentTime);
		mapToContractRecord.put("hash", hash);
		contractManagementDao.insertInformationToContractRecord(mapToContractRecord);
		
		//将数据封装插入到附件表中attachment
		Map<String, Object> mapToAttachment=new LinkedHashMap<String, Object>();
		mapToAttachment.put("attachmentId", contractId);
		mapToAttachment.put("attachmentName", contractName);
		mapToAttachment.put("url", url);
		mapToAttachment.put("userId", userDetail.getUser_id());
		mapToAttachment.put("createTime", currentTime);
		contractManagementDao.insertInformationToAttachment(mapToAttachment);
		
		//将数据插入到操作记录表中operationHistory
		Map<String, Object> mapToOperationHistory=new LinkedHashMap<String, Object>();
		mapToOperationHistory.put("operatorTypeId", OperationTypeId.CONTRACT_UPLOAD);		//operatorTypeId=1004表示【合同上传】
		mapToOperationHistory.put("operatorRole", userDetail.getOrganization_name());		//当前用户的上传部门，写活♥
		mapToOperationHistory.put("operatorAccount", userDetail.getAccount());				//当前操作账号写活♥
		mapToOperationHistory.put("operatorPerson", userDetail.getPerson_name());			//当前操作人先写活♥
		mapToOperationHistory.put("operatorTime", currentTime);								//操作时间为当前操作时间
		mapToOperationHistory.put("hash", "to be calculated from operation");				//如何计算操作的hash值？？？？============================>>待定TODO
		contractManagementDao.insertInformationToOperationHistory(mapToOperationHistory);
		
		//新的合同上传以后,contractStatusTracking的信息也要进行修改(合同换成最新的，更新时间这两项)
		Map<String, Object> mapToContractStatusTracking=new LinkedHashMap<String, Object>();
		mapToContractStatusTracking.put("contractId", contractId);
		mapToContractStatusTracking.put("businessId", contractStatusTracking.getBusiness_id());
		mapToContractStatusTracking.put("updateTime", currentTime);
		contractManagementDao.updateContractStatusTracking(mapToContractStatusTracking);
	}

	/**
	 * 
	* @Title: getLatestContractRecordByBusinessId
	* @Description: TODO(获取最新版本号的合同记录详细信息)
	* @param @param businessId
	* @param @return    设定文件
	* @return ContractRecord    返回类型
	* @author ylx
	* @date 2018年1月9日 上午11:01:42
	* @throws
	 */
	public ContractRecord getLatestContractRecordByBusinessId(Integer businessId) {
		/*if(businessId==null){
			throw new RuntimeException("业务id不能为空");
		}*/
		return contractManagementDao.getLatestContractRecordByBusinessId(businessId);
	}

	/**
	 * 
	* @Title: getCurrentContractRecordByBusinessId
	* @Description: TODO(根据业务id号和版本号确认得到唯一一条合同记录信息)
	* @param @param businessId
	* @param @param version
	* @param @return    设定文件
	* @return ContractRecord    返回类型
	* @author ylx
	* @date 2018年1月9日 下午2:11:53
	* @throws
	 */
	public ContractRecord getCurrentContractRecordByBusinessId(Integer businessId, Integer version) {
		return contractManagementDao.getCurrentContractRecordByBusinessId(businessId,version);
	}

	/**
	 * 
	* @Title: updateContractByUser
	* @Description: TODO(当用户点击确认按钮的时候产生的一系列更新操作)
	* @param @param mapToService    设定文件
	* @return void    返回类型
	* @author ylx
	* @date 2018年1月9日 下午2:12:36
	* @throws
	 */
	@Transactional(rollbackFor=Exception.class)
	public void updateContractByUser(Map<String, Object> map) {
		long currentTime = System.currentTimeMillis();
		UserDetail userDetail = (UserDetail) map.get("userDetail");
		ContractRecord contractRecord = (ContractRecord) map.get("contractRecord");
		String unconfirmed = contractRecord.getUnconfirm_department();
		String currentUserRole = userDetail.getRole_name().get(0);//获取当前用户角色名
		if(!unconfirmed.contains(currentUserRole)){//判断当前用户是否已经确认过
			throw new RuntimeException("您已确认过了");
		}
		unconfirmed = unconfirmed.replace(currentUserRole, "");//将当前角色在字符串中截掉
		Integer businessId = contractRecord.getBusiness_id();
		Integer version = contractRecord.getVersion();
		Integer contractId = contractRecord.getContract_id();//被确认的合同id号，一旦被确认，合同记录跟踪表的合同id号以被确认的那个合同id号为准
		
		if(unconfirmed.contains(Role.ADMIN)||unconfirmed.contains(Role.BUSINESS_CHIEF_DEP_OF_PBB)||unconfirmed.contains(Role.LAW_DEP_OF_PBB)){
			//如果字符串中还含有其它角色信息，那说明其他部门还没有全部确认，该合同的状态信息暂时还不需要进行变动
			//所有部门都还没有全部确认，只要更改待确认部门信息即可
			Map<String, Object> mapToContractRecord=new LinkedHashMap<String, Object>();
			mapToContractRecord.put("businessId", businessId);
			mapToContractRecord.put("version", version);
			mapToContractRecord.put("commitTime", currentTime);//当前的状态更新时间
			mapToContractRecord.put("unconfirmed", unconfirmed);//修改待确认部门
			mapToContractRecord.put("statusId", StatusId.INVALID);//将状态值仍然为未生效【19】
			contractManagementDao.updateContractRecord(mapToContractRecord);
		}else{
			//接下来的操作是所有部门都已经确认的情况下的操作
			Map<String, Object> mapToContractRecord=new LinkedHashMap<String, Object>();
			mapToContractRecord.put("businessId", businessId);
			mapToContractRecord.put("version", version);
			mapToContractRecord.put("commitTime", currentTime);//当前的状态更新时间
			mapToContractRecord.put("unconfirmed", "--");//将待确认部门置为空
			mapToContractRecord.put("statusId", StatusId.VALID);//将状态值改为生效【20】
			contractManagementDao.updateContractRecord(mapToContractRecord);
			
			//当所有部门全部确认了以后，除了被确认的合同记录状态为【生效】该业务id下的其它所有合同记录的状态全部为【作废状态】
			Map<String, Object> mapToOtherContractRecord=new LinkedHashMap<String, Object>();
			mapToOtherContractRecord.put("businessId", businessId);
			mapToOtherContractRecord.put("version", version);
			mapToOtherContractRecord.put("commitTime", currentTime);
			mapToOtherContractRecord.put("statusId", StatusId.DUMPED);//其它所有状态改为【作废】
			contractManagementDao.updateOtherContractRecord(mapToOtherContractRecord);
			
			//总表中的合同状态跟踪表也要进行相应的更新
			Map<String, Object> mapToContractStatusTracking=new LinkedHashMap<String, Object>();
			mapToContractStatusTracking.put("businessId", businessId);
			mapToContractStatusTracking.put("contractId", contractId);
			mapToContractStatusTracking.put("updateTime", currentTime);
			mapToContractStatusTracking.put("statusId", StatusId.CONFIRMED);	//此时所有人都已经确认的情况下将【合同状态跟踪表】状态代码变成已确认【8】
			contractManagementDao.updateContractStatusTrackingStatusAndContractId(mapToContractStatusTracking);//更新合同状态跟踪表中的信息
		}
		
		//将操作记录插入到操作记录表中
		Map<String, Object> mapToOperationHistory=new LinkedHashMap<String, Object>();
		mapToOperationHistory.put("operatorTypeId", OperationTypeId.CONTRACT_CONFIRM);		//operatorTypeId=1005表示【合同确认】
		mapToOperationHistory.put("operatorRole", userDetail.getOrganization_name());		//当前用户的上传部门，写活♥
		mapToOperationHistory.put("operatorAccount", userDetail.getAccount());				//当前操作账号写活♥
		mapToOperationHistory.put("operatorPerson", userDetail.getPerson_name());			//当前操作人先写活♥
		mapToOperationHistory.put("operatorTime", currentTime);								//操作时间为当前操作时间
		mapToOperationHistory.put("hash", "to be calculated from operation");				//如何计算操作的hash值？？？？============================>>待定TODO
		contractManagementDao.insertInformationToOperationHistory(mapToOperationHistory);
	}
}