kknongchang_2506/app/Module/UrsPromotion/Services/UrsReferralService.php

<?php

namespace App\Module\UrsPromotion\Services;

use App\Module\UrsPromotion\Dtos\UrsUserReferralDto;
use App\Module\UrsPromotion\Models\UrsUserMapping;
use App\Module\UrsPromotion\Models\UrsUserReferral;
use App\Module\UrsPromotion\Models\UrsUserTalent;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

/**
 * URS推荐关系服务
 *
 * 管理URS用户之间的推荐关系
 */
class UrsReferralService
{
    /**
     * 建立推荐关系
     *
     * @param int $ursUserId URS用户ID
     * @param int $ursReferrerId URS推荐人ID
     * @return UrsUserReferralDto
     * @throws \Exception
     */
    public static function createReferral(int $ursUserId, int $ursReferrerId): UrsUserReferralDto
    {
        try {
            DB::beginTransaction();

            // 检查是否已存在推荐关系
            $existingReferral = UrsUserReferral::where('urs_user_id', $ursUserId)->first();
            if ($existingReferral) {
                throw new \Exception("URS用户ID {$ursUserId} 已存在推荐关系");
            }

            // 检查推荐人是否存在
            if ($ursUserId === $ursReferrerId) {
                throw new \Exception("不能推荐自己");
            }

            // 检查是否会形成循环推荐
            if (self::wouldCreateCircularReferral($ursUserId, $ursReferrerId)) {
                throw new \Exception("不能形成循环推荐关系");
            }

            // 获取农场用户ID（如果已进入农场）
            $farmUserId = UrsUserMappingService::getFarmUserId($ursUserId);
            $referrerFarmUserId = UrsUserMappingService::getFarmUserId($ursReferrerId);

            // 创建推荐关系
            $referral = UrsUserReferral::create([
                'urs_user_id' => $ursUserId,
                'urs_referrer_id' => $ursReferrerId,
                'user_id' => $farmUserId ,
                'referrer_id' => $referrerFarmUserId,
                'referral_time' => now(),
                'status' => UrsUserReferral::STATUS_VALID,
            ]);



            DB::commit();
            // 更新推荐人的团队统计
            self::updateReferrerStats($ursReferrerId);

            Log::info('URS推荐关系创建成功', [
                'urs_user_id' => $ursUserId,
                'urs_referrer_id' => $ursReferrerId,
                'referral_id' => $referral->id
            ]);

            return UrsUserReferralDto::fromModel($referral);

        } catch (\Exception $e) {
            DB::rollBack();
            Log::error('URS推荐关系创建失败', [
                'urs_user_id' => $ursUserId,
                'urs_referrer_id' => $ursReferrerId,
                'error' => $e->getMessage()
            ]);
            throw $e;
        }
    }

    /**
     * 获取用户的推荐人
     *
     * @param int $ursUserId URS用户ID
     * @return int|null 推荐人URS用户ID，如果没有推荐人返回null
     */
    public static function getReferrer(int $ursUserId): ?int
    {
        $referral = UrsUserReferral::where('urs_user_id', $ursUserId)
            ->where('status', UrsUserReferral::STATUS_VALID)
            ->first();

        return $referral ? $referral->urs_referrer_id : null;
    }

    /**
     * 获取用户的直推下级列表
     *
     * @param int $ursUserId URS用户ID
     * @return array 直推下级URS用户ID数组
     */
    public static function getDirectReferrals(int $ursUserId): array
    {
        return UrsUserReferral::where('urs_referrer_id', $ursUserId)
            ->where('status', UrsUserReferral::STATUS_VALID)
            ->pluck('urs_user_id')
            ->toArray();
    }

