package cn.ksource.web.facade.xtpz.sjzd;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cn.ksource.beans.CONFIG_DATA_DICTIONARY;
import cn.ksource.beans.CONFIG_DATA_DICTIONARY_CATEGORY;
import cn.ksource.beans.CONFIG_DATA_INTERFACE;
import cn.ksource.beans.CONFIG_DATA_MESSAGE;
import cn.ksource.beans.CONFIG_DATA_SUBSYSTEM;
import cn.ksource.beans.GG_USER;
import cn.ksource.core.config.ConfigConstants;
import cn.ksource.core.dao.BaseDao;
import cn.ksource.core.dao.SqlParameter;
import cn.ksource.core.page.PageInfo;
import cn.ksource.core.util.ConvertUtil;
import cn.ksource.core.util.EqualUtil;
import cn.ksource.core.util.JsonUtil;
import cn.ksource.core.util.StringUtil;
import cn.ksource.core.web.TreeNode;
import cn.ksource.core.web.WebUtil;
import cn.ksource.web.Constants;
import cn.ksource.web.service.AreaService;
import cn.ksource.web.service.DataDictionaryService;

@Service("sjzdFacade")
public class SjzdFacadeImpl implements SjzdFacade {

	@Autowired
	private BaseDao baseDao;
	
	@Autowired
	private AreaService areaService;
	
	@Autowired
	private DataDictionaryService dataDictionaryService;

	@Override
	public List<Map> getSubSystemList() {
		String sql = "select * from CONFIG_DATA_SUBSYSTEM";
		return baseDao.queryForList(sql);
	}

	@Override
	public Map getSubSystemInfo(String id) {
		if (StringUtils.isBlank(id)) {
			return new HashMap();
		}
		return baseDao.queryForMap("select * from CONFIG_DATA_SUBSYSTEM where id=:id",new SqlParameter("id",id));
	}

	@Override
	public boolean addOrUpdateSubSystem(CONFIG_DATA_SUBSYSTEM subsystem) {
		if (isSubSystemExists(subsystem.getSystemkey(), subsystem.getId())) {
			return false;
		}
		subsystem.setSystemname(ConfigConstants.getSub_System_Label(subsystem.getSystemkey()));
		if (StringUtils.isBlank(subsystem.getId())) {
			subsystem.insert();
		} else {
			subsystem.update();
		}
		
		dataDictionaryService.updateSubSystemUrl(subsystem.getSystemkey());
		return true;
	}

	private boolean isSubSystemExists(String key,String id) {
		String sql = "select count(*) from CONFIG_DATA_SUBSYSTEM where SYSTEMKEY=:SYSTEMKEY";
		if (StringUtils.isNotBlank(id)) {
			sql += " and id != :id";
		}
		int count = baseDao.queryForInteger(sql,new SqlParameter("SYSTEMKEY",key).addValue("id", id));
		if (count >0) {
			return true;
		}
		return false;
	}

	@Override
	public boolean delSubSystem(String id) {
		CONFIG_DATA_SUBSYSTEM system =  new CONFIG_DATA_SUBSYSTEM(id).getInstanceById();
		dataDictionaryService.updateSubSystemUrl(system.getSystemkey());
		system.deleteById();
		return true;
	}
	
	private Object getType(Object type){
		Map map = new HashMap();
		map.put("1", "查询类");
		map.put("2", "修改类");
		map.put("3", "查询修改类");
		return map.get(ConvertUtil.obj2Str(type));    
	}

