<?php
/**
 * RightService.class.php
 * 活动权限信息表
 * @author: daijun
 * @copyright: vchangyi.com
 */

namespace Common\Service;

use Common\Common\Department;
use Common\Common\Job;
use Common\Common\Role;
use Common\Common\Tag;
use Common\Common\User;
use Common\Model\RightModel;
use VcySDK\Member;
use VcySDK\Service;

class RightService extends AbstractService
{

    // 构造方法
    public function __construct()
    {
        parent::__construct();
        $this->_d = new RightModel();
    }

    /**
     * 获取参与活动权限（部门、人员、岗位、标签、角色）
     * @author houyingcai
     *
     * @param array $right 参与权限
     *
     * @return array
     */
    public function list_by_right($right)
    {
        $right['uids'] = array_column($right['uids'], 'memID');
        $right['dp_ids'] = array_column($right['dp_ids'], 'dpID');
        $right['job_ids'] = array_column($right['job_ids'], 'jobID');
        $right['role_ids'] = array_column($right['role_ids'], 'roleID');
        $right['tag_ids'] = array_column($right['tag_ids'], 'tagID');

        // 初始化保存人员UID
        $right['uids'] = !empty($right['uids']) ? array_unique($right['uids']) : [];

        // 处理部门
        if (!empty($right['dp_ids'])) {
            // 部门ID去重
            $right['dp_ids'] = !empty($right['dp_ids']) ? array_unique($right['dp_ids']) : [];
        }
        // 处理岗位
        if (!empty($right['job_ids'])) {
            // 岗位ID去重
            $right['job_ids'] = !empty($right['job_ids']) ? array_unique($right['job_ids']) : [];
        }
        // 处理角色
        if (!empty($right['role_ids'])) {
            // 角色ID去重
            $right['role_ids'] = !empty($right['role_ids']) ? array_unique($right['role_ids']) : [];
        }
        // 处理标签
        if (!empty($right['tag_ids'])) {
            // 标签ID去重
            $right['tag_ids'] = !empty($right['tag_ids']) ? array_unique($right['tag_ids']) : [];
        }

        return $right;
    }

    /**
     * 已有权限转为全公司时需要发布消息的人员
     * @author houyingcai
     *
     * @param array $old_list 已有权限
     * @param array $new_list 用户提交的权限
     *
     * @return array
     */
    public function right_to_all($old_list, $new_list)
    {
        $data = [];

        // 格式化数据库中的权限数据
        $old_rights = $this->format_db_data($old_list);
        $old_rights['is_all'] = empty($old_list) ? ActivityService::IS_ALL : 0;

        // 格式化用户提交的权限数据
        $new_rights = $this->format_post_data($new_list);

        // 数据库人员
        $old_uids = $this->list_uids_by_right($old_rights);

        // 当前人员
        $new_uids = $this->list_uids_by_right($new_rights);

        // 需要更新的数据
        $data['update'] = array_intersect($old_uids, $new_uids);

        // 需要新增的数据
        $data['add'] = array_diff($new_uids, $old_uids);

        return $data;
    }

    /**
     * 获取权限表中的人员
     * @author houyingcai
     *
     * @param array $right 权限数据
     *
     * @return array
     */
    public function list_uids_by_right($right)
    {
        $userServ = &User::instance();
        if ($right['is_all'] == ActivityService::IS_ALL) {
            // 获取全部人员
            $result = User::instance()->listBasicByConds([], 1, 1);
            $total = $result['total'];
            $result = User::instance()->listBasicByConds([], 1, $total);
            $uids = array_column($result['list'], 'memUid');

            return $uids;
        }

        // 人员UID
        $uids = isset($right['uids']) ? $right['uids'] : [];

        // 部门
        $dp_ids = [];
        if (isset($right['dp_ids'])) {
            $dp_ids = $right['dp_ids'];
        }

        // 标签
        $tag_ids = $right['tag_ids'];
        if (!empty($tag_ids)) {
            $tag_s = new Tag();
            $tag_list = $tag_s->listUserByTagId($tag_ids, 1, 1000);
            $tag_dp_id = array_filter(array_column($tag_list['list'], 'dpId'));
            $tag_uid = array_filter(array_column($tag_list['list'], 'memUid'));
            $uids = array_merge($uids, (array)$tag_uid);
            $dp_ids = array_merge($dp_ids, (array)$tag_dp_id);
        }

        // 部门ID
        $conds = [];
        $dp_uids = [];
        if (!empty($dp_ids)) {
            $conds['dpIdList'] = $dp_ids;
            $conds['departmentChildrenFlag'] = 1;

            $dp_uids = User::instance()->listAll($conds);
            $dp_uids = array_column($dp_uids, 'memUid');
        }

        // 岗位
        $conds = [];
        $job_uids = [];
        if (!empty($right['job_ids'])) {
            $conds['jobIdList'] = $right['job_ids'];

            $job_uids = User::instance()->listAll($conds);
            $job_uids = array_column($job_uids, 'memUid');
        }

        // 角色
        $conds = [];
        $role_uids = [];
        if (!empty($right['role_ids'])) {
            $conds['roleIdList'] = $right['role_ids'];

            $role_uids = User::instance()->listAll($conds);
            $role_uids = array_column($role_uids, 'memUid');
        }

        // 合并所有uid
        $uids = array_merge($uids, $dp_uids, $job_uids, $role_uids);

        return array_filter(array_unique($uids));
    }

