php/app/common/repositories/shared/SharedProsperityUserRepository.php

<?php

namespace app\common\repositories\shared;

use app\common\dao\shared\SharedProsperityUserDao;
use app\common\dao\user\UserDao;
use app\common\enum\CommonEnum;
use app\common\enum\shared\SharedProsperityUserEnum;
use app\common\repositories\BaseRepository;
use app\entity\data\shared\SharedProsperityRecommendConfigEntity;
use app\entity\data\shared\SharedProsperityUserEntity;
use think\db\exception\DbException;

class SharedProsperityUserRepository extends BaseRepository
{

    protected $dao;

    /**
     * SharedProsperityUserRepository constructor.
     * @param SharedProsperityUserDao $dao
     */
    public function __construct(SharedProsperityUserDao $dao)
    {
        $this->dao = $dao;
    }

    /**
     * @param int $id
     * @return SharedProsperityUserEntity
     */
    public function getSharedProsperityUserEntityById(int $id): SharedProsperityUserEntity
    {
        $entityList = $this->getSharedProsperityUserEntityListByIdList([$id]);
        $entity = array_shift($entityList);
        if ($entity instanceof SharedProsperityUserEntity) {
            return $entity;
        } else {
            /** @var SharedProsperityUserEntity */
            return SharedProsperityUserEntity::newInstance();
        }
    }

    /**
     * @param array $idList
     * @return SharedProsperityUserEntity[]
     */
    public function getSharedProsperityUserEntityListByIdList(array $idList): array
    {
        return $this->dao->getSharedProsperityUserEntityListByIdList($idList);
    }

    /**
     * @param int $userId
     * @return SharedProsperityUserEntity
     */
    public function getSharedProsperityUserEntityByUserId(int $userId): SharedProsperityUserEntity
    {
        $entityList = $this->getSharedProsperityUserEntityListByUserIdList([$userId]);
        $entity = array_shift($entityList);
        if ($entity instanceof SharedProsperityUserEntity) {
            return $entity;
        } else {
            /** @var SharedProsperityUserEntity */
            return SharedProsperityUserEntity::newInstance();
        }
    }

    /**
     * @param array $userIdList
     * @return SharedProsperityUserEntity[]
     */
    public function getSharedProsperityUserEntityListByUserIdList(array $userIdList): array
    {
        return $this->dao->getSharedProsperityUserEntityListByUserIdList($userIdList);
    }

    /**
     * 获取直接下级用户ID列表
     * @param int $parentId 用户ID
     * @return SharedProsperityUserEntity[] 直接下级用户ID列表
     */
    public function getSharedProsperityUserEntityListByParentId(int $parentId): array
    {
        return $this->dao->getSharedProsperityUserEntityListByParentId($parentId);
    }

    /**
     * @param array $userIdList
     * @return SharedProsperityUserEntity[]
     */
    public function getSharedProsperityUserEntityMapByUserIdList(array $userIdList): array
    {
        $sharedProsperityUserEntityList = $this->dao->getSharedProsperityUserEntityListByUserIdList($userIdList);
        /** @var SharedProsperityUserEntity[] $sharedProsperityUserEntityMapByUserId */
        $sharedProsperityUserEntityMapByUserId = array_column($sharedProsperityUserEntityList, null, 'userId');
        return $sharedProsperityUserEntityMapByUserId;
    }

    public function create($data)
    {
        return $this->dao->create($data);
    }

    /**
     * @param SharedProsperityUserEntity $sharedProsperityUserEntity
     * @return SharedProsperityUserEntity
     */
    public function createByEntity(SharedProsperityUserEntity $sharedProsperityUserEntity): SharedProsperityUserEntity
    {
        $result = $this->create($sharedProsperityUserEntity->toUnderlineArray())->toArray();
        /** @var SharedProsperityUserEntity $entity */
        $entity = SharedProsperityUserEntity::newInstance($result);
        return $entity;
    }