	@Override
	public List<Map> getJiekouList(Map<String, String> paramMap) {
		String sql = "select CONFIG_DATA_INTERFACE.*,CONFIG_DATA_SUBSYSTEM.SYSTEMNAME,CONFIG_DATA_SUBSYSTEM.URL " +
				"from CONFIG_DATA_INTERFACE,CONFIG_DATA_SUBSYSTEM where " +
				"CONFIG_DATA_INTERFACE.SYSTEMID=CONFIG_DATA_SUBSYSTEM.ID ";
		
		String system_id = paramMap.get("system_id");
		String interfacename = paramMap.get("interfacename");
		String interfacekey = paramMap.get("interfacekey");
		String interfaceurl = paramMap.get("interfaceurl");
		
		if (StringUtils.isNotBlank(paramMap.get("system_id"))) {
			sql +=  "and SYSTEMID=:SYSTEMID";
		}
		
		if (StringUtils.isNotBlank(interfacename)) {
			sql += " and interfacename like '%"+ interfacename.replaceAll("\\s", "%") +"%'";
		}
		if (StringUtils.isNotBlank(interfacekey)) {
			sql += " and interfacekey like '%"+ interfacekey.replaceAll("\\s", "%") +"%'";
		}
		if (StringUtils.isNotBlank(interfaceurl)) {
			sql += " and interfaceurl like '%"+ interfaceurl.replaceAll("\\s", "%") +"%'";
		}
		
		List<Map> list = baseDao.queryForList(sql,new SqlParameter("SYSTEMID",system_id));
		
		for (Map map : list) {
			map.put("MYTYPE", getType(map.get("TYPE")));
		}
		
		return list;
	}
	
	public List<Map> getMessageList(Map<String, String> paramMap){
		String sql = "select * from CONFIG_DATA_MESSAGE where 1=1  ";

		String message_name = paramMap.get("message_name");
		String interfacekey = paramMap.get("interfacekey");
		String message_key = paramMap.get("message_key");
		
		if (StringUtils.isNotBlank(message_name)) {
			sql += " and message_name like '%"+ message_name.replaceAll("\\s", "%") +"%'";
		}
		if (StringUtils.isNotBlank(interfacekey)) {
			sql += " and interfacekey like '%"+ interfacekey.replaceAll("\\s", "%") +"%'";
		}
		if (StringUtils.isNotBlank(message_key)) {
			sql += " and message_key like '%"+ message_key.replaceAll("\\s", "%") +"%'";
		}
		List<Map> list = baseDao.queryForList(sql,new SqlParameter());
		
		return list;
	}

	@Override
	public Map getJiekouInfo(String id) {
		String sql = "select * from CONFIG_DATA_INTERFACE where id=:id";
		return baseDao.queryForMap(sql,new SqlParameter("id",id));
	}
	
	public Map getMessageInfo(String id){
		String sql = "select * from CONFIG_DATA_MESSAGE where id=:id";
		return baseDao.queryForMap(sql,new SqlParameter("id",id));
	}
	
	public Map getSjzdflInfo(String id){
		String sql = "select * from CONFIG_DATA_DICTIONARY_CATEGORY where id=:id";
		return baseDao.queryForMap(sql,new SqlParameter("id",id));
	}
	
	public Map getDataInfo(String id){
		String sql = "select * from CONFIG_DATA_DICTIONARY where id=:id";
		return baseDao.queryForMap(sql,new SqlParameter("id",id));
	}

	@Override
	public Map getSubSystemMapUsing() {
		String sql = "select * from CONFIG_DATA_SUBSYSTEM";
		List<Map> list = baseDao.queryForList(sql);
		Map result = new HashMap();
		for (Map map : list) {
			result.put(map.get("ID"), ConfigConstants.getSub_System_Label(map.get("SYSTEMKEY").toString()));
		}
		return result;
	}

	@Override
	public boolean isJiekouExists(String id,String key) {
		String sql = "select count(*) from CONFIG_DATA_INTERFACE where INTERFACEKEY=:INTERFACEKEY";
		if (StringUtils.isNotBlank(id)) {
			sql +=" and id != :id";
		}
		int count = baseDao.queryForInteger(sql,new SqlParameter("INTERFACEKEY",key).addValue("id", id));
		if (count > 0) {
			return true;
		}
		return false;
	}
	public boolean isMessageExists(String id,String key){
		String sql = "select count(*) from CONFIG_DATA_MESSAGE where MESSAGE_KEY=:MESSAGE_KEY";
		if (StringUtils.isNotBlank(id)) {
			sql +=" and id != :id";
		}
		int count = baseDao.queryForInteger(sql,new SqlParameter("MESSAGE_KEY",key).addValue("id", id));
		if (count > 0) {
			return true;
		}
		return false;
	}
	
