package cn.ksource.web.facade.impl;

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

import javax.annotation.Resource;

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

import com.sun.org.apache.bcel.internal.generic.NEW;

import cn.ksource.beans.AC_ROLE;
import cn.ksource.beans.AC_ROLE_GROUP;
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.JsonUtil;
import cn.ksource.core.util.StringUtil;
import cn.ksource.web.Constants;
import cn.ksource.web.facade.JsglFacade;
import cn.ksource.web.service.UserService;

@Service("jsglFacade")
public class JsglFacadeImpl implements JsglFacade {


	@Resource(name="baseDao")
	private BaseDao baseDao;
	
	@Autowired
	private UserService userService;
	

	public void onQxInRoleSubmit(String[] yjgnbhs, String[] ejgnbhs, String[] sjgnbhs, String[] sijgnbhs, String roleid) {
		baseDao.execute("delete from AC_ROLE_QX where JSBH=:JSBH", new SqlParameter("JSBH",roleid));
		List<SqlParameter> paramList = new ArrayList<SqlParameter>();
		String sql = "insert into AC_ROLE_QX (ID,JSBH,GNBH) values(:ID,:JSBH,:GNBH)";
		if (yjgnbhs != null) {
			for (String gnbh : yjgnbhs) {
				paramList.add(new SqlParameter("ID",StringUtil.getUUID())
					.addValue("JSBH", roleid)
					.addValue("GNBH", gnbh)
				);
			}
		}
		if (ejgnbhs != null) {
			for (String gnbh : ejgnbhs) {
				paramList.add(new SqlParameter("ID",StringUtil.getUUID())
					.addValue("JSBH", roleid)
					.addValue("GNBH", gnbh)
				);
			}
		}
		if (sjgnbhs != null) {
			for (String gnbh : sjgnbhs) {
				paramList.add(new SqlParameter("ID",StringUtil.getUUID())
					.addValue("JSBH", roleid)
					.addValue("GNBH", gnbh)
				);
			}
		}
		if (sijgnbhs != null) {
			for (String gnbh : sijgnbhs) {
				paramList.add(new SqlParameter("ID",StringUtil.getUUID())
					.addValue("JSBH", roleid)
					.addValue("GNBH", gnbh)
				);
			}
		}
		baseDao.executeBatch(sql, paramList);
		
		/*updateRolePermission(roleid);*/
		
	}

	/*private void updateRolePermission(String roleid) {
		//更新该角色下所有人员权限
		List<Map> userList = baseDao.queryForList("select YHBH from AC_USER_REF_ROLE where JSBH=:roleid",new SqlParameter("roleid",roleid));
		for (Map map : userList) {
			userService.updateUserPermission(map.get("YHBH").toString());
		}
	}*/

	public void onUserInRoleSubmit(String[] userids, String roleid) {
		Map param = new HashMap();
		param.put("JSBH", roleid);
		List<Map> userList = baseDao.queryForList("SELECT * FROM AC_USER_REF_ROLE WHERE JSBH =:JSBH",param);
		List<Map> groupList = baseDao.queryForList("SELECT * FROM AC_ROLE_GROUP WHERE JSBH =:JSBH",param);
		Map cacheMap = new HashMap();
		baseDao.execute("delete from AC_USER_REF_ROLE where JSBH =:JSBH", param);
		if (userids != null && userids.length > 0) {
			String sql = "insert into AC_USER_REF_ROLE(ID,JSBH,YHBH) VALUES(:ID,:JSBH,:YHBH)";
			List<SqlParameter> paramList = new ArrayList<SqlParameter>();
			for (String userid : userids) {
				cacheMap.put(userid, userid);
				paramList.add(new SqlParameter("ID",StringUtil.getUUID())
					.addValue("JSBH", roleid)
					.addValue("YHBH", userid)
				);
			}
			baseDao.executeBatch(sql, paramList);
			
			
			//角色去掉的人员，在角色下的分组里禁用
			List<SqlParameter> updparams = new ArrayList<SqlParameter>();
			for(Map map:userList){
				if(!cacheMap.containsKey(map.get("YHBH"))){
					SqlParameter params = new SqlParameter();
					params.put("USER_ID", map.get("YHBH"));
					updparams.add(params);
				}
			}
			if(updparams.size() > 0){
				StringBuilder updsql = new StringBuilder("UPDATE AC_ROLE_GROUP_USER SET STATE = 0 WHERE USER_ID = :USER_ID ");
				if(groupList.size() > 0){
					if(groupList.size() == 1){
						updsql.append(" AND GROUP_ID = ' "+groupList.get(0).get("ID")+"' ");
					}else{
						updsql.append(" AND GROUP_ID IN ( '");
						for(Map map:groupList){
							updsql.append(map.get("ID")+"','");
						}
						updsql.deleteCharAt(updsql.lastIndexOf("'"));
						updsql.deleteCharAt(updsql.lastIndexOf(","));
						updsql.append(")");
					}
					
				}
				baseDao.executeBatch(updsql.toString(), updparams);
			}
			
			/*updateRolePermission(roleid);*/
		}else{
			StringBuilder updsql = new StringBuilder("UPDATE AC_ROLE_GROUP_USER SET STATE = 0 WHERE 1=1 ");
			if(groupList.size() > 0){
				if(groupList.size() == 1){
					updsql.append(" AND GROUP_ID = ' "+groupList.get(0).get("ID")+"' ");
				}else{
					updsql.append(" AND GROUP_ID IN ( '");
					for(Map map:groupList){
						updsql.append(map.get("ID")+"','");
					}
					updsql.deleteCharAt(updsql.lastIndexOf("'"));
					updsql.deleteCharAt(updsql.lastIndexOf(","));
					updsql.append(")");
				}
				
			}
			baseDao.execute(updsql.toString(), new HashMap());
		}
	}