    /**
     * @param $id
     * @param $data
     * @return int
     */
    public function update($id, $data): int
    {
        try {
            return $this->dao->update($id, $data);
        } catch (DbException $e) {
            return 0;
        }
    }

    public function updateByUserId($userId, $data): int
    {
        try {
            return $this->dao->updateByUserId($userId, $data);
        } catch (DbException $e) {
            return 0;
        }
    }

    /**
     * @param SharedProsperityUserEntity $sharedProsperityUserEntity
     * @return SharedProsperityUserEntity
     */
    public function updateByEntity(SharedProsperityUserEntity $sharedProsperityUserEntity): SharedProsperityUserEntity
    {
        if (empty($sharedProsperityUserEntity->getId())) {
            return SharedProsperityUserEntity::newInstance();
        }
        $result = $this->update($sharedProsperityUserEntity->getId(), $sharedProsperityUserEntity->toUnderlineArray());
        if ($result > 0) {
            return $this->getSharedProsperityUserEntityById($sharedProsperityUserEntity->getId());
        }
        return SharedProsperityUserEntity::newInstance();
    }

    /**
     * 绑定 上级
     * @param int $userId
     * @param int $parentId
     * @return bool
     */
    public function bindParentId(int $userId, int $parentId): bool
    {
        $sharedProsperityUserEntity = $this->getSharedProsperityUserEntityByUserId($userId);
        if (empty($sharedProsperityUserEntity->getUserId())) {
            return false;
        }
        $sharedProsperityUserEntityByParentId = $this->getSharedProsperityUserEntityByUserId($parentId);
        if (empty($sharedProsperityUserEntityByParentId->getUserId())) {
            return false;
        }
        $sharedProsperityUserEntity = $this->updateByEntity($sharedProsperityUserEntity->setParentId($sharedProsperityUserEntityByParentId->getUserId()));
        if (empty($sharedProsperityUserEntity->getId())) {
            return false;
        }
        return true;
    }