	public boolean isSjzdflExists(String id,String key){
		String sql = "select count(*) from CONFIG_DATA_DICTIONARY_CATEGORY where CATEGORYKEY=:CATEGORYKEY AND USESTATE = 1 ";
		if (StringUtils.isNotBlank(id)) {
			sql +=" and id != :id";
		}
		int count = baseDao.queryForInteger(sql,new SqlParameter("CATEGORYKEY",key).addValue("id", id));
		if (count > 0) {
			return true;
		}
		return false;
	}
	
	public boolean isDataExists(String id,String key){
		String sql = "select count(*) from CONFIG_DATA_DICTIONARY where DATAKEY=:DATAKEY";
		if (StringUtils.isNotBlank(id)) {
			sql +=" and id != :id";
		}
		int count = baseDao.queryForInteger(sql,new SqlParameter("DATAKEY",key).addValue("id", id));
		if (count > 0) {
			return true;
		}
		return false;
	}

	@Override
	public boolean addOrUpdateJiekou(CONFIG_DATA_INTERFACE jiekou) {
		
		if (isJiekouExists(jiekou.getId(), jiekou.getInterfacekey())) {
			return false;
		}
		jiekou.insertOrUpdate();
		
		dataDictionaryService.updateInterfaceUrlByKey(jiekou.getInterfacekey());
		
		return true;
	}
	
	public boolean addOrUpdateMessage(CONFIG_DATA_MESSAGE message){
		if (isMessageExists(message.getId(), message.getMessage_key())) {
			return false;
		}
		message.insertOrUpdate();
		
		dataDictionaryService.updateInterfaceUrlByMessageKey(message.getMessage_key());
		
		return true;
	}
	
	public boolean addOrUpdateSjzdfl(CONFIG_DATA_DICTIONARY_CATEGORY category){
		if (isSjzdflExists(category.getId(), category.getCategorykey())) {
			return false;
		}
		  if (EqualUtil.isStringEqual(category.getParentid(), "0")||StringUtil.isEmpty(category.getParentid())) {
			  category.setParentid(null);
		  }
		category.setUsestate(1);
		category.insertOrUpdate();
		
		dataDictionaryService.updateDataDictionaryByCategoryKey(category.getCategorykey());
		
		return true;
	}
	
	public boolean addOrUpdateData(CONFIG_DATA_DICTIONARY dic){
		if (isDataExists(dic.getId(), dic.getDatakey())) {
			return false;
		}
		dic.setUsestate(1);
		dic.insertOrUpdate();
		dataDictionaryService.updateDataDictionaryByKey(dic.getDatakey());
		return true;
	}

	@Override
	public boolean delJiekou(String id) {
		CONFIG_DATA_INTERFACE inteConfig_data_interface = new CONFIG_DATA_INTERFACE(id).getInstanceById();
		dataDictionaryService.updateInterfaceUrlByKey(inteConfig_data_interface.getInterfacekey());
		inteConfig_data_interface.deleteById();
		return true;
	}
	
	public boolean delMessage(String id){
		CONFIG_DATA_MESSAGE message = new CONFIG_DATA_MESSAGE(id).getInstanceById();
		dataDictionaryService.updateInterfaceUrlByMessageKey(message.getMessage_key());
		message.deleteById();
		return true;
	}
	
	@Override
	public boolean deleteSjzdfl(String id){
		CONFIG_DATA_DICTIONARY_CATEGORY cate = new CONFIG_DATA_DICTIONARY_CATEGORY(id).getInstanceById();
		dataDictionaryService.updateDataDictionaryByCategoryKey(cate.getCategorykey());
		cate.setUsestate(2).update();
		return true;
	}
	public boolean delData(String id){
		CONFIG_DATA_DICTIONARY data = new CONFIG_DATA_DICTIONARY(id).getInstanceById();
		dataDictionaryService.updateDataDictionaryByKey(data.getDatakey());
		data.setUsestate(2).update();
		return true;
	}
	