	public int deleteRole(String roleid) {
		new AC_ROLE(roleid).deleteById();
		/*updateRolePermission(roleid);*/
		return 1;
	}

	@Override
	public void execExtend(String[] indexs, String[] ids, String[] sxhs, String[] datavalues, String extendid,String[] ables) {
		
		baseDao.execute("delete from Extend_Columns_Values where EXTENDID=:EXTENDID", new SqlParameter("EXTENDID",extendid));
		
		String sql = "insert into Extend_Columns_Values(ID,EXTENDID,LISTVALUES,SXH,USINGSTATE) values(:ID,:EXTENDID,:LISTVALUES,:SXH,:USINGSTATE)";
		
		List<SqlParameter> paramList = new ArrayList<SqlParameter>();
		
		for (int i = 0; i < indexs.length; i++) {
			if (StringUtils.isBlank(datavalues[i])) {
				continue;
			}
			paramList.add(new SqlParameter("ID",StringUtils.isBlank(ids[i]) ? StringUtil.getUUID() : ids[i])
				.addValue("EXTENDID", extendid)
				.addValue("LISTVALUES", datavalues[i])
				.addValue("SXH", sxhs[i])
				.addValue("USINGSTATE", StringUtils.isBlank(ables[i]) ? "2" : ables[i])
			);
		}
		
		baseDao.executeBatch(sql, paramList);
	}

    @Override
    public void insertConfig(String att, String id) {
        //先删除后修改
        Map paramMap = new HashMap();
        paramMap.put("id",id);
        baseDao.execute("DELETE FROM AC_ROLE_ZHIBIAO WHERE JSBH=:id",paramMap);
        //拷贝
        String[]ids = att.split(",");
        List<SqlParameter> paramList = new ArrayList<SqlParameter>();
        for (String userid : ids) {
            paramList.add(new SqlParameter("ID",StringUtil.getUUID())
                    .addValue("JSBH", id)
                    .addValue("ZBBH", userid)
            );
        }
        baseDao.executeBatch("insert into AC_ROLE_ZHIBIAO(ID,JSBH,ZBBH) VALUES(:ID,:JSBH,:ZBBH)", paramList);
    }
    
    public List<Map> getUserInRoleList(String userid){
		String sql = "SELECT * FROM ac_user_ref_role WHERE YHBH =:userid";
		List<Map> list = baseDao.queryForList(sql,new SqlParameter("userid",userid));
		return list;
	}
	
	public List<Map> getRoleList(){
		String sql =
			"SELECT * from (\n" +
			"SELECT * FROM ac_role WHERE TYPE = 0 \n" +
			"UNION\n" +
			"SELECT * from ac_role  ) r \n" +
			"ORDER BY sxh asc";
		
		 return baseDao.queryForList(sql);
	}
	
