package com.zanxiang.game.data.serve.component;

import com.github.sd4324530.jtuple.Tuple2;
import com.zanxiang.erp.base.ErpServer;
import com.zanxiang.erp.base.rpc.ISysGameUserGroupRpc;
import com.zanxiang.erp.security.util.SecurityUtil;
import com.zanxiang.game.module.base.ServerInfo;
import com.zanxiang.game.module.base.pojo.enums.GameAuthEnum;
import com.zanxiang.game.module.base.pojo.vo.GameAuthUserVO;
import com.zanxiang.game.module.base.rpc.GameAuthRpc;
import com.zanxiang.module.util.JsonUtil;
import com.zanxiang.module.util.exception.BaseException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.dubbo.config.annotation.DubboReference;
import org.nutz.dao.Cnd;
import org.nutz.dao.Dao;
import org.nutz.dao.Sqls;
import org.nutz.dao.sql.Criteria;
import org.nutz.dao.sql.Sql;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

@Slf4j
@Component
public class DataPowerComponent {

    @DubboReference(providedBy = ErpServer.SERVER_DUBBO_NAME)
    private ISysGameUserGroupRpc sysGameUserGroupRpc;

    @DubboReference(providedBy = ServerInfo.SERVER_DUBBO_NAME)
    private GameAuthRpc gameAuthRpc;

    @Autowired
    private Dao dao;

    public Tuple2<List<Long>, List<Long>> getPowerInfo() {
        return getPowerInfo("ZX_ONE");
    }

    /**
     * 获取当前登录用户有权限查看的用户列表
     * 1：普通用户-投手：自己
     * 1：普通用户-运营：游戏数据
     * 2：投手组长：自己+组员+自然量
     * 3：管理员/超管：所有数据
     */
    public Tuple2<List<Long>, List<Long>> getPowerInfo(String sdk) {
        if (StringUtils.isBlank(sdk)) {
            sdk = "ZX_ONE";
        }
        if (SecurityUtil.isAdmin()) {
            return Tuple2.with(null, null);
        }
        Collection<Long> subUserIds = sysGameUserGroupRpc.memberUserIds(SecurityUtil.getCompanyId(), SecurityUtil.getUserId()).getData();
        if (!"ZX_ONE".equals(sdk)) {
            return Tuple2.with(new ArrayList<>(subUserIds), null);
        }
        GameAuthUserVO userGameInfo = gameAuthRpc.getGameAuthByUserIds().getData();
        //原有的游戏ID添加通包游戏的权限
        List<Long> gameIds = getFullGameIdList(userGameInfo.getGameIdList());
        if (CollectionUtils.isEmpty(gameIds)) {
            throw new BaseException("没有游戏查看权限，请联系管理员指派游戏权限");
        }
        GameAuthEnum gameAuth = userGameInfo.getGameAuthEnum();
        if (CollectionUtils.isEmpty(subUserIds)) {
            throw new BaseException("服务异常，获取用户列表失败！！");
        }
        if (subUserIds.size() == 1) {
            if (gameAuth == GameAuthEnum.MANAGE) {
                return Tuple2.with(null, null);
            } else if (gameAuth == GameAuthEnum.OPERATE || gameAuth == GameAuthEnum.CUSTOMER || gameAuth == GameAuthEnum.GS) {
                // 运营
                return Tuple2.with(null, gameIds);
            } else {
                // 投手
                return Tuple2.with(new ArrayList<>(subUserIds), gameIds);
            }
        } else {
            if (gameAuth == GameAuthEnum.MANAGE) {
                return Tuple2.with(null, null);
            } else if (gameAuth == GameAuthEnum.OPERATE || gameAuth == GameAuthEnum.CUSTOMER || gameAuth == GameAuthEnum.GS) {
                // 运营组长
                return Tuple2.with(null, gameIds);
            } else {
                // 投手组长
                // 自然量
                subUserIds.add(0L);
                return Tuple2.with(new ArrayList<>(subUserIds), gameIds);
            }
        }
    }


    /**
     * 获取当前登录用户有权限查看的用户列表
     * 1：普通用户-投手：自己
     * 1：普通用户-运营：null-->表示不按权限做
     * 2：投手组长：自己+组员
     * 3：管理员：自己+组员
     * 4：超管：null-->有权限看所有数据
     */
    public List<Long> getSubUserIdList() {
        if (SecurityUtil.isAdmin()) {
            return null;
        }
        Collection<Long> subUserIds = sysGameUserGroupRpc.memberUserIds(SecurityUtil.getCompanyId(), SecurityUtil.getUserId()).getData();
        if (subUserIds.size() > 1) {
            // 自然量
            subUserIds.add(0L);
        }
        log.error("1111--------->" + JsonUtil.toString(subUserIds));
        return new ArrayList<>(subUserIds);
    }


    /**
     * 获取当前登录用户有权限查看的游戏列表
     * 1：普通运营：自己有权限的游戏列表
     * 2：普通投手：自己有投的游戏列表
     * 3：投手组长：自己+组员投的游戏列表
     * 4：管理员：自己+组员投的游戏列表
     * 5：超管：null-->表示不用此字段做游戏过滤
     */
    public List<Long> getSubGameIdList() {
        if (SecurityUtil.isAdmin()) {
            return null;
        }
        List<Long> gameIdList = gameAuthRpc.getGameAuthByUserIds().getData().getGameIdList();
        if (CollectionUtils.isEmpty(gameIdList)) {
            throw new BaseException("没有游戏查看权限，请联系管理员指派游戏权限");
        }
        return gameIdList;
    }

    /**
     * 获取全量的游戏ID（补全虚拟的IOS包游戏ID）
     *
     * @param gameIds 用户拥有的游戏权限的游戏ID
     * @return 游戏ID
     */
    public List<Long> getFullGameIdList(List<Long> gameIds) {
        //查询条件
        Criteria cri = Cnd.cri();
        if (CollectionUtils.isEmpty(gameIds)) {
            return null;
        } else {
            cri.where().andInList("id", gameIds);
        }
        cri.where().andEquals("source_system", "ZX_ONE");
        cri.where().andEquals("is_common_game", 1);
        Sql sql = Sqls.create("""
                SELECT
                    guide_game_ids
                FROM dm_game_order.t_game
                """ + cri);
        sql.setCallback(Sqls.callback.strList());
        dao.execute(sql);
        List<String> strList = sql.getList(String.class);
        if (CollectionUtils.isEmpty(strList)) {
            return gameIds;
        }
        for (String str : strList) {
            gameIds.addAll(Arrays.stream(str.split(",")).
                    map(gameId -> Long.parseLong(gameId) + 10000).toList());
        }
        return gameIds;
    }


}
