package com.vci.server.framework.delegate;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import com.vci.common.log.ServerWithLog4j;
import com.vci.common.utility.ObjectUtility;
import com.vci.corba.common.VCIError;
import com.vci.corba.framework.data.FuncOperationInfo;
import com.vci.corba.common.data.UserEntityInfo;
import com.vci.server.base.delegate.BaseDelegate;
import com.vci.server.framework.funcmng.funcOperation.FuncOperation;
import com.vci.server.framework.funcmng.funcOperation.FuncOperationService;

public class FuncOperationDelegate extends BaseDelegate {
	
	private FuncOperationService service = null;
	
	public FuncOperationDelegate(UserEntityInfo userEntityInfo){
		super(userEntityInfo);
		service = new FuncOperationService(userEntity);
	}
	
	public FuncOperationDelegate(){
		service = new FuncOperationService();
	}
	
	public boolean saveFuncOperation(FuncOperationInfo[] funcOperationInfos) throws VCIError {
		boolean res = true;
		try{
			FuncOperation[] funcOps = new FuncOperation[funcOperationInfos.length];
			for(int i = 0;i < funcOps.length;i++){
				if (StringUtils.isBlank(funcOperationInfos[i].id)) {
					String id = ObjectUtility.getNewObjectID36();
					funcOperationInfos[i].id = id;
				}
				
				funcOps[i] = changeFuncOperationInfoToEntity(funcOperationInfos[i]);
			}
			res = service.saveFuncOperation(funcOps);
		}catch (Exception e) {
			//e.printStackTrace();
			ServerWithLog4j.logger.error(e);
			throw new VCIError("0", new String[0]);
		}
		return res;
	}
	
	public boolean updateFuncOperation(String id, String alias, boolean isSelected) throws VCIError {
		boolean res = true;
		try{
			res = service.updateFuncOperation(id, alias, isSelected);
		}catch (Exception e) {
			//e.printStackTrace();
			ServerWithLog4j.logger.error(e);
			throw new VCIError("0", new String[0]);
		}
		return res;
	}
	
	public boolean deleteFuncOperation(FuncOperationInfo info) throws VCIError {
		boolean res = true;
		try{
			res = service.deleteFuncOperation(changeFuncOperationInfoToEntity(info));
		}catch (Exception e) {
			//e.printStackTrace();
			ServerWithLog4j.logger.error(e);
			throw new VCIError("0", new String[0]);
		}
		return res;
	}
	/**
	 * 获取模块下的操作，如果操作ID为空，则获取模块下的全部操作
	 * @param functionId 模块ID
	 * @param operateId  操作ID
	 * @param onlyIsValid onlyIsValid 参数表示是否仅仅返回是生效的操作 true：是 false ：不是（此时返回模块下全部的操作，仅在定义模块下的操作时需要返回全部的操作，其它情况需要均只需要返回生效的操作） 
	 * @return
	 */
	public FuncOperationInfo[] getFuncOperationByModule(String functionId,String operateId, boolean onlyIsValid) throws VCIError {
		FuncOperationInfo[] infos = null;
		try{
			List<FuncOperation> ls = service.getFuncOperationByModule(functionId, operateId, onlyIsValid);
			infos = new FuncOperationInfo[ls.size()];
			for(int i = 0;i < ls.size();i++){
				infos[i] = changeFuncOperationEntityToInfo(ls.get(i));
			}
		}catch (Exception e) {
			//e.printStackTrace();
			ServerWithLog4j.logger.error(e);
			throw new VCIError("0", new String[0]);
		}
		return infos;
	}
	
	/**
	 * 通过模块ID和操作标识获取挂接关系
	 * @param funcId
	 * @param identify
	 * @return
	 * @throws VCIError
	 */
	public FuncOperationInfo getFuncOperationByIdentify(String funcId,String identify) throws VCIError{
		try{
			FuncOperation funcOperation = service.getFuncOperationByIdentify(funcId, identify);
			return changeFuncOperationEntityToInfo(funcOperation);
		}catch (Exception e) {
			//e.printStackTrace();
			ServerWithLog4j.logger.error(e);
			throw new VCIError("0", new String[0]);
		}
	}
	