    /**
     * 获取用户的推荐关系链（向上查找）
     *
     * @param int $ursUserId URS用户ID
     * @param int $maxLevels 最大层级数
     * @return array 推荐关系链，按层级排序 [level => urs_user_id]
     */
    public static function getReferralChain(int $ursUserId, int $maxLevels = 10): array
    {
        $chain = [];
        $currentUserId = $ursUserId;

        for ($level = 1; $level <= $maxLevels; $level++) {
            $referrerId = self::getReferrer($currentUserId);
            if (!$referrerId) {
                break; // 没有上级了
            }

            $chain[$level] = $referrerId;
            $currentUserId = $referrerId;
        }

        return $chain;
    }

    /**
     * 获取用户的团队成员（向下查找）
     *
     * @param int $ursUserId URS用户ID
     * @param int $maxLevels 最大层级数
     * @return array 团队成员，按层级分组 [level => [urs_user_ids]]
     */
    public static function getTeamMembers(int $ursUserId, int $maxLevels = 3): array
    {
        $team = [];
        $currentLevelUsers = [$ursUserId];

        for ($level = 1; $level <= $maxLevels; $level++) {
            $nextLevelUsers = [];

            foreach ($currentLevelUsers as $userId) {
                $directReferrals = self::getDirectReferrals($userId);
                $nextLevelUsers = array_merge($nextLevelUsers, $directReferrals);
            }

            if (empty($nextLevelUsers)) {
                break; // 没有下级了
            }

            $team[$level] = $nextLevelUsers;
            $currentLevelUsers = $nextLevelUsers;
        }

        return $team;
    }

    /**
     * 检查是否会形成循环推荐
     *
     * @param int $ursUserId URS用户ID
     * @param int $ursReferrerId URS推荐人ID
     * @return bool
     */
    private static function wouldCreateCircularReferral(int $ursUserId, int $ursReferrerId): bool
    {
        // 检查推荐人的上级链中是否包含当前用户
        $referrerChain = self::getReferralChain($ursReferrerId);
        return in_array($ursUserId, $referrerChain);
    }

    /**
     * 更新推荐人的团队统计
     *
     * @param int $ursReferrerId URS推荐人ID
     */
    private static function updateReferrerStats(int $ursReferrerId): void
    {
        $user_id = UrsUserMapping::getFarmUserIdByUrsUserId($ursReferrerId);

        $teamMembers = self::getTeamMembers($ursReferrerId);

        $directCount = count($teamMembers[1] ?? []);
        $indirectCount = count($teamMembers[2] ?? []);
        $thirdCount = count($teamMembers[3] ?? []);
        $totalCount = $directCount + $indirectCount + $thirdCount;

        UrsUserTalent::updateOrCreate(
            ['user_id' => $user_id],
            [
                'direct_count' => $directCount,
                'indirect_count' => $indirectCount,
                'third_count' => $thirdCount,
                'promotion_count' => $totalCount,
            ]
        );
    }

    /**
     * 批量更新团队统计
     *
     * @param array $ursUserIds URS用户ID数组
     */
    public static function batchUpdateTeamStats(array $ursUserIds): void
    {
        foreach ($ursUserIds as $ursUserId) {
            self::updateReferrerStats($ursUserId);
        }
    }

    /**
     * 获取推荐关系统计
     *
     * @param int $ursUserId URS用户ID
     * @return array
     */
    public static function getReferralStats(int $ursUserId): array
    {
        $teamMembers = self::getTeamMembers($ursUserId);
        $referralChain = self::getReferralChain($ursUserId);

        return [
            'urs_user_id' => $ursUserId,
            'referrer_id' => self::getReferrer($ursUserId),
            'referrer_level' => count($referralChain),
            'direct_count' => count($teamMembers[1] ?? []),
            'indirect_count' => count($teamMembers[2] ?? []),
            'third_count' => count($teamMembers[3] ?? []),
            'total_team_count' => array_sum(array_map('count', $teamMembers)),
            'team_members' => $teamMembers,
            'referral_chain' => $referralChain,
        ];
    }

