package com.nis.web.service.basics;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
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.nis.domain.FunctionServiceDict;
import com.nis.domain.Page;
import com.nis.domain.basics.AsnGroupInfo;
import com.nis.domain.configuration.AsnKeywordCfg;
import com.nis.domain.maat.GroupReuseAddBean;
import com.nis.domain.maat.GroupReuseCfg;
import com.nis.domain.maat.MaatCfg;
import com.nis.domain.maat.ToMaatBean;
import com.nis.domain.maat.ToMaatResult;
import com.nis.domain.specific.ConfigGroupInfo;
import com.nis.exceptions.MaatConvertException;
import com.nis.util.ConfigServiceUtil;
import com.nis.util.Constants;
import com.nis.util.DictUtils;
import com.nis.util.StringUtil;
import com.nis.web.dao.basics.AsnGroupInfoDao;
import com.nis.web.dao.basics.AsnIpCfgDao;
import com.nis.web.dao.configuration.StringCfgDao;
import com.nis.web.dao.specific.ConfigGroupInfoDao;
import com.nis.web.security.UserUtils;
import com.nis.web.service.BaseService;

import jersey.repackaged.com.google.common.collect.Maps;

@Service
public class AsnGroupInfoService extends BaseService{
	
	@Autowired
    private AsnGroupInfoDao asnGroupInfoDao;
	@Autowired
	private ConfigGroupInfoDao configGroupInfoDao;
	@Autowired
	private AsnIpCfgDao asnIpCfgDao;
	
	/**
	 * @param page
	 * @param entity
	 * @return
	 */
	public Page<AsnGroupInfo> findAsnGroupInfoList(Page<AsnGroupInfo> page, AsnGroupInfo entity) {
		entity.getSqlMap().put("dsf", configScopeFilter(entity.getCurrentUser(),"r"));
		entity.setPage(page);
		List<AsnGroupInfo> list=asnGroupInfoDao.findAsnGroupInfoList(entity);
		page.setList(list);
		return page;
	}
	
	public AsnGroupInfo getById(int id) {
		AsnGroupInfo AsnGroupInfo=asnGroupInfoDao.getById(id);
		return AsnGroupInfo;
	}
	public List<AsnGroupInfo> getByOrg(String org) {
		List<AsnGroupInfo> AsnGroupInfos=asnGroupInfoDao.getConfigGroupInfoByName(org);
		return AsnGroupInfos;
	}
	