	public TreeNode getSjzdflTree(String parentid){
		
		TreeNode root = new TreeNode("0","数据字典");
		String sql = "select * from CONFIG_DATA_DICTIONARY_CATEGORY where USESTATE=1";
		
		if (StringUtils.isBlank(parentid) || StringUtils.equalsIgnoreCase(parentid, "0")) {
			sql += "  and parentid is null";
		} else {
			sql += "  and parentid=:parentid";
		}
		sql += "  order by ORDERNUM asc";
		
		List<Map> xtgnList = baseDao.queryForList(sql, new SqlParameter("parentid",parentid));
		Map<String, TreeNode> yjgnCache = new HashMap<String, TreeNode>();
		
		for (Map map : xtgnList) {
			TreeNode yjTree = new TreeNode(map.get("ID").toString(),
					map.get("CATEGORYNAME")+"["+map.get("CATEGORYKEY")+"]");
			yjTree.setIsOpen(true);
			root.addChild(yjTree);
			yjgnCache.put(ConvertUtil.obj2Str(map.get("ID")), yjTree);
		}
		return root;
	}
	
	public TreeNode getDataTree(String parentid){
		TreeNode root = new TreeNode("0","数据字典");
		String sql = "select * from CONFIG_DATA_DICTIONARY_CATEGORY where USESTATE=1";
		
		boolean isOpen = false;
		
		if (StringUtils.isBlank(parentid) || StringUtils.equalsIgnoreCase(parentid, "0")) {
			sql += "  and parentid is null";
		} else {
			sql += "  and parentid=:parentid";
			isOpen = true;
		}
		sql += "  order by ORDERNUM asc";
		
		List<Map> xtgnList = baseDao.queryForList(sql, new SqlParameter("parentid",parentid));
		
		for (Map map : xtgnList) {
			TreeNode yjTree = new TreeNode(map.get("ID").toString(),
					map.get("CATEGORYNAME")+"["+map.get("CATEGORYKEY")+"]");
			yjTree.setIsOpen(isOpen);
			if (isOpen) {
				Map attr = new HashMap();
				attr.put("ISNODE", "1");
				yjTree.setAttributes(attr);
			}
			root.addChild(yjTree);
		}
		return root;
	}

	@Override
	public List<Map> getSjzdflList(String flid) {
		String sql = "select * from CONFIG_DATA_DICTIONARY_CATEGORY where  USESTATE=1";
		if (StringUtils.isBlank(flid) || EqualUtil.isStringEqual(flid, "0")) {
			sql += " and PARENTID is null ";
		} else {
			sql += "  and  PARENTID=:PARENTID ";
		}
		sql += " order by ORDERNUM";
		List<Map> list = baseDao.queryForList(sql,new SqlParameter("PARENTID",flid));
		return list;
	}
	
	public List<Map> getDataList(String flid){
		String sql = "select * from CONFIG_DATA_DICTIONARY where  USESTATE=1";
		if (StringUtils.isBlank(flid) || EqualUtil.isStringEqual(flid, "0")) {
			sql += " and CATEGORYID is null ";
		} else {
			sql += "  and  CATEGORYID=:CATEGORYID ";
		}
		sql += " order by ORDERNUM";
		List<Map> list = baseDao.queryForList(sql,new SqlParameter("CATEGORYID",flid));
		return list;
	}
	
	
	public String getAreaTree(String pid){
		TreeNode node = areaService.getAreaTreeNode(pid);
		if (StringUtils.isBlank(pid)) {
			System.out.println(node.toJson());
			return node.toJson();
		} else {
			System.out.println(node.getChildrenNodesForJson());
			return node.getChildrenNodesForJson();
		}
	}
	public void onArea_manager_configSubmit(HttpServletRequest request){
		String ids = request.getParameter("areaids");
		String type = request.getParameter("type");    
		String area_manager_id = request.getParameter("area_manager_id");
		String area_manager_id_TEXT = request.getParameter("area_manager_id_TEXT");
		if (StringUtils.isNotBlank(ids)) {
			String delSql = "delete from CRM_SALES_AREA where COUNTY_ID in ('" + ids.replaceAll(",", "','") +"')";
			baseDao.execute(delSql, new SqlParameter());
			ids = StringUtils.removeEnd(ids, ",");
			List<SqlParameter> paramList = new ArrayList<SqlParameter>();
			String[] idsArray = ids.split(",");
			String insertSql = "insert into CRM_SALES_AREA (ID,COUNTY_ID,TYPE,AREA_MANAGER_ID,AREA_MANAGER_NAME) " +
					"	VALUES(:ID,:COUNTY_ID,:TYPE,:AREA_MANAGER_ID,:AREA_MANAGER_NAME)";
			for (String id : idsArray) {
				paramList.add(new SqlParameter("ID",StringUtil.getUUID())
					.addValue("COUNTY_ID", id)
					.addValue("TYPE", type).addValue("AREA_MANAGER_ID", area_manager_id).addValue("AREA_MANAGER_NAME", area_manager_id_TEXT)
				);
			}
			baseDao.executeBatch(insertSql, paramList);
		}
	}