    /**
     * 格式化数据库中的权限数据
     * @author houyingcai
     *
     * @param array $rights 权限数据
     *
     * @return array
     */
    public function format_db_data($rights)
    {
        $data = [];
        // 数据分组
        $data['uids'] = array_filter(array_column($rights, 'uid'));
        $data['dp_ids'] = array_filter(array_column($rights, 'dp_id'));
        $data['job_ids'] = array_filter(array_column($rights, 'job_id'));
        $data['role_ids'] = array_filter(array_column($rights, 'role_id'));
        $data['tag_ids'] = array_filter(array_column($rights, 'tag_id'));

        return $data;
    }

    /**
     * 格式化用户输入的权限数据
     * @author houyingcai
     *
     * @param array $rights 权限数据
     *
     * @return array
     */
    public function format_post_data($rights)
    {
        $data = [];

        foreach ($rights as $k => $v) {
            // 是否是全公司
            if ($k == 'is_all' && ActivityService::IS_ALL == $v) {

                $data[$k] = $v;

                return $data;
            }

            // 过滤空数组
            if (!is_array($v) || empty($v)) {

                continue;
            }

            switch ($k) {
                case 'uids':
                    $data[$k] = array_column($v, 'memID');
                    break;
                case 'dp_ids':
                    $data[$k] = array_column($v, 'dpID');
                    break;
                case 'job_ids':
                    $data[$k] = array_column($v, 'jobID');
                    break;
                case 'role_ids':
                    $data[$k] = array_column($v, 'roleID');
                    break;
                case 'tag_ids':
                    $data[$k] = array_column($v, 'tagID');
                    break;
                default:
                    # code...
                    break;
            }
        }

        return $data;
    }

    /**
     * 比较权限数据，并返回需要新增、删除和更新的数据
     * @author houyingcai
     *
     * @param array $rights_db 数据库中的权限数据
     * @param array $rights_post 用户输入的权限数据
     *
     * @return array
     */
    public function diff_data($rights_db, $rights_post)
    {
        $keys = [
            'uids',
            'dp_ids', /*'tag_ids',*/
            'job_ids',
            'role_ids',
            'tag_ids'
        ];

        $data = [];
        // 遍历所有权限类型
        foreach ($keys as $key) {
            $rights_old = isset($rights_db[$key]) ? $rights_db[$key] : [];
            $rights_new = isset($rights_post[$key]) ? $rights_post[$key] : [];

            // 需要更新的数据
            $data[$key]['update'] = array_intersect($rights_old, $rights_new);

            // 需要删除的数据
            $data[$key]['del'] = array_diff($rights_old, $rights_new);

            // 需要新增的数据
            $data[$key]['add'] = array_diff($rights_new, $rights_old);
        }

        return $data;
    }