	@Override
	public List<Map> getRoleList(Map<String, String> params){
		String sql =
			"SELECT * from (\n" +
			"SELECT * FROM ac_role WHERE TYPE = 0 \n" +
			"UNION\n" +
			"SELECT * from ac_role  ) r \n" +
			"ORDER BY sxh asc";
		
		 List<Map> jsList = baseDao.queryForList(sql);
		 List<Map> groupList = baseDao.queryForList("SELECT * FROM AC_ROLE_GROUP WHERE STATE = 1 ORDER BY SXH ");
		 List<Map> usergroupList = baseDao.queryForList("SELECT * FROM AC_ROLE_GROUP_USER WHERE USER_ID = :userid AND STATE = 1 ",params);
		 Map cacheMap = new HashMap();
		 for(Map map:usergroupList){
			 cacheMap.put(map.get("GROUP_ID"), map);
		 }
		 //选中人员所在的组
		 for(Map map:groupList){
			 if(cacheMap.containsKey(map.get("ID"))){
				 map.put("check", 1);
			 }
		 }
		 for(Map map:jsList){
			 for(Map group:groupList){
				 if(group.get("JSBH").equals(map.get("ID"))){
					 List<Map> groupList2 = (List)map.get("groupList");
					 if(groupList2 == null){
						 groupList2 = new ArrayList<Map>();
					 }
					 groupList2.add(group);
					 map.put("groupList", groupList2);
				 }
			 }
		 }
		 return jsList;
	}
	
	public void onUserInRoleSubmit(String userid,String[] roleids,String[] groupids){
		Map param = new HashMap();
		param.put("yhbh", userid);
		String sql = "delete from AC_USER_REF_ROLE where YHBH=:yhbh";
		baseDao.execute(sql, param);
		
		sql = "insert into AC_USER_REF_ROLE(ID,JSBH,YHBH) VALUES(:ID,:JSBH,:YHBH)";
		List<SqlParameter> paramList = new ArrayList<SqlParameter>();
		if (roleids != null && roleids.length > 0) {
			for (String jsbh : roleids) {
				paramList.add(new SqlParameter("ID",StringUtil.getUUID())
				.addValue("JSBH", jsbh)
				.addValue("YHBH", userid)
				);
			}
			baseDao.executeBatch(sql, paramList);
		}
		//选中/取消组
		if (groupids != null && groupids.length > 0) {
			String sqlgroup = "SELECT * FROM AC_ROLE_GROUP_USER  WHERE USER_ID = :yhbh "; 
			List<Map> groupuserList = baseDao.queryForList(sqlgroup, param);
			List<SqlParameter> addparamList = new ArrayList<SqlParameter>();
			List<SqlParameter> upddelparamList = new ArrayList<SqlParameter>();
			List<SqlParameter> updparamList = new ArrayList<SqlParameter>();
			//人员没有所属组
			if(groupuserList.size() == 0){
				for(int i=0;i<groupids.length;i++){
					SqlParameter addparam = new SqlParameter();
					addparam.put("ID", StringUtil.getUUID());
					addparam.put("GROUP_ID", groupids[i]);
					addparam.put("USER_ID", userid);
					addparam.put("STATE", 1);
					addparamList.add(addparam);
				}
			}else{
				Map cacheMap = new HashMap();
				Map usercacheMap = new HashMap();
				for(Map map:groupuserList){
					cacheMap.put(map.get("GROUP_ID"), map);
				}
				for(int i=0;i<groupids.length;i++){
					usercacheMap.put(groupids[i], groupids[i]);
				}
				for(int i=0;i<groupids.length;i++){
					SqlParameter addparam = new SqlParameter();
					//新增组
					if(!cacheMap.containsKey(groupids[i])){
						addparam.put("ID", StringUtil.getUUID());
						addparam.put("GROUP_ID", groupids[i]);
						addparam.put("USER_ID", userid);
						addparam.put("STATE", 1);
						addparamList.add(addparam);
					}else{
						//组状态更新为正常
						Map user = (Map)cacheMap.get(groupids[i]);
						if(ConvertUtil.obj2Integer(user.get("STATE"))==0){
							addparam.put("ID", user.get("ID"));
							updparamList.add(addparam);
						}
					}
				}
				for(Map map:groupuserList){
					SqlParameter upsparam = new SqlParameter();
					//组状态更新为禁用
					if(!usercacheMap.containsKey(map.get("GROUP_ID"))){
						if(ConvertUtil.obj2Integer(map.get("STATE"))==1){
							upsparam.put("ID", map.get("ID"));
							upddelparamList.add(upsparam);
						}
					}
				}
			}
			baseDao.executeBatch("INSERT INTO AC_ROLE_GROUP_USER(ID,USER_ID,GROUP_ID,STATE) VALUES(:ID,:USER_ID,:GROUP_ID,:STATE);", addparamList);
			baseDao.executeBatch("UPDATE AC_ROLE_GROUP_USER SET STATE = 0 WHERE ID = :ID", upddelparamList);
			baseDao.executeBatch("UPDATE AC_ROLE_GROUP_USER SET STATE = 1 WHERE ID = :ID", updparamList);
		}else{
			baseDao.execute("UPDATE AC_ROLE_GROUP_USER SET STATE = 0 WHERE USER_ID = :yhbh", param);
		}
		
		//userService.updateUserPermission(userid);
	}