    /**
     * 获取直推用户列表，并计算每个直推用户的团队总人数和团队总业绩（包含自己）
     * 返回三个列表：全部直推、大部门（团队业绩最大的直推用户）、小部门（其余直推用户）
     * 同时返回统计数据：我的部门总人数、总业绩、小部门业绩总和、大部门业绩总和
     * @param int $userId
     * @return array
     */
    public function getTeam(int $userId): array
    {
        // 获取直推用户
        $list = $this->dao->getDirectByUserId($userId);
        if (empty($list)) {
            // 没有直推用户，仍然返回统计数据（我的部门总人数和总业绩）
            $myTeamUserIds = $this->dao->getAllSubordinateUserIds($userId, true);
            $myTeamTotalCount = count($myTeamUserIds);
            $myTeamPvSum = $this->dao->getTeamPvSumWithSelf($userId);
            return [
                'all_direct' => [],
                'big_department' => [],
                'small_department' => [],
                'stats' => [
                    'my_team_total_count' => $myTeamTotalCount,
                    'my_team_pv_sum' => $myTeamPvSum,
                    'small_department_pv_sum' => 0,
                    'big_department_pv_sum' => 0,
                ]
            ];
        }
        // 收集所有直推用户ID
        $userIds = array_column($list, 'user_id');
        // 获取用户详细信息（昵称、头像、注册时间）
        /** @var UserDao $userDao */
        $userDao = app()->make(UserDao::class);
        $userEntities = $userDao->getUserEntityListByUidList($userIds);
        $userMap = [];
        foreach ($userEntities as $userEntity) {
            $userMap[$userEntity->getUid()] = [
                'nickname' => $userEntity->getNickname(),
                'avatar' => $userEntity->getAvatar(),
                'create_time' => $userEntity->getCreateTime(),
            ];
        }
        // 计算每个直推用户的团队总人数和团队总业绩
        $maxPv = 0;
        $maxPvIndex = -1;
        foreach ($list as $index => &$item) {
            $teamUserIds = $this->dao->getAllSubordinateUserIds($item['user_id'], true);
            $teamTotalCount = count($teamUserIds);
            $teamPvSum = $this->dao->getTeamPvSumWithSelf($item['user_id']);
            $item['team_total_count'] = $teamTotalCount;
            $item['team_pv_sum'] = $teamPvSum;
            // 补充用户信息
            if (isset($userMap[$item['user_id']])) {
                $item['nickname'] = $userMap[$item['user_id']]['nickname'];
                $item['avatar'] = $userMap[$item['user_id']]['avatar'];
                $item['create_time'] = $userMap[$item['user_id']]['create_time'];
            } else {
                $item['nickname'] = '';
                $item['avatar'] = '';
                $item['create_time'] = '';
            }
            // 找出团队业绩最大的直推用户
            if ($teamPvSum > $maxPv) {
                $maxPv = $teamPvSum;
                $maxPvIndex = $index;
            }
        }
        unset($item);
        // 分割大部门和小部门
        $bigDepartment = [];
        $smallDepartment = [];
        if ($maxPvIndex >= 0) {
            $bigDepartment[] = $list[$maxPvIndex];
            foreach ($list as $index => $item) {
                if ($index !== $maxPvIndex) {
                    $smallDepartment[] = $item;
                }
            }
        } else {
            // 没有直推用户（理论上不会发生）
            $smallDepartment = $list;
        }
        // 计算统计数据
        $myTeamUserIds = $this->dao->getAllSubordinateUserIds($userId, true);
        $myTeamTotalCount = count($myTeamUserIds);
        $myTeamPvSum = $this->dao->getTeamPvSumWithSelf($userId);
        $smallDepartmentPvSum = 0;
        foreach ($smallDepartment as $item) {
            $smallDepartmentPvSum += $item['team_pv_sum'];
        }
        $bigDepartmentPvSum = 0;
        foreach ($bigDepartment as $item) {
            $bigDepartmentPvSum += $item['team_pv_sum'];
        }
        return [
            'all_direct' => $list,
            'big_department' => $bigDepartment,
            'small_department' => $smallDepartment,
            'stats' => [
                'my_team_total_count' => $myTeamTotalCount,
                'my_team_pv_sum' => $myTeamPvSum,
                'small_department_pv_sum' => $smallDepartmentPvSum,
                'big_department_pv_sum' => $bigDepartmentPvSum,
            ]
        ];
    }

    /**
     * 批量更新
     * @param $dataList
     * @return array
     */
    public function batchUpdateSharedProsperityUserDataByDataList($dataList): array
    {
        return $this->dao->saveAll($dataList);
    }

    /**
     * 用户身份升级
     * @param array $userIdList
     * @return void
     */
    public function identityUpgrade(array $userIdList)
    {
        if (empty($userIdList)) {
            return;
        }

        /** @var SharedProsperityRecommendConfigRepository $sharedProsperityRecommendConfigRepository */
        $sharedProsperityRecommendConfigRepository = app()->make(SharedProsperityRecommendConfigRepository::class);
        $sharedProsperityRecommendConfigEntityList = $sharedProsperityRecommendConfigRepository->getList();
        usort($sharedProsperityRecommendConfigEntityList, function (SharedProsperityRecommendConfigEntity $a, SharedProsperityRecommendConfigEntity $b) {
            return $a->getPv() <=> $b->getPv();  // 从小到大排序
        });

        $sharedProsperityUserEntityList = $this->getSharedProsperityUserEntityListByUserIdList($userIdList);

        // 批量更新用户等级
        $this->batchUpgradeUsers($sharedProsperityUserEntityList, $sharedProsperityRecommendConfigEntityList);

        // foreach ($sharedProsperityUserEntityList as $sharedProsperityUserEntity) {
        //     $partnerLevel = 0;
        //     foreach ($sharedProsperityRecommendConfigEntityList as $sharedProsperityRecommendConfigEntity) {
        //         if ($sharedProsperityUserEntity->getPv() >= $sharedProsperityRecommendConfigEntity->getPv()) {
        //             $partnerLevel = $sharedProsperityRecommendConfigEntity->getLevel();
        //         } else {
        //             // 如果本次验证的等级结果大于 之前的等级，说明用户升级了 需要更新等级
        //             if ($partnerLevel > $sharedProsperityUserEntity->getPartnerLevel()) {
        //                 $this->updateByEntity(
        //                     SharedProsperityUserEntity::newInstance()
        //                         ->setId($sharedProsperityUserEntity->getId())
        //                         ->setPartnerLevel($partnerLevel)
        //                 );
        //             }
        //             break;
        //         }
        //     }
        // }
    }