    /**
     * 验证推荐关系的有效性
     *
     * @param int $ursUserId URS用户ID
     * @return bool
     */
    public static function validateReferral(int $ursUserId): bool
    {
        $referral = UrsUserReferral::where('urs_user_id', $ursUserId)->first();
        return $referral && $referral->isValid();
    }

    /**
     * 禁用推荐关系
     *
     * @param int $ursUserId URS用户ID
     * @return bool
     */
    public static function disableReferral(int $ursUserId): bool
    {
        try {
            $referral = UrsUserReferral::where('urs_user_id', $ursUserId)->first();
            if (!$referral) {
                return false;
            }

            $referral->setInvalid();
            $referral->save();

            // 更新推荐人的团队统计
            self::updateReferrerStats($referral->urs_referrer_id);

            Log::info('URS推荐关系已禁用', [
                'urs_user_id' => $ursUserId,
                'referral_id' => $referral->id
            ]);

            return true;

        } catch (\Exception $e) {
            Log::error('URS推荐关系禁用失败', [
                'urs_user_id' => $ursUserId,
                'error' => $e->getMessage()
            ]);
            return false;
        }
    }

    /**
     * 批量更新推荐关系表中的农场用户ID
     *
     * 当用户进入农场后，批量更新推荐关系表中的农场用户ID字段
     *
     * @return array 更新结果
     */
    public static function batchUpdateFarmUserIds(): array
    {
        try {
            Log::info('开始批量更新推荐关系表中的农场用户ID');

            // 使用SQL批量更新，提高性能
            $updateSql = "
                UPDATE `kku_urs_promotion_user_referrals` r
                LEFT JOIN `kku_urs_promotion_user_mappings` um ON r.urs_user_id = um.urs_user_id AND um.status = 1
                LEFT JOIN `kku_urs_promotion_user_mappings` rm ON r.urs_referrer_id = rm.urs_user_id AND rm.status = 1
                SET
                    r.user_id = COALESCE(um.user_id, 0),
                    r.referrer_id = COALESCE(rm.user_id, 0)
                WHERE r.status = 1
            ";

            $affectedRows = DB::update($updateSql);

            Log::info('批量更新推荐关系表中的农场用户ID完成', [
                'affected_rows' => $affectedRows
            ]);

            return [
                'success' => true,
                'affected_rows' => $affectedRows,
                'message' => "成功更新 {$affectedRows} 条推荐关系记录"
            ];

        } catch (\Exception $e) {
            Log::error('批量更新推荐关系表中的农场用户ID失败', [
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'affected_rows' => 0,
                'message' => '批量更新失败: ' . $e->getMessage()
            ];
        }
    }

    /**
     * 更新单个推荐关系的农场用户ID
     *
     * 当特定用户进入农场时，更新其相关的推荐关系记录
     *
     * @param int $ursUserId URS用户ID
     * @param int $farmUserId 农场用户ID
     * @return bool
     */
    public static function updateFarmUserIdForUser(int $ursUserId, int $farmUserId): bool
    {
        try {
            DB::beginTransaction();

            // 更新该用户作为被推荐人的记录
            UrsUserReferral::where('urs_user_id', $ursUserId)
                ->where('status', UrsUserReferral::STATUS_VALID)
                ->update(['user_id' => $farmUserId]);

            // 更新该用户作为推荐人的记录
            UrsUserReferral::where('urs_referrer_id', $ursUserId)
                ->where('status', UrsUserReferral::STATUS_VALID)
                ->update(['referrer_id' => $farmUserId]);

            DB::commit();

            Log::info('更新用户推荐关系农场用户ID成功', [
                'urs_user_id' => $ursUserId,
                'farm_user_id' => $farmUserId
            ]);

            return true;

        } catch (\Exception $e) {
            DB::rollBack();
            Log::error('更新用户推荐关系农场用户ID失败', [
                'urs_user_id' => $ursUserId,
                'farm_user_id' => $farmUserId,
                'error' => $e->getMessage()
            ]);

            return false;
        }
    }
}