	@Override
	public List<Map> getSjzdflList(HttpServletRequest request) {
		String sql = "SELECT * FROM CONFIG_DATA_DICTIONARY_CATEGORY WHERE PARENTID IS NULL AND USESTATE=1 ORDER BY ORDERNUM";
		List<Map> bms = baseDao.queryForList(sql);
		return bms;
	}

	@Override
	public List<Map> sjzdflData(HttpServletRequest request) {
		Map paramMap = new HashMap();
		String pId = request.getParameter("pId");
		StringBuilder builder = new StringBuilder(" SELECT * FROM CONFIG_DATA_DICTIONARY_CATEGORY WHERE USESTATE=1 ");
		if(StringUtil.notEmpty(pId)) {
			builder.append(" AND PARENTID = :pId ");
			paramMap.put("pId", pId);
		} else {
			builder.append(" AND PARENTID IS NULL ");
		}
		
		builder.append(" ORDER BY ORDERNUM");
		
		List<Map> bms = baseDao.queryForList(builder.toString(),paramMap);
		return bms;
	}

	/**
	 * 查询数据字典树形结构
	 */
	@Override
	public List querySjzdTree(HttpServletRequest request) {
		
		Map paramMap = new HashMap();
		
		StringBuilder builder = new StringBuilder("SELECT * FROM CONFIG_DATA_DICTIONARY_CATEGORY WHERE  USESTATE=1 ORDER BY PARENTID,ORDERNUM ASC");
		
		List<Map> trees = baseDao.queryForList(builder.toString(),paramMap);
		

		List<Map> resultList = new LinkedList<Map>();
		
		Map<String, Map> yjgnCache = new HashMap<String, Map>();
		
		for (Map map : trees) {
			
			String treeId = ConvertUtil.obj2StrBlank(map.get("ID"));
			String parentId = ConvertUtil.obj2StrBlank(map.get("PARENTID"));
			
			//一级树
			if (!StringUtil.notEmpty(parentId)) {
				yjgnCache.put(treeId, map);
				List<Map> ejgnList = new LinkedList<Map>();
				map.put("ejTree", ejgnList);
				resultList.add(map);
				continue;
			}
			//二级树
			String pId = map.get("PARENTID").toString();
			if(yjgnCache.containsKey(pId)) {
				Map yjgnMap = yjgnCache.get(pId);
				List<Map> list = (List<Map>)yjgnMap.get("ejTree");
				map.put("sjTree", new LinkedList<Map>());
				list.add(map);
			}
		}
		
		System.out.println(JsonUtil.list2Json(resultList));
		return resultList;
	}