    /**
     * 批量更新用户等级
     * @param SharedProsperityUserEntity[] $sharedProsperityUserEntityList 用户实体列表
     * @param SharedProsperityRecommendConfigEntity[] $sharedProsperityRecommendConfigEntityList 等级配置列表
     * @return void
     */
    private function batchUpgradeUsers(array $sharedProsperityUserEntityList, array $sharedProsperityRecommendConfigEntityList)
    {
        foreach ($sharedProsperityUserEntityList as $sharedProsperityUserEntity) {

            // // 计算用户的团队业绩（向下5级）
            // $teamPv = $this->calculateTeamPv($sharedProsperityUserEntity->getId());

            // 根据团队业绩确定等级
            // $newLevel = $this->calculateLevelByTeamPv($teamPv, $sharedProsperityRecommendConfigEntityList);
            //
            // // 如果新等级大于当前等级，则更新
            // if ($newLevel > $sharedProsperityUserEntity->getPartnerLevel()) {
            //     $this->updateByEntity(
            //         SharedProsperityUserEntity::newInstance()
            //             ->setId($sharedProsperityUserEntity->getId())
            //             ->setPartnerLevel($newLevel)
            //     );
            // }

            $this->upgradeUpperLevels($sharedProsperityUserEntity->getUserId(), $sharedProsperityRecommendConfigEntityList);
        }
    }

    /**
     * 向上追溯更新上级身份等级（最多向上5层）
     * @param int $userId 当前用户ID
     * @param SharedProsperityRecommendConfigEntity[] $sharedProsperityRecommendConfigEntityList 等级配置列表
     * @return void
     */
    private function upgradeUpperLevels(int $userId, array $sharedProsperityRecommendConfigEntityList)
    {
        $maxLevels = SharedProsperityUserEnum::TEAM_DEPTH;
        $currentUserId = $userId;

        for ($i = 0; $i < $maxLevels; $i++) {
            // 获取上级用户ID
            $sharedProsperityUserEntity = $this->getSharedProsperityUserEntityByUserId($currentUserId);
            $parentId = $sharedProsperityUserEntity->getParentId();

            if (empty($parentId)) {
                break; // 没有上级，停止追溯
            }

            // 重新计算上级的团队业绩和等级
            $this->upgradeSingleUser($parentId, $sharedProsperityRecommendConfigEntityList);

            // 继续向上追溯
            $currentUserId = $parentId;
        }
    }

    /**
     * 升级单个用户身份
     * @param int $userId 用户ID
     * @param SharedProsperityRecommendConfigEntity[] $sharedProsperityRecommendConfigEntityList 等级配置列表
     * @return void
     */
    private function upgradeSingleUser(int $userId, array $sharedProsperityRecommendConfigEntityList)
    {
        // 获取用户实体
        $sharedProsperityUserEntity = $this->getSharedProsperityUserEntityByUserId($userId);

        if (empty($sharedProsperityUserEntity->getId())) {
            return;
        }

        // 计算团队业绩
        $teamPvMap = $this->calculateTeamPv($userId);

        // 当前只计算团队业绩的 小团队业绩
        $maxKey = array_keys($teamPvMap, max($teamPvMap))[0];
        unset($teamPvMap[$maxKey]);
        $teamPvBySmallSum = array_sum($teamPvMap);

        // 计算新等级
        $newLevel = $this->calculateLevelByTeamPv($teamPvBySmallSum, $sharedProsperityRecommendConfigEntityList);

        // 如果新等级大于当前等级，则更新
        if ($newLevel > $sharedProsperityUserEntity->getPartnerLevel()) {
            $this->updateByEntity(
                SharedProsperityUserEntity::newInstance()
                    ->setId($sharedProsperityUserEntity->getId())
                    ->setPartnerLevel($newLevel)
            );
        }
    }