    /**
     * 保存权限数据
     * @author houyingcai
     *
     * @param array $conds 权限筛选条件
     * @param array $data 权限数据
     *
     * @return bool
     */
    public function save_data($conds, $data)
    {
        if (!is_array($conds) || empty($conds) || !is_array($data) || empty($data)) {
            return false;
        }

        // 获取活动权限列表
        $list = $this->_d->list_by_conds($conds);
        // 格式化数据库中的权限数据
        $rights_db = $this->format_db_data($list);
        // 格式化用户输入的权限数据
        $rights_post = $this->format_post_data($data);
        // 比较权限数据，并返回需要新增、删除和更新的数据
        $rights = $this->diff_data($rights_db, $rights_post);

        $add_conds = [];
        $insert_data = [];

        foreach ($rights as $k => $v) {
            // 格式化数据库字段
            $db_k = substr($k, 0, -1);
            // 删除数据
            $del_conds = array_filter($v['del']);
            if (!empty($del_conds)) {

                $del_conds = array_merge($conds, [$db_k => $del_conds]);

                $this->_d->delete_by_conds($del_conds);
            }

            // 初始化字段
            $add_conds['uid'] = '';
            $add_conds['dp_id'] = '';
            $add_conds['job_id'] = '';
            $add_conds['role_id'] = '';
            $add_conds['tag_id'] = '';

            foreach ($v['add'] as $obj_id) {
                $add_conds[$db_k] = $obj_id;
                $insert_data[] = array_merge($conds, $add_conds);
            }
        }

        // 批量插入新增数据
        if (!empty($insert_data)) {
            $this->_d->insert_all($insert_data);
        }

        return true;
    }

    /**
     * 获取格式化后的权限数据
     * @author houyingcai
     *
     * @param array $conds 权限筛选条件
     *
     * @return array
     *          + array dp_list   部门信息
     *                    + string dp_id   部门ID
     *                    + string dp_name 部门名称
     *          + array tag_list  标签信息
     *                    + string tag_id   标签ID
     *                    + string tag_name 标签名称
     *          + array user_list 人员信息
     *                    + string uid      用户ID
     *                    + string username 用户姓名
     *                    + string face     头像
     */
    public function get_data($conds)
    {
        $list = $this->list_by_conds($conds);

        $rights_db = $this->format_db_data($list);

        $data = [
            'user_arr' => [],
            'dp_arr' => [],
            'job_arr' => [],
            'role_arr' => [],
            'tag_arr' => [],
        ];

        foreach ($rights_db as $k => $v) {
            switch ($k) {

                // 部门
                case 'dp_ids':
                    if (!empty($v)) {

                        $dpServ = &Department::instance();
                        sort($v);
                        $dps = $dpServ->listById($v);

                        foreach ($dps as $dp) {
                            $data['dp_arr'][] = [
                                'dpID' => $dp['dpId'],
                                'dpName' => $dp['dpName'],
                            ];
                        }
                    }
                    break;

                // 人员
                case 'uids':
                    if (!empty($v)) {

                        $userServ = &User::instance();
                        sort($v);
                        $users = $userServ->listAll(['memUids' => $v]);
                        // 获取被删除的用户信息
                        $this->user_list($users, $v);

                        foreach ($users as $user) {
                            $data['user_arr'][] = [
                                'memID' => $user['memUid'],
                                'memUsername' => $user['memUsername'],
                                'memFace' => $user['memFace'],
                            ];
                        }
                    }
                    break;
                // 岗位
                case 'job_ids':
                    if (!empty($v)) {

                        $jobServ = &Job::instance();
                        sort($v);
                        $jobs = $jobServ->listById($v);

                        foreach ($jobs as $job) {
                            $data['job_arr'][] = [
                                'jobID' => $job['jobId'],
                                'jobName' => $job['jobName'],
                            ];
                        }
                    }
                    break;
                // 角色
                case 'role_ids':
                    if (!empty($v)) {

                        $roleServ = &Role::instance();
                        sort($v);
                        $roles = $roleServ->listById($v);

                        foreach ($roles as $role) {
                            $data['role_arr'][] = [
                                'roleID' => $role['roleId'],
                                'roleName' => $role['roleName'],
                            ];
                        }
                    }
                    break;
                // 标签
                case 'tag_ids':
                    if (!empty($v)) {

                        $tagServ = &Tag::instance();
                        sort($v);
                        $tags = $tagServ->listById($v);

                        foreach ($tags as $tag) {
                            $data['tag_arr'][] = [
                                'tagID' => $tag['tagId'],
                                'tagName' => $tag['tagName'],
                            ];
                        }
                    }
                    break;
                default:
                    # code...
                    break;
            }
        }

        return [$list, $data];
    }