	@Override
	public int jsCount(Map<String, String> params) {
		int count = baseDao.queryForInteger("SELECT COUNT(ID) FROM AC_ROLE ");
		return count;
	}

	@Override
	public PageInfo jsData(PageInfo pageInfo, Map<String, String> params) {
		PageInfo info = baseDao.queryforSplitPageInfo(pageInfo, "SELECT * FROM AC_ROLE ORDER BY SXH ASC", params);
		return info;
	}

	@Override
	public List getRolesByUserId(String userId, Integer defFlag) {
		SqlParameter params = new SqlParameter("userId",userId);
		StringBuilder sql = new StringBuilder();
		if(defFlag==1){
			sql.append(" select a.id,a.identify,a.rolename,b.is_default from ac_role a,ac_user_ref_role b where a.id=b.jsbh and b.yhbh=:userId and a.state=1 and b.is_default=1 ");
			List<Map> list =  baseDao.queryForList(sql.toString(),params);
			if(list!=null&&list.size()==1){
				return list;
			}else{
				sql.setLength(0);
				sql.append(" select a.id,a.identify,a.rolename,b.is_default from ac_role a,ac_user_ref_role b where a.id=b.jsbh and b.yhbh=:userId and a.state=1 ");
				return  baseDao.queryForList(sql.toString(),params);
			}
		}else{
			sql.append(" select a.id,a.identify,a.rolename,b.is_default from ac_role a,ac_user_ref_role b where a.id=b.jsbh and b.yhbh=:userId and a.state=1 ");
			return  baseDao.queryForList(sql.toString(),params);
		}
		
	}

	@Override
	public void setDefaultRole(String userId, String roleId) {
		String sql = "update ac_user_ref_role set is_default=1 where jsbh=:roleId and yhbh=:userId "; 
		SqlParameter params = new SqlParameter().addValue("userId", userId)
										.addValue("roleId", roleId);
		baseDao.execute(sql.toString(), params);
	}

	@Override
	public List<Map> getUsersByRoleKey(String key) {
		StringBuilder sql = new StringBuilder();
		sql.append(" select c.id,c.zsxm name from ac_role a,ac_user_ref_role b,gg_user c ");
		sql.append(" where a.id = b.jsbh and b.yhbh = c.id and a.identify = :key and c.zt = 1");
		return baseDao.queryForList(sql.toString(),new SqlParameter("key",key));
	}

	@Override
	public void updateDefDesk(String userId, String roleId) {
		SqlParameter param = new SqlParameter().addValue("userId", userId).addValue("roleId",roleId);
		StringBuilder sql = new StringBuilder();
		sql.append(" update ac_user_ref_role set is_default=0 where yhbh=:userId "); 
		baseDao.execute(sql.toString(), param);
		sql.setLength(0);
		sql.append(" update ac_user_ref_role set is_default=1 where jsbh=:roleId and yhbh=:userId ");
		baseDao.execute(sql.toString(), param);
	}

	@Override
	public int roleGroupCount(Map<String, String> params) {
		String sql = "SELECT COUNT(ID) FROM AC_ROLE_GROUP WHERE JSBH = :jsbh ";
		return baseDao.queryForInteger(sql, params);
	}

	@Override
	public PageInfo roleGroupData(PageInfo pageInfo, Map<String, String> params) {
		String sql = "SELECT A.* ,COUNT(B.ID) AS NUM FROM AC_ROLE_GROUP A LEFT JOIN AC_ROLE_GROUP_USER B ON A.ID = B.GROUP_ID AND B.STATE =1 WHERE A.JSBH = :jsbh  GROUP BY A.ID ORDER BY A.SXH ";
		return baseDao.queryforSplitPageInfo(pageInfo, sql, params);
	}

	@Override
	public List<Map> getGroupUser(String id) {
		Map param = new HashMap();
		param.put("groupid", id);
		AC_ROLE_GROUP group = new AC_ROLE_GROUP(id).getInstanceById();
		param.put("jsbh", group.getJsbh());
		String sql = "SELECT B.* FROM AC_USER_REF_ROLE A,GG_USER B WHERE A.JSBH = :jsbh AND A.YHBH = B.ID AND B.ZT = 1 "; 
		List<Map> userList = baseDao.queryForList(sql, param);
		String sqlgroup = "SELECT * FROM AC_ROLE_GROUP_USER  WHERE GROUP_ID = :groupid AND STATE = 1 "; 
		List<Map> groupuserList = baseDao.queryForList(sqlgroup, param);
		Map cacheMap = new HashMap();
		for(Map map:groupuserList){
			cacheMap.put(map.get("USER_ID"), map);
		}
		for(Map map:userList){
			if(cacheMap.containsKey(map.get("ID"))){
				map.put("check", 1);
			}
		}
		return userList;
	}