    /**
     * 计算用户的团队业绩（向下5级）
     * @param int $userId 用户ID
     * @return array 团队业绩
     */
    private function calculateTeamPv(int $userId): array
    {
        $teamPvMap = [];

        // 获取所有下级用户ID（向下5级）
        // 第一层级在这里查询 因为要统计大小区
        $sharedProsperityUserEntityListByParentId = $this->getSharedProsperityUserEntityListByParentId($userId);

        // 循环 直属下级
        foreach ($sharedProsperityUserEntityListByParentId as $sharedProsperityUserEntityByUnderling) {
            $departmentTeamUserIdList = $this->getUserIdListByParentIdForDepth($sharedProsperityUserEntityByUnderling->getUserId(), SharedProsperityUserEnum::TEAM_DEPTH - 1);
            $departmentTeamUserIdList[] = $sharedProsperityUserEntityByUnderling->getUserId();

            // 直属团队的 业绩总和
            $teamPv = '0.00';
            if (!empty($departmentTeamUserIdList)) {
                // 批量获取下级用户的个人业绩并求和
                // 假设有方法批量获取用户的PV
                $sharedProsperityUserEntityListByTeam = $this->getSharedProsperityUserEntityListByUserIdList($departmentTeamUserIdList);
                foreach ($sharedProsperityUserEntityListByTeam as $sharedProsperityUserEntityByTeam) {
                    $teamPv = bcadd($teamPv, (string)$sharedProsperityUserEntityByTeam->getPv(), 2);
                }
            }
            $teamPvMap[$sharedProsperityUserEntityByUnderling->getUserId()] = $teamPv;
        }

        return $teamPvMap;
    }


    /**
     * 根据团队业绩计算等级
     * @param float $teamPv 团队业绩
     * @param array $configEntityList 等级配置列表
     * @return int 等级
     */
    private function calculateLevelByTeamPv(float $teamPv, array $configEntityList): int
    {
        $level = 0;

        foreach ($configEntityList as $configEntity) {
            if ($teamPv >= $configEntity->getPv()) {
                $level = $configEntity->getLevel();
            } else {
                break;
            }
        }

        return $level;
    }

    /**
     * 获取下级用户ID列表（向下指定层级）
     * @param int $parentId 用户ID
     * @param int $maxLevel 最大层级数
     * @param int $currentLevel 当前层级（内部递归使用）
     * @return array 下级用户ID列表
     */
    private function getUserIdListByParentIdForDepth(int $parentId, int $maxLevel, int $currentLevel = 1): array
    {
        if ($currentLevel > $maxLevel) {
            return [];
        }

        $subordinateIds = [];

        // 获取直接下级用户ID列表（假设有方法获取直接下级）
        $sharedProsperityUserEntityListByParentId = $this->getSharedProsperityUserEntityListByParentId($parentId);

        if (empty($sharedProsperityUserEntityListByParentId)) {
            return [];
        }

        // 添加直接下级
        $subordinateIds = array_merge($subordinateIds, array_column($sharedProsperityUserEntityListByParentId, 'userId'));

        // 递归获取下级的下级
        foreach ($sharedProsperityUserEntityListByParentId as $sharedProsperityUserEntity) {
            $nestedSubordinateIds = $this->getUserIdListByParentIdForDepth($sharedProsperityUserEntity->getUserId(), $maxLevel, $currentLevel + 1);
            if (!empty($nestedSubordinateIds)) {
                $subordinateIds = array_merge($subordinateIds, $nestedSubordinateIds);
            }
        }

        return array_unique($subordinateIds);
    }
}