package com.bjsxt.oa.managers.impl;

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

import com.bjsxt.oa.managers.AclManager;
import com.bjsxt.oa.model.ACL;
import com.bjsxt.oa.model.Permission;

public class AclManagerImpl extends AbstractManager implements AclManager {

	//授權過程
	public void addOrUpdatePermission(String principalType, int principalSn,
			int resourceSn, int permission, boolean yes) {
		
		//根據主體標識和資源標識查找ACL實例
		ACL acl = findACL(principalType, principalSn, resourceSn);
		
		//如果存在ACL實例，則更新其授權
		if(acl != null){
			acl.setPermission(permission, yes);
			getHibernateTemplate().update(acl);
			return;
		}
		
		//不存在ACL實例，則創建ACL實例
		acl = new ACL();
		acl.setPrincipalType(principalType);
		acl.setPrincipalSn(principalSn);
		acl.setResourceSn(resourceSn);
		acl.setPermission(permission, yes);
		getHibernateTemplate().save(acl);
	}

	//設置用戶某個資源授權的繼承特性
	public void addOrUpdateUserExtends(int userId, int resourceSn, boolean yes) {
		
		//根據主體標識和資源標識查找ACL實例
		ACL acl = findACL(ACL.TYPE_USER, userId, resourceSn); 
		
		//如果存在ACL實例，則更新其授權
		if(acl != null){
			acl.setExtends(yes);
			getHibernateTemplate().update(acl);
			return;
		}
		
		//不存在ACL實例，則創建ACL實例
		acl = new ACL();
		acl.setPrincipalType(ACL.TYPE_USER);
		acl.setPrincipalSn(userId);
		acl.setResourceSn(resourceSn);
		acl.setExtends(yes);
		getHibernateTemplate().save(acl);
	}

	//刪除授權
	public void delPermission(String principalType, int principalSn,
			int resourceSn) {
		getHibernateTemplate().delete(findACL(principalType, principalSn, resourceSn));
	}

	//即時認證
	public boolean hasPermission(int userId, int resourceSn, int permission) {
		
		//查找直接授予用戶的授權
		ACL acl = findACL(ACL.TYPE_USER, userId, resourceSn);
		
		if(acl != null){
			int yesOrNo = acl.getPermission(permission);
			
			//如果是確定的授權
			if(yesOrNo != ACL.ACL_NEUTRAL){
				return yesOrNo == ACL.ACL_YES ? true : false;
			}
		}
		
		//繼續查找用戶的角色授權
		String hql = "select r.id from UsersRoles ur join ur.role r join ur.user u " +
				"where u.id = ? order by ur.orderNo";
		List aclIds = getHibernateTemplate().find(hql, userId);
		
		//依照角色優先級依次查找其授權
		for (Iterator iter = aclIds.iterator(); iter.hasNext();) {
			Integer rid = (Integer) iter.next();
			acl = findACL(ACL.TYPE_ROLE, rid, resourceSn);
			
			//一旦發現授權，即可返回結果
			if(acl != null){
				return acl.getPermission(permission) == ACL.ACL_YES ? true : false;
			}
		}
		
		return false;
	}

	//搜索某個用戶擁有讀取權限的模塊列表（用于登錄，形成導航菜單的時候）
	public List searchModules(int userId) {
		
		//定義臨時變量
		Map temp = new HashMap();
		
		//按優先級從低到高查找用戶擁有的角色
		String hql = "select r.id from UsersRoles ur join ur.role r join ur.user u " +
					"where u.id = ? order by ur.orderNo desc";
		List aclIds = getHibernateTemplate().find(hql, userId);
		
		//依次循環角色
		for (Iterator iter = aclIds.iterator(); iter.hasNext();) {
			Integer rid = (Integer) iter.next();
			
			//根據角色獲得角色擁有的授權列表
			List acls = findRoleACLs(rid);
			
			//把授權放入臨時變量
			for (Iterator iterator = acls.iterator(); iterator.hasNext();) {
				ACL acl = (ACL) iterator.next();
				temp.put(acl.getResourceSn(), acl);
			}
		}
		
		//查找直接授予用戶的授權列表
		List acls = findUserACLs(userId);
		for (Iterator iter = acls.iterator(); iter.hasNext();) {
			ACL acl = (ACL) iter.next();
			temp.put(acl.getResourceSn(), acl);
		}
		
		//現在已獲得用戶擁有的所有授權（包括直接授予用戶自身以及其包含的角色的授權）
		List delResources = new ArrayList();
		Set entries = temp.entrySet();
		for (Iterator iter = entries.iterator(); iter.hasNext();) {
			Map.Entry entry = (Map.Entry) iter.next();
			ACL acl = (ACL)entry.getValue();
			
			//如果沒有讀取權限，則需要在臨時變量中刪除這個授權
			if(acl.getPermission(Permission.READ) == ACL.ACL_NO){
				delResources.add(entry.getKey());
			}
		}
		//在臨時變量中刪除這些需要刪除的授權
		for (Iterator iter = delResources.iterator(); iter.hasNext();) {
			Object key = (Object) iter.next();
			temp.remove(key);
		}
		
		//如果授權列表是空的，則返回0長度的集合
		if(temp.isEmpty()){
			return new ArrayList();
		}
		
		//現在已獲得用戶擁有讀取權限的授權
		String searchModules = "select m from Module m where m.id in (:ids)";
		return getSession().createQuery(searchModules)
				.setParameterList("ids", temp.keySet())
				.list();
	}
	
	//根據主體類型、主體標識和資源標識查找ACL實例
	private ACL findACL(String principalType, int principalSn,
			int resourceSn){
		return (ACL)getSession().createQuery(
				"select acl from ACL acl where acl.principalType = ? " +
				"and acl.principalSn = ? and acl.resourceSn = ?")
				.setParameter(0, principalType)
				.setParameter(1, principalSn)
				.setParameter(2, resourceSn)
				.uniqueResult();
	}
	
	//根據角色查找角色的授權列表，返回列表的元素是：ACL實例
	private List findRoleACLs(int roleId){
		String hql = "select acl from ACL acl where acl.principalType = ? " +
				"and acl.principalSn = ? ";
		return getHibernateTemplate().find(hql,new Object[]{ACL.TYPE_ROLE,roleId}); 
	}
	
	//根據用戶查找直接授予用戶的授權列表（注意：如果直接授予用戶的授權是繼承的話，則不應該包含在這個列表中），返回的列表元素是：ACL實例
	private List findUserACLs(int userId){
		String hql = "select acl from ACL acl where acl.principalType = ? " +
				"and acl.principalSn = ? and acl.aclTriState = 0";		
		return getHibernateTemplate().find(hql, new Object[]{ACL.TYPE_USER,userId});
	}

}