package com.ld.igds.sys.service;

import com.bstek.bdf2.core.model.Role;
import com.bstek.bdf2.core.model.RoleMember;
import com.bstek.bdf2.core.model.RoleResource;
import com.bstek.bdf2.core.model.Url;
import com.bstek.bdf2.core.orm.hibernate.HibernateDao;
import com.bstek.bdf2.core.service.IUrlService;
import com.ld.igds.constant.RedisConst;
import com.ld.igds.util.ContextUtil;

import com.ld.igds.util.RedisUtil;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

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

@Repository(SysRoleService.BEAN_ID)
public class SysRoleService extends HibernateDao {

    public static final String BEAN_ID = "sys.RoleService";

    private String CACHE_ROLE_URL = "ROLE_URL";

    private String CACHE_ROLE_USER = "ROLE_USER";

    @Autowired
    private IUrlService urlService;
    @Autowired
    private RedisUtil redisUtil;

    public List<Role> getRolesByUsername(String username) {
        String hql = " from " + Role.class.getName() + " where id in("
                + "select roleId from " + RoleMember.class.getName()
                + " where username=:username)";

        Map<String, Object> args = new HashMap<String, Object>();
        args.put("username", username);
        return this.query(hql, args);
    }

    public Role getRoleByUsername(String username) {
        List<Role> roles = this.getRolesByUsername(username);
        if (null == roles || roles.isEmpty())
            return null;

        return roles.get(0);
    }

    public List<Role> loadRoles(String companyId) {

        String hql = " from " + Role.class.getName()
                + " where companyId=:companyId order by name";

        Map<String, Object> args = new HashMap<>();
        args.put("companyId", companyId);
        return this.query(hql, args);
    }

    public void updateUserRole(String username, String roleId) {
        if (StringUtils.isEmpty(username) || StringUtils.isEmpty(roleId)) {
            return;
        }

        // 删除当前用户的原来均色
        Session session = this.getSessionFactory().openSession();
        try {
            String hql = "delete from " + RoleMember.class.getName()
                    + " where username=:username";
            Query query = session.createQuery(hql);
            query.setString("username", username);
            query.executeUpdate();

            // 执行新增
            RoleMember member = new RoleMember();
            member.setId(ContextUtil.getUUID());
            member.setUsername(username);
            member.setRoleId(roleId);
            member.setCreateDate(new Date());
            member.setGranted(true);

            session.save(member);

        } finally {
            session.flush();
            session.close();
        }

    }

    public String delRole(Role data) {
        if (null == data.getId())
            return null;

        Session session = this.getSessionFactory().openSession();
        try {

            // 删除角色
            String hql = " delete from " + Role.class.getName()
                    + " where id = :id";
            Query query = session.createQuery(hql);
            query.setString("id", data.getId());
            query.executeUpdate();

            // 删除角色成员
            hql = " delete from " + RoleMember.class.getName()
                    + " where roleId = :id";
            query = session.createQuery(hql);
            query.setString("id", data.getId());
            query.executeUpdate();

            // 删除角色资源
            hql = " delete from " + RoleResource.class.getName()
                    + " where roleId = :id";
            query = session.createQuery(hql);
            query.setString("id", data.getId());
            query.executeUpdate();

        } finally {
            session.flush();
            session.close();
        }

        return null;
    }

    public void updateRole(Role data) {

        Session session = this.getSessionFactory().openSession();
        try {
            if (null == data.getCompanyId()) {
                data.setCompanyId(ContextUtil.getCompanyId());

                session.save(data);
            } else {
                session.update(data);
            }

        } finally {
            session.flush();
            session.close();
        }

    }

    public List<Url> loadUrls(String companyId, String parentId, String roleId) {

        // 已经分配的菜单
        List<Url> allUrls = urlService.loadUrlsByRoleId(roleId);

        String hql = "from " + Url.class.getName()
                + " u where u.companyId=:companyId";
        Map<String, Object> parameterMap = new HashMap<String, Object>();
        parameterMap.put("companyId", companyId);
        hql += " and u.parentId=:parentId order by u.order asc";
        parameterMap.put("parentId", parentId);
        List<Url> urls = this.query(hql, parameterMap);

        for (Url url : urls) {
            url.setUse(this.checkUse(url, allUrls));
        }
        return urls;
    }

    public List<Url> loadUrls(String companyId, String roleId) {

        // 已经分配的菜单
        List<Url> allUrls = urlService.loadUrlsByRoleId(roleId);

        String hql = "from " + Url.class.getName()
                + " u where u.companyId=:companyId";
        Map<String, Object> parameterMap = new HashMap<String, Object>();
        parameterMap.put("companyId", companyId);
        hql += " and u.parentId is null order by u.order asc";
        List<Url> urls = this.query(hql, parameterMap);

        for (Url url : urls) {
            url.setUse(this.checkUse(url, allUrls));
        }
        return urls;
    }

    private boolean checkUse(Url url, List<Url> allUrls) {
        if (null == allUrls || allUrls.isEmpty())
            return false;
        for (Url roleUrl : allUrls) {
            if (url.getId().equals(roleUrl.getId())) {
                return true;
            }
        }
        return false;
    }

    /**
     * 根据组织编码更新缓存
     *
     * @param companyId
     */
    public List<RoleResource> updateCacheRoleUrl(String companyId) {
        String hql = "from " + RoleResource.class.getName();

        List<RoleResource> resources = this.query(hql);

        if (null == resources || resources.isEmpty()) {
            redisUtil.del(RedisConst.buildKey(companyId, CACHE_ROLE_URL));
        } else {
            redisUtil.set(RedisConst.buildKey(companyId, CACHE_ROLE_URL), resources);
        }
        return resources;
    }


    /**
     * 根据用户获取当前用户所拥有的角色下的菜单信息
     * @param companyId
     * @param userName
     * @return
     */
    public Map<String, String> getMapUrlByUser(String companyId, String userName) {
        List<RoleResource> resources = (List<RoleResource>) redisUtil.get(RedisConst.buildKey(companyId, CACHE_ROLE_URL));

        if (null == resources || resources.isEmpty()) return null;

        String roleId = (String) redisUtil.get(RedisConst.buildKey(CACHE_ROLE_USER, userName));
        if (StringUtils.isEmpty(roleId)) return null;

        Map<String, String> result = new HashMap<>();
        for (RoleResource roleUrl : resources) {
            if (roleUrl.getRoleId().equals(roleId)) result.put(roleUrl.getUrlId(), roleUrl.getRoleId());
        }

        return result;
    }

    public void updateCacheRoleUser(String companyId) {
        String hql = "from " + RoleMember.class.getName();
        List<RoleMember> resources = this.query(hql);
        if (null == resources || resources.isEmpty()) return;

        String key;
        for (RoleMember roleUser : resources) {
            key = RedisConst.buildKey(CACHE_ROLE_USER, roleUser.getUsername());
            redisUtil.set(key, roleUser.getRoleId());
        }
    }
}