	@Override
	public PageInfo querySjzdData(PageInfo pageInfo,String categoryId) {
		StringBuilder sql = new StringBuilder();
		sql.append("SELECT D.* FROM CONFIG_DATA_DICTIONARY D  ");
		SqlParameter param = new SqlParameter();
		
		sql.append(" INNER JOIN  CONFIG_DATA_DICTIONARY_CATEGORY C");
		sql.append(" ON D.CATEGORYID=C.ID WHERE 1=1 ");
		
		
		if(StringUtil.notEmpty(categoryId)) {
			sql.append(" AND D.CATEGORYID=:categoryid ");
			param.addValue("categoryid",categoryId);
		} else {
			sql.append(" AND D.CATEGORYID IS NULL ");
		}
	
		sql.append(" ORDER BY D.ORDERNUM");
		return baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), param);
	}

	@Override
	public int querySjzdCount(String categoryId) {
		StringBuilder sql = new StringBuilder();
		sql.append("SELECT COUNT(D.ID) FROM CONFIG_DATA_DICTIONARY D  ");
		SqlParameter param = new SqlParameter();
		
		sql.append(" INNER JOIN  CONFIG_DATA_DICTIONARY_CATEGORY C");
		sql.append(" ON D.CATEGORYID=C.ID WHERE 1=1 ");
		
		
		if(StringUtil.notEmpty(categoryId)) {
			sql.append(" AND D.CATEGORYID=:categoryid ");
			param.addValue("categoryid",categoryId);
		} else {
			sql.append(" AND D.CATEGORYID IS NULL ");
		}
	
		return baseDao.queryForInteger(sql.toString(), param);
	}

	
	@Override
	public String sjzdExists(HttpServletRequest request) {
		StringBuilder builder = new StringBuilder("SELECT COUNT(ID) FROM CONFIG_DATA_DICTIONARY WHERE CATEGORYID = :cateId AND DATAKEY = :datakey ");
		String datakey = request.getParameter("val");
		String cateId = request.getParameter("cateId");
		Map paramMap = new HashMap();
		paramMap.put("datakey", datakey);
		paramMap.put("cateId", cateId);
		String id = request.getParameter("id");
		if(StringUtil.notEmpty(id)) {
			builder.append(" AND ID != :id ");
			paramMap.put("id", id);
		}
		
		int count = baseDao.queryForInteger(builder.toString(),paramMap);
		
		if(count>0) {
			return "1";
		}
		return "0";
	}

	@Override
	public String addSjzd(HttpServletRequest request) {
		String categoryid = request.getParameter("cateId");
		String datakey = request.getParameter("datakey");
		String datavalue = request.getParameter("datavalue");
		String beiz = request.getParameter("beiz");
		String ordernum = request.getParameter("ordernum");
		
		String insertSql = "INSERT INTO CONFIG_DATA_DICTIONARY (ID,CATEGORYID,DATAKEY,DATAVALUE,BEIZ,ORDERNUM,USESTATE) VALUES (:id,:categoryid,:datakey,:datavalue,:beiz,:ordernum,1)";
		
		Map paramMap = new HashMap();
		paramMap.put("id", StringUtil.getUUID());
		paramMap.put("categoryid", categoryid);
		paramMap.put("datakey", datakey);
		paramMap.put("datavalue", datavalue);
		paramMap.put("beiz", beiz);
		paramMap.put("ordernum", ordernum);
		
		baseDao.execute(insertSql, paramMap);
		
		return "0";
	}

	@Override
	public boolean deleteData(String id, String state) {
		CONFIG_DATA_DICTIONARY data = new CONFIG_DATA_DICTIONARY(id).getInstanceById();
		dataDictionaryService.updateDataDictionaryByKey(data.getDatakey());
		data.setUsestate(ConvertUtil.obj2Integer(state)).update();
		return true;
	}

	@Override
	public int sjzdflCount(String pId) {
		Map paramMap = new HashMap();
		StringBuilder builder = new StringBuilder(" SELECT COUNT(ID) FROM CONFIG_DATA_DICTIONARY_CATEGORY WHERE USESTATE=1 ");
		if(StringUtil.notEmpty(pId)) {
			builder.append(" AND PARENTID = :pId ");
			paramMap.put("pId", pId);
		} else {
			builder.append(" AND PARENTID IS NULL ");
		}
		
		
		return baseDao.queryForInteger(builder.toString(), paramMap);
	}

	@Override
	public PageInfo sjzdflData(PageInfo pageInfo, HttpServletRequest request) {
		SqlParameter paramMap=new SqlParameter();
		String pId = request.getParameter("pId");
		StringBuilder builder = new StringBuilder(" SELECT * FROM CONFIG_DATA_DICTIONARY_CATEGORY WHERE USESTATE=1 ");
		if(StringUtil.notEmpty(pId)) {
			builder.append(" AND PARENTID = :pId ");
			paramMap.put("pId", pId);
		} else {
			builder.append(" AND PARENTID IS NULL ");
		}
		
		builder.append(" ORDER BY ORDERNUM");
		
		return baseDao.queryforSplitPageInfo(pageInfo, builder.toString(), paramMap);
	}


}