	@Override
	public void updateGroupUser(Map<String, String> params) {
		String userId = params.get("userid");
		if(!StringUtil.isEmpty(userId)){
			
			String[] userIds = userId.split(",");
			String groupid = params.get("groupid");
			if(userIds.length > 0){
				String sqlgroup = "SELECT * FROM AC_ROLE_GROUP_USER  WHERE GROUP_ID = :groupid "; 
				List<Map> groupuserList = baseDao.queryForList(sqlgroup, params);
				List<SqlParameter> addparamList = new ArrayList<SqlParameter>();
				List<SqlParameter> updparamList = new ArrayList<SqlParameter>();
				List<SqlParameter> upddelparamList = new ArrayList<SqlParameter>();
				if(groupuserList.size() == 0){
					for(int i=0;i<userIds.length;i++){
						SqlParameter param = new SqlParameter();
						param.put("ID", StringUtil.getUUID());
						param.put("GROUP_ID", groupid);
						param.put("USER_ID", userIds[i]);
						param.put("STATE", 1);
						addparamList.add(param);
					}
				}else{
					Map cacheMap = new HashMap();
					Map usercacheMap = new HashMap();
					for(Map map:groupuserList){
						cacheMap.put(map.get("USER_ID"), map);
					}
					for(int i=0;i<userIds.length;i++){
						usercacheMap.put(userIds[i], userIds[i]);
					}
					for(int i=0;i<userIds.length;i++){
						SqlParameter param = new SqlParameter();
						if(!cacheMap.containsKey(userIds[i])){
							param.put("ID", StringUtil.getUUID());
							param.put("GROUP_ID", groupid);
							param.put("USER_ID", userIds[i]);
							param.put("STATE", 1);
							addparamList.add(param);
						}else{
							Map user = (Map)cacheMap.get(userIds[i]);
							if(ConvertUtil.obj2Integer(user.get("STATE"))==0){
								param.put("ID", user.get("ID"));
								updparamList.add(param);
							}
						}
					}
					for(Map map:groupuserList){
						SqlParameter param = new SqlParameter();
						if(!usercacheMap.containsKey(map.get("USER_ID"))){
							if(ConvertUtil.obj2Integer(map.get("STATE"))==1){
								param.put("ID", map.get("ID"));
								upddelparamList.add(param);
							}
						}
					}
				}
				baseDao.executeBatch("INSERT INTO AC_ROLE_GROUP_USER(ID,USER_ID,GROUP_ID,STATE) VALUES(:ID,:USER_ID,:GROUP_ID,:STATE);", addparamList);
				baseDao.executeBatch("UPDATE AC_ROLE_GROUP_USER SET STATE = 0 WHERE ID = :ID", upddelparamList);
				baseDao.executeBatch("UPDATE AC_ROLE_GROUP_USER SET STATE = 1 WHERE ID = :ID", updparamList);
			}else{
				baseDao.execute("UPDATE AC_ROLE_GROUP_USER SET STATE = 0 WHERE GROUP_ID = :groupid", params);
			}
	    }else{
			baseDao.execute("UPDATE AC_ROLE_GROUP_USER SET STATE = 0 WHERE GROUP_ID = :groupid", params);
		}
	}

	@Override
	public Map getRoleByRoleKey(String key) {
		String sql = "SELECT * FROM AC_ROLE WHERE IDENTIFY = :identify ";
		return baseDao.queryForMap(sql, new SqlParameter("identify",key));
	}

	@Override
	public int deleteGroup(String groupId) {
		Map param = new HashMap();
		param.put("groupId", groupId);
		String sql = "SELECT COUNT(ID) FROM SC_SERVCE_CATEGORY_USER WHERE GROUP_ID = :groupId ";
		int count = baseDao.queryForInteger(sql, param);
		if(count == 0){
			sql = "SELECT COUNT(ID) FROM WORKFLOW_NODE WHERE CURRENT_DEAL_ROLEIDA = :groupId ";
			count = baseDao.queryForInteger(sql, param);
		}
		if(count == 0){
			AC_ROLE_GROUP group = new AC_ROLE_GROUP(groupId);
			group.deleteById();
		}
		return count;
	}

}