	@Transactional(readOnly=false,rollbackFor=RuntimeException.class)
	public void saveOrUpdate(AsnGroupInfo entity) throws MaatConvertException{
		//asn类型从综合服务获取groupId
		String org=entity.getOrganization().trim().toUpperCase();
		String country=entity.getCountry().trim().toUpperCase();
		entity.setOrganization(org);
		entity.setCountry(country);
		int groupId=0;
		//获取组织
		ConfigGroupInfo configGroupInfo=configGroupInfoDao.getAsnGroupByName(org);
		
		if(configGroupInfo==null) {
			List<Integer> groupIds= ConfigServiceUtil.getId(2,2);
			if(groupIds.size()>0) {
				groupId=groupIds.get(0).intValue();
			}else {
				throw new MaatConvertException("Get asn group id failed");
			}
			configGroupInfo=new ConfigGroupInfo();
			configGroupInfo.setGroupName(org.toUpperCase());
			configGroupInfo.setIsIssued(0);
			configGroupInfo.setGroupType(4);
			configGroupInfo.setIsAuditAll(0);
			configGroupInfo.setIsUsed(0);
			configGroupInfo.setGroupId(groupIds.get(1));
			configGroupInfo.setInsertTime(new Date());
			configGroupInfoDao.insertConfigGroupInfo(configGroupInfo);
		}else {
			List<Integer> groupIds= ConfigServiceUtil.getId(2,1);
			if(groupIds.size()>0) {
				groupId=groupIds.get(0).intValue();
			}else {
				throw new MaatConvertException("Get asn group id failed");
			}
			
		}
		//新增
		if(entity.getGroupId()==null){
			Date createTime=new Date();
			entity.setCreatorId(UserUtils.getUser().getId());
			entity.setCreateTime(createTime);
			entity.setGroupId(groupId);
			entity.setIsValid(0);
			//分组已被策略设定为下发全部域，则需要自动下发新增的asno
			if(configGroupInfo.getIsAuditAll() != null && configGroupInfo.getIsAuditAll().equals(1)){
				entity.setIsUsed(1);
			}else{
				entity.setIsUsed(0);
			}
			
			List<Integer> compileIds= ConfigServiceUtil.getId(1,1);
			if(compileIds.size()>0) {
				entity.setCompileId(compileIds.get(0));
			}else {
				throw new MaatConvertException("Get asn reigon id failed");
			}
			List<Integer> regionIds= ConfigServiceUtil.getId(3,1);
			if(regionIds.size()>0) {
				entity.setRegionId(regionIds.get(0));
			}else {
				throw new MaatConvertException("Get asn reigon id failed");
			}
			asnGroupInfoDao.insert(entity);
			//新增，需要判断组是否被标记为全量下发，如果标记则下发新增的，没有不下发
			if(configGroupInfo.getIsAuditAll() != null 
					&& configGroupInfo.getIsAuditAll().equals(1) 
					&& configGroupInfo.getIsUsed()!= null
					&& configGroupInfo.getIsUsed().equals(1)){
				auditAsn(entity,configGroupInfo,Constants.OPACTION_POST);
			}
		//修改
		}else{
			long id=entity.getId();
			AsnGroupInfo group=asnGroupInfoDao.getById(id);
			int count=asnGroupInfoDao.getCountGroupInfoByName(group.getOrganization());
			if(count==1&&!group.getOrganization().equalsIgnoreCase(entity.getOrganization())) {
				configGroupInfoDao.delAsnGroup(group.getOrganization());
			}
			ConfigGroupInfo configGroupInfo1=configGroupInfoDao.getAsnGroupByName(entity.getOrganization());
			if(configGroupInfo1==null) {
				List<Integer> groupIds= ConfigServiceUtil.getId(2,2);
				if(groupIds.size()>0) {
					groupId=groupIds.get(0).intValue();
				}else {
					throw new MaatConvertException("Get asn group id failed");
				}
				configGroupInfo1=new ConfigGroupInfo();
				configGroupInfo1.setGroupName(entity.getOrganization().toUpperCase());
				configGroupInfo1.setIsIssued(0);
				configGroupInfo1.setGroupType(4);
				configGroupInfo1.setIsUsed(0);
				configGroupInfo1.setIsAuditAll(0);
				configGroupInfo1.setGroupId(groupIds.get(1));
				configGroupInfo1.setInsertTime(new Date());
				configGroupInfoDao.insertConfigGroupInfo(configGroupInfo1);
			}
			Date editTime=new Date();
			entity.setEditorId(UserUtils.getUser().getId());
			entity.setEditTime(editTime);
			entity.setGroupId(groupId);
			asnGroupInfoDao.update(entity);
			asnIpCfgDao.updateAsn(String.valueOf(entity.getAsnId()),entity.getOrganization(),entity.getCountry(),entity.getDetail());
			if(configGroupInfo1.getIsUsed()!= null
					&& configGroupInfo1.getIsUsed().equals(1)){
				group.setGroupId(groupId);
				group.setAsnId(entity.getAsnId());
				auditAsn(group,configGroupInfo1,Constants.OPACTION_PUT);
			}
		}
		
		
		
	}
	public void auditAsn(AsnGroupInfo entity,ConfigGroupInfo group,Integer action){
		Map<Integer, List<AsnKeywordCfg>> srcMap=new HashMap<>();
		List srcList=new ArrayList<>();
		AsnKeywordCfg cfg=new AsnKeywordCfg();
		cfg.initDefaultValue();
		cfg.setGroupId(group.getGroupId());
		cfg.setCfgKeywords(entity.getAsnId().toString());
		cfg.setRegionId(entity.getRegionId());
		cfg.setCfgType(Constants.NTC_ASN_NUMBER);
		cfg.setAuditTime(new Date());
		srcList.add(cfg);
		srcMap.put(group.getGroupId(), srcList);
		GroupReuseAddBean commonGroupBean=new GroupReuseAddBean();
		List<GroupReuseCfg> commonGroupList=new ArrayList<>();
		commonGroupList=convertCommonRegion(srcMap,commonGroupList,1,2,4);
		commonGroupBean.setGroupReuseCfgList(commonGroupList);
		//如果已经被引用，则修改
		commonGroupBean.setAuditTime(new Date());
		commonGroupBean.setCreatorName(UserUtils.getUser().getName());
		commonGroupBean.setVersion(Constants.MAAT_VERSION);
		if(entity.getIsUsed() != null && entity.getIsUsed().equals(1)){ //已经被引用过的asn可调用修改region
			commonGroupBean.setOpAction(action);
			String json = gsonToJson(commonGroupBean);
			logger.info("ASN配置下发配置参数：" + json);
			// 调用服务接口下发配置
			ToMaatResult result = ConfigServiceUtil.auditCommonGroupRegionSources(json, action);
		}else{//已经被引用过的asn可调用新增region
			commonGroupBean.setOpAction(action);
			String json = gsonToJson(commonGroupBean);
			logger.info("ASN配置下发配置参数：" + json);
			// 调用服务接口下发配
			ToMaatResult result = ConfigServiceUtil.auditCommonGroupRegionSources(json, action);
		}
		
	}
	@Transactional(readOnly=false,rollbackFor=RuntimeException.class)
	public void delete(String ids,String asnIds){
		
		if(!StringUtil.isEmpty(ids)){
			List<GroupReuseCfg> commonGroupList=new ArrayList<>();
			//查询已经被策略引用的asn
			List<AsnGroupInfo> asnList=asnGroupInfoDao.findAsnGroupInfoByAsnNos(Arrays.asList(asnIds.split(",")), 1);
			//修改asn为无效，且解除引用
			asnGroupInfoDao.updateIsUsedAndIsValid(Arrays.asList(asnIds.split(",")), 0, -1);
			//删除asn下的所有asn IP
			asnIpCfgDao.deleteByAsnId(asnIds);
			
			//查询已经被策略引用的asn，需要走取消接口
			if(!StringUtil.isEmpty(asnList)){
				Map<Integer, List<AsnKeywordCfg>> srcMap=new HashMap<>();
				Map<String, Integer> groupIdMap=new HashMap<>();
				for (AsnGroupInfo asnGroupInfo : asnList) {
					//查询groupId
					if(StringUtil.isEmpty(groupIdMap.get(asnGroupInfo.getOrganization()))){
						ConfigGroupInfo group=configGroupInfoDao.getAsnGroupByName(asnGroupInfo.getOrganization());
						groupIdMap.put(asnGroupInfo.getOrganization(), group.getGroupId());
						List<AsnKeywordCfg> list1=new ArrayList<>();
						AsnKeywordCfg asnCfg=new AsnKeywordCfg();
						asnCfg.initDefaultValue();
						asnCfg.setCfgType(Constants.NTC_ASN_NUMBER);
						asnCfg.setRegionId(asnGroupInfo.getRegionId());
						asnCfg.setGroupId(group.getGroupId());
						asnCfg.setIsValid(0);
						list1.add(asnCfg);
						srcMap.put(group.getGroupId(), list1);
					}else{
						Integer groupId=groupIdMap.get(asnGroupInfo.getOrganization());
						List list2=srcMap.get(groupId);
						AsnKeywordCfg asnCfg=new AsnKeywordCfg();
						asnCfg.initDefaultValue();
						asnCfg.setCfgType(Constants.NTC_ASN_NUMBER);
						asnCfg.setRegionId(asnGroupInfo.getRegionId());
						asnCfg.setGroupId(groupId);
						asnCfg.setIsValid(0);
						list2.add(asnCfg);
						srcMap.put(groupId, list2);
					}
				}
				commonGroupList=convertCommonRegion(srcMap, commonGroupList, 0, 2,4);
				GroupReuseAddBean commonGroupBean=new GroupReuseAddBean();
				commonGroupBean.setGroupReuseCfgList(commonGroupList);
				commonGroupBean.setAuditTime(new Date());
				commonGroupBean.setCreatorName(UserUtils.getUser().getName());
				commonGroupBean.setVersion(Constants.MAAT_VERSION);
				commonGroupBean.setOpAction(2);
				String json = gsonToJson(commonGroupBean);
				logger.info("ASN配置下发配置参数：" + json);
				// 调用服务接口下发配置
				ToMaatResult result = ConfigServiceUtil.auditCommonGroupRegionSources(json, 3);
			}
		}
			
			
		/*List<FunctionServiceDict> dicts=DictUtils.getFunctionServiceDictList(600);
		int result=0;
		do {
			result=asnIpCfgDao.deleteByAsnId(asnIds);
		}while(result>0);
		for (String id : ids.split(",")) {
			if(!StringUtil.isEmpty(id)){
				AsnGroupInfo entity=asnGroupInfoDao.getById(Integer.parseInt(id));
				int valid=entity.getIsValid();
				entity.setIsValid(-1);
				entity.setId(Long.parseLong(id));
				asnGroupInfoDao.updateValid(entity);
				if(asnGroupInfoDao.getCountGroupInfoByName(entity.getOrganization())==0) {
					configGroupInfoDao.delAsnGroup(entity.getOrganization());
				}
				//取消下发过的编译
				if(valid==1) {
					ToMaatBean maatBean = new ToMaatBean();		
					MaatCfg maatCfg = new MaatCfg();
					List<MaatCfg> configCompileList = new ArrayList();
					maatCfg.setCompileId(entity.getCompileId());
					maatCfg.setServiceId(dicts.get(0).getServiceId());
					maatCfg.setIsValid(0);//无效
					configCompileList.add(maatCfg);
					maatBean.setConfigCompileList(configCompileList);
					maatBean.setAuditTime(entity.getAuditTime());
					maatBean.setCreatorName(entity.getCurrentUser().getName());
					maatBean.setVersion(Constants.MAAT_VERSION);
					maatBean.setOpAction(Constants.UPDATE_ACTION);
					//调用服务接口取消配置
					String json=gsonToJson(maatBean);
					logger.info("asn ip配置取消配置参数："+json);
					//调用服务接口下发配置
					ToMaatResult _result = ConfigServiceUtil.put(json,1);
					logger.info("asn ip配置取消配置响应信息："+_result.getMsg());
				}
			}
		}
		
	}*/
		
	}
	public boolean checkIps(String groupIds) {
		for(String groupId:groupIds.split(",")) {
			Integer.parseInt(groupId);
		}
		List<Integer> hasIpList=asnIpCfgDao.hasASNIds(groupIds);
		if(hasIpList!=null&&hasIpList.size()>0) {
			return true;
		}
		return false;
	}
	public boolean checkIpAddrs(String groupIds) {
		StringBuffer buffer=new StringBuffer();
		for(String groupId:groupIds.split(",")) {
			Integer.parseInt(groupId);
			buffer.append("'AS"+groupId+"',");
		}
		List<Integer> hasIpList=asnIpCfgDao.hasASNIpAddrs(buffer.substring(0, buffer.toString().length()-1));
		if(hasIpList!=null&&hasIpList.size()>0) {
			return true;
		}
		return false;
	}
	
