package com.nis.web.service.basics;

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 org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.nis.domain.Page;
import com.nis.domain.basics.CommonGroupInfo;
import com.nis.domain.basics.IpCommCfg;
import com.nis.domain.basics.UrlCommCfg;
import com.nis.exceptions.MaatConvertException;
import com.nis.util.StringUtil;
import com.nis.web.dao.basics.AsnIpCfgDao;
import com.nis.web.dao.basics.CommonGroupManageDao;
import com.nis.web.dao.basics.IpCommGroupCfgDao;
import com.nis.web.dao.basics.UrlCommGroupDao;
import com.nis.web.dao.specific.ConfigGroupInfoDao;
import com.nis.web.security.UserUtils;
import com.nis.web.service.BaseService;
import com.nis.web.service.SpringContextHolder;

@Service
public class CommonGroupManageService extends BaseService{
	
	@Autowired
    private CommonGroupManageDao commonGroupManageDao;
	
	@Autowired
	private ConfigGroupInfoDao configGroupInfoDao;
	
	@Autowired
    private IpCommGroupCfgDao ipCommGroupCfgDao;
	
	@Autowired
	private UrlCommGroupDao urlCommGroupDao;
	 
	@Autowired
	private AsnIpCfgDao asnIpCfgDao;
	
	public Page<CommonGroupInfo> findCommonGroupInfoList(Page<CommonGroupInfo> page, CommonGroupInfo entity) {
		entity.getSqlMap().put("dsf", configScopeFilter(entity.getCurrentUser(),"r"));
		entity.setPage(page);
		List<CommonGroupInfo> list=commonGroupManageDao.findCommonGroupInfoList(entity);
		page.setList(list);
		return page;
	}
	
	public CommonGroupInfo getById(int id) {
		CommonGroupInfo groupInfo=commonGroupManageDao.getById(id);
		return groupInfo;
	}
	
	@Transactional(readOnly=false,rollbackFor=RuntimeException.class)
	public void saveOrUpdate(CommonGroupInfo entity) throws MaatConvertException{
		entity.setIsValid(1);
		//新增
		if(entity.getGroupId()==null){
			Date createTime=new Date();
			entity.setCreatorId(UserUtils.getUser().getId());
			entity.setCreateTime(createTime);
			//asn类型从综合服务获取groupId 非ASN组 不对config_group_info表添加数据
			/*if(4==entity.getGroupType().intValue()) {
				int serviceGroupId=0;
				List<Integer> groupIds= ConfigServiceUtil.getId(2,1);
				if(groupIds.size()>0) {
					serviceGroupId=groupIds.get(0).intValue();
				}else {
					throw new MaatConvertException("Get asn group id failed");
				}
				entity.setServiceGroupId(serviceGroupId);
				//新增协议分组
				ConfigGroupInfo group = configGroupInfoDao.getConfigGroupInfoByGroupId(serviceGroupId);
				if(group==null){
					group = new ConfigGroupInfo();
					group.setGroupId(serviceGroupId);
					group.setGroupName(entity.getGroupName());
					group.setIsIssued(0);
					group.setGroupType(entity.getGroupType());
					group.setAsnId(entity.getAsnNo());
					configGroupInfoDao.insertConfigGroupInfo(group);
//					if(group.getGroupType().intValue()==4) {
//						AsnCacheUtils.put(entity.getAsnNo(), group);
//					}
					
				}
			}*/
			commonGroupManageDao.insert(entity);
		//修改
		}else{
			Date editTime=new Date();
			entity.setEditorId(UserUtils.getUser().getId());
			entity.setEditTime(editTime);
			commonGroupManageDao.update(entity);
		}
	}
	
	@Transactional(readOnly=false,rollbackFor=RuntimeException.class)
	public void deldete(String ids, int isValid){
		//TODO 公共组删除时需检索是否有被对应公共组配置引用，被引用的公共组无法删除
		IpCommGroupCfgService ipGroupCfgService = SpringContextHolder.getBean(IpCommGroupCfgService.class);
		
		CommonGroupInfo entity=new CommonGroupInfo();
		Date editTime=new Date();
		entity.setEditorId(UserUtils.getUser().getId());
		entity.setEditTime(editTime);
		entity.setIsValid(isValid);
		if(!StringUtil.isEmpty(ids)){
			for (String id : ids.split(",")) {
				if(!StringUtil.isEmpty(id)){
					entity.setGroupId(Integer.parseInt(id));
					commonGroupManageDao.update(entity);
				}
			}
		}
	}
	