	private FuncOperation changeFuncOperationInfoToEntity(FuncOperationInfo info){
		FuncOperation funcOperation = new FuncOperation();
		funcOperation.setId(info.id);
		funcOperation.setFuncoid(info.funcId);
		funcOperation.setNumber(info.number);
		funcOperation.setOperoid(info.operId);
		funcOperation.setOperName(info.operName);
		funcOperation.setOperIndntify(info.operIndentify);
		funcOperation.setOperAlias(info.operAlias);
		funcOperation.setOperDesc(info.operDesc);
		funcOperation.setIsValid(info.isValid);
		return funcOperation;
	}
	
	private FuncOperationInfo changeFuncOperationEntityToInfo(FuncOperation funcOperation){
		FuncOperationInfo info = new FuncOperationInfo();
		info.id = funcOperation.getId() == null ? "":funcOperation.getId();
		info.funcId = funcOperation.getFuncoid() == null ? "":funcOperation.getFuncoid();
		info.number = funcOperation.getNumber();
		info.operId = funcOperation.getOperoid() == null ? "" : funcOperation.getOperoid();
		info.operName = funcOperation.getOperName() == null ? "" : funcOperation.getOperName();
		info.operIndentify = funcOperation.getOperIndntify() == null ? "" : funcOperation.getOperIndntify();
		info.operAlias = funcOperation.getOperAlias() == null ? "" : funcOperation.getOperAlias();
		info.operDesc = funcOperation.getOperDesc() == null ? "" : funcOperation.getOperDesc();
		info.isValid = funcOperation.getIsValid();
		return info;
	}
	/**
	 * 
	 * add by caill
	 * */
	public String saveFunOper(FuncOperationInfo funcOperationInfo) throws VCIError {
		String res = "";
		if (StringUtils.isBlank(funcOperationInfo.id)) {
			String id = ObjectUtility.getNewObjectID36();
			funcOperationInfo.id = id;
		}
		try{
			 res = service.saveFunOper(changeFuncOperationInfoToEntity(funcOperationInfo));
		}catch (Exception e) {
			//e.printStackTrace();
			ServerWithLog4j.logger.error(e);
			throw new VCIError("0", new String[0]);
		}
		return res;
	}
	/**
	 * 保存操作类型
	 * add by caill
	 * */
	public boolean saveFuncOperation2(FuncOperationInfo funcOperationInfo) throws VCIError {
		boolean res = true;
		try{
			/*FuncOperation[] funcOperations = new FuncOperation[funcOperationInfos.length];
			for(int i = 0;i < funcOperationInfos.length;i++){
				String id = ObjectUtility.getNewObjectID36();
				funcOperationInfos[i].id = id;
				funcOperations[i] = changeFuncOperationInfoToEntity(funcOperationInfos[i]);
			}*/
			res = service.saveFuncOperation2(changeFuncOperationInfoToEntity(funcOperationInfo));
		}catch (Exception e) {
			//e.printStackTrace();
			ServerWithLog4j.logger.error(e);
			throw new VCIError("0", new String[0]);
		}
		return res;
	}
	/**
	 * 覆盖操作类型
	 * add by caill
	 * */
	public boolean updateOperation(FuncOperationInfo funcOperationInfo,String dataOperName,String plFuncOid) throws VCIError {
		boolean res = true;
		try{
			
			res = service.updateOperation(changeFuncOperationInfoToEntity(funcOperationInfo),dataOperName,plFuncOid);
		}catch (Exception e) {
			//e.printStackTrace();
			ServerWithLog4j.logger.error(e);
			throw new VCIError("0", new String[0]);
		}
		return res;
	}
	/**
	 * 查询同一模块中是否已经存在同样的操作类型
	 * add by caill
	 * */
	public boolean selSameOper(String dataOperName,String plFuncOid) throws VCIError {
		boolean same = false;
		try{
			
			same = service.selSameOper(dataOperName,plFuncOid);
		}catch (Exception e) {
			//e.printStackTrace();
			ServerWithLog4j.logger.error(e);
			throw new VCIError("0", new String[0]);
		}
		return same;
	}
}