	public AsnGroupInfo getInfoByAsnNo(AsnGroupInfo AsnGroupInfo){
		return asnGroupInfoDao.getInfoByAsnNo(AsnGroupInfo);
	}
	
	public Integer getGroupIdByOrganization(String groupName){
		return asnGroupInfoDao.getGroupIdByOrganization(groupName);
	}
	
	public AsnGroupInfo getGroupInfo(AsnGroupInfo AsnGroupInfo){
		return asnGroupInfoDao.getGroupInfo(AsnGroupInfo);
	}

	public AsnGroupInfo getGroupIdByNameAndASNId(String organization,String country,Long asnId) {
		return asnGroupInfoDao.getGroupIdByNameAndASNId(organization,country,asnId);
	}
	public Map<Long,AsnGroupInfo> getGroupList() {
		Map<Long,AsnGroupInfo> map=Maps.newConcurrentMap();
		for(AsnGroupInfo info:asnGroupInfoDao.findAsnGroupInfos()) {
			map.put(info.getAsnId(), info);
		}
		return map;
	}
	public List<AsnGroupInfo> findAsnGroupList(AsnGroupInfo asnGroupInfo){
		List<AsnGroupInfo> list=asnGroupInfoDao.findAsnGroupInfoByAsnGroup(asnGroupInfo);
		return list;
	}
	public List<AsnGroupInfo> findAsnGroupList(List<String> asnNos,Integer isUsed){
		List<AsnGroupInfo> list=asnGroupInfoDao.findAsnGroupInfoByAsnNos(asnNos,null );
		return list;
	}
	
}