    /**
     * 获取当前用户的标签，部门，岗位，用户ID
     *
     * @param array $user 传入当前用户信息
     *
     * @return array
     */
    public function get_by_right($user = [])
    {
        // 获取用户所在部门ID以及上级部门ID
        $dpIds = $this->get_user_dp_list($user);

        // 获取用户岗位ID
        $job_ids = [];
        if (!empty($user['job']['jobId'])) {
            $job_ids = $user['job']['jobId'];
        }

        // 获取用户角色ID
        $role_ids = [];
        if (!empty($user['role']['roleId'])) {
            $role_ids = $user['role']['roleId'];
        }

        // 获取用户标签ID
        $tagIds = [];
        $tagsInfo = User::instance()->getTagsByUserId($user['memUid']);
        if (!empty($tagsInfo)) {
            $userTagInfo = isset($tagsInfo['userTagList']) ? array_column($tagsInfo['userTagList'], 'tagId') : [];
            $departTagInfo = isset($tagsInfo['departTagList']) ? array_column($tagsInfo['departTagList'], 'tagId') : [];
            $tagIds = array_unique(array_merge($userTagInfo, $departTagInfo));
        }

        return [
            'memID' => $user['memUid'],
            'dpIds' => $dpIds,
            'jobIds' => $job_ids,
            'roleIds' => $role_ids,
            'tagIds' => $tagIds
        ];
    }

    /**
     * 判断权限
     *
     * @param array $right 权限数组
     * @param array $user 单个用户信息数组
     *
     * @return bool
     */
    public function check_get_quit($right = [], $user = [])
    {
        $uid = array_values(array_filter(array_unique(array_column($right, 'uid'))));
        $cd_id = array_values(array_filter(array_unique(array_column($right, 'dp_id'))));
        $job_id = array_values(array_filter(array_unique(array_column($right, 'job_id'))));
        $role_id = array_values(array_filter(array_unique(array_column($right, 'role_id'))));
        $tag_id = array_values(array_filter(array_unique(array_column($right, 'tag_id'))));

        $arr = array_filter(array_merge($uid, $cd_id, $job_id, $role_id, $tag_id));

        // 部门ID
        $qx_list_ids = [];
        if (!empty($cd_id)) {
            // 获取用户所在部门的ID集合
            $qx_list_ids = $this->get_user_dp_list($user);
        }
        // 用户ID
        $qx_list_ids[] = $user['memUid'];

        // 岗位ID
        if (isset($user['job']['jobId'])) {

            $qx_list_ids[] = $user['job']['jobId'];
        }
        // 角色ID
        if (isset($user['role']['roleId'])) {

            $qx_list_ids[] = $user['role']['roleId'];
        }
        // 获取用户标签ID
        $tagIds = [];
        $tagsInfo = User::instance()->getTagsByUserId($user['memUid']);
        if (!empty($tagsInfo)) {
            $userTagInfo = isset($tagsInfo['userTagList']) ? array_column($tagsInfo['userTagList'], 'tagId') : [];
            $departTagInfo = isset($tagsInfo['departTagList']) ? array_column($tagsInfo['departTagList'], 'tagId') : [];
            $tagIds = array_unique(array_merge($userTagInfo, $departTagInfo));
        }
        $qx_list_ids = array_merge($qx_list_ids, $tagIds);

        // 用试卷权限和用户权限集合取交集
        $ids = array_intersect($arr, $qx_list_ids);
        // 如果交集存在，则有权限，否则无权限
        if (!empty($ids)) {

            return true;
        }

        return false;
    }

    /**
     * 获取用户所在部门以及父级部门的ID集合
     *
     * @param array $user
     *
     * @return array
     */
    private function get_user_dp_list($user = [])
    {
        $dpIds = [];
        // 部门ID
        if (isset($user['dpName']) && !empty($user['dpName'])) {

            $myDpIds = array_column($user['dpName'], 'dpId');

            $dpServ = &Department::instance();
            $parentDpIds = [];

            // 取父级部门ID
            foreach ($myDpIds as $myDpId) {
                $dpServ->list_parent_cdids($myDpId, $parentDpIds);
            }

            $dpIds = array_unique(array_merge($myDpIds, array_values($parentDpIds)));
        }

        return $dpIds;
    }

}