	// 查询指定类型的分组信息
	public List<CommonGroupInfo> findCommonGroupInfosByType(int type) {
		List<CommonGroupInfo> list=commonGroupManageDao.findCommonGroupInfosByType(type);
		return list;
	}
	
	public List<CommonGroupInfo> findGroupInfoList(String ids) {
		List<CommonGroupInfo> list=commonGroupManageDao.findGroupInfoList(ids);
		return list;
	}
	
	/**
	 * 删除时校验分组是否被引用，未被引用可删除
	 * @param groupIds
	 * @return false未被引用 / true已被引用
	 */
	public boolean checkIsIssued(String groupIds) {
		// 组织格式
		Map<Integer,Set<Integer>> map = new HashMap<Integer,Set<Integer>>();
		for(String str : groupIds.split(",")) {
			Integer id = Integer.valueOf(str.substring(0, str.indexOf("_")));
			Integer type = Integer.valueOf(str.substring(str.indexOf("_")+1));
			if(map.containsKey(type)) {
				Set<Integer> set = map.get(type);
				set.add(id);
				map.put(type, set);
			}else {
				Set<Integer> set = new HashSet<Integer>();
				set.add(id);
				map.put(type, set);
			}
		}
		
		// 根据类型去相应配置查询，若存在被引用的则限制操作
		Set<Integer> keySet = map.keySet();
		for (Integer type : keySet) {
			Set<Integer> set = map.get(type);
			String str = set.toString();
			String ids = str.substring(1, str.indexOf("]"));
			if(type == 5) {
				List<IpCommCfg> list = ipCommGroupCfgDao.getCfgInfoByGroupIds(ids);
				if(list.size() > 0) {
					return true;
				}
			}else if(type == 7) {
				List<UrlCommCfg> list = urlCommGroupDao.getCfgInfoByGroupIds(ids);
				if(list.size() > 0) {
					return true;
				}
			}
		}
		return false;
	}
	
	/*
	public List<PolicyGroupInfo> findPolicyGroupInfos() {
		List<PolicyGroupInfo> list=commonGroupManageDao.findPolicyGroupInfos();
		return list;
	}
	public List<PolicyGroupInfo> findNatPolicyGroups() {
		List<PolicyGroupInfo> list=commonGroupManageDao.findNatPolicyGroups();
		return list;
	}
	public List<PolicyGroupInfo> findPolicyGroupInfosByType(int type) {
		List<PolicyGroupInfo> list=commonGroupManageDao.findPolicyGroupInfosByType(type);
		return list;
	}
	public List<PolicyGroupInfo> findHasIpPolicyGroupInfosByType(int type) {
		List<PolicyGroupInfo> list=commonGroupManageDao.findHasIPPolicyGroupInfosByType(type);
		return list;
	}
	public List<PolicyGroupInfo> findPolicyGroupInfosHasIpRegionByType(int type) {
		List<PolicyGroupInfo> list=commonGroupManageDao.findPolicyGroupInfosByType(type);
		return list;
	}
	
	public boolean checkIps(String groupIds) {
		for(String groupId:groupIds.split(",")) {
			Integer.parseInt(groupId);
		}
		List<Integer> hasIpList=asnIpCfgDao.hasGroupIds(groupIds);
		if(hasIpList!=null&&hasIpList.size()>0) {
			return true;
		}
		return false;
	}
	
	public PolicyGroupInfo getInfoByAsnNo(PolicyGroupInfo policyGroupInfo){
		return commonGroupManageDao.getInfoByAsnNo(policyGroupInfo);
	}
	
	*//**
	 * IP复用配置表单-获取拥有区域信息的策略分组
	 * @param groupType
	 * @return
	 *//*
	public List<PolicyGroupInfo> getHasAreaPolicyGroups(int groupType) {
		return commonGroupManageDao.getHasAreaPolicyGroups(groupType);
	}
	
	public Integer getGroupIdByGroupName(String groupName){
		return commonGroupManageDao.getGroupIdByGroupName(groupName);
	}
	
	public PolicyGroupInfo getGroupInfo(PolicyGroupInfo policyGroupInfo){
		return commonGroupManageDao.getGroupInfo(policyGroupInfo);
	}*/
	
}