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

<?php

namespace App\Module\UrsPromotion\Services;

use App\Module\UrsPromotion\Dtos\UrsUserMappingDto;
use App\Module\UrsPromotion\Events\UrsUserEnteredFarmEvent;
use App\Module\UrsPromotion\Models\UrsUserMapping;
use App\Module\User\Services\UserService;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Str;

/**
 * URS用户映射服务
 *
 * 管理URS用户ID与农场用户ID的映射关系
 */
class UrsUserMappingService
{

    static $isFirst=[];


    /**
     * 创建用户映射关系（用户进入农场时调用）
     *
     * @param int $ursUserId URS用户ID
     * @param int $farmUserId 农场用户ID
     * @param string|null $userKey 用户凭证
     * @return UrsUserMappingDto
     * @throws \Exception
     */
    public static function createMapping(int $ursUserId, int $farmUserId, ?string $userKey = null): UrsUserMappingDto
    {
        try {
            DB::beginTransaction();

            // 检查是否已存在映射
            $existingMapping = UrsUserMapping::where('urs_user_id', $ursUserId)->first();
            if ($existingMapping) {
                if ($existingMapping->user_id === $farmUserId) {
                    // 相同映射，直接返回
                    DB::rollBack();
                    return UrsUserMappingDto::fromModel($existingMapping);
                } else {
                    // 不同映射，抛出异常
                    throw new \Exception("URS用户ID {$ursUserId} 已映射到农场用户ID {$existingMapping->user_id}");
                }
            }

            // 检查农场用户ID是否已被映射
            $existingFarmMapping = UrsUserMapping::where('user_id', $farmUserId)->first();
            if ($existingFarmMapping) {
                throw new \Exception("农场用户ID {$farmUserId} 已映射到URS用户ID {$existingFarmMapping->urs_user_id}");
            }

            // 创建新映射
            $mapping = UrsUserMapping::create([
                'urs_user_id' => $ursUserId,
                'user_key' => $userKey,
                'user_id' => $farmUserId,
                'mapping_time' => now(),
                'status' => UrsUserMapping::STATUS_VALID,
            ]);
            self::$isFirst[$farmUserId] = $ursUserId;
            DB::commit();

            Log::info('URS用户映射创建成功', [
                'urs_user_id' => $ursUserId,
                'farm_user_id' => $farmUserId,
                'mapping_id' => $mapping->id
            ]);

            // 触发用户进入农场事件
            try {
                event(new UrsUserEnteredFarmEvent($ursUserId, $farmUserId, $userKey, true));

                Log::info('URS用户进入农场事件已触发', [
                    'urs_user_id' => $ursUserId,
                    'farm_user_id' => $farmUserId,
                    'user_key_length' => $userKey ? strlen($userKey) : 0
                ]);
            } catch (\Exception $e) {
                // 事件触发失败不影响映射创建，只记录日志
                Log::error('URS用户进入农场事件触发异常', [
                    'urs_user_id' => $ursUserId,
                    'farm_user_id' => $farmUserId,
                    'error' => $e->getMessage()
                ]);
            }

            return UrsUserMappingDto::fromModel($mapping);

        } catch (\Exception $e) {
            DB::rollBack();
            Log::error('URS用户映射创建失败', [
                'urs_user_id' => $ursUserId,
                'farm_user_id' => $farmUserId,
                'error' => $e->getMessage()
            ]);
            throw $e;
        }
    }

    /**
     * 根据URS用户ID获取农场用户ID，不存在时自动创建新用户并绑定关系
     *
     * @param int $ursUserId URS用户ID
     * @param string|null $userKey 用户凭证（不存在则不创建新用户）
     * @return int|null 农场用户ID，创建失败时返回null
     */
    public static function getFarmUserId(int $ursUserId, ?string $userKey = null): ?int
    {
        // 首先尝试获取现有映射关系
        $existingFarmUserId = UrsUserMapping::getFarmUserIdByUrsUserId($ursUserId);
        if ($existingFarmUserId !== 0) {
            return $existingFarmUserId;
        }
        if ($userKey == null) {
                return 0 ;
        }
        // 不存在映射关系，自动创建新用户并建立映射
        try {
            DB::beginTransaction();

            // 生成用户名和随机密码
            $username = 'urs-' . $ursUserId;
            $password = Str::random(12);

            // 创建新用户
            $userDto = UserService::create($username, $password);
            if (is_string($userDto)) {
                // 创建失败
                DB::rollBack();
                Log::error('自动创建URS用户失败', [
                    'urs_user_id' => $ursUserId,
                    'username' => $username,
                    'error' => $userDto
                ]);
                return null;
            }

            // 创建用户映射关系
            $mapping = UrsUserMapping::create([
                'urs_user_id' => $ursUserId,
                'user_key' => $userKey,
                'user_id' => $userDto->id,
                'mapping_time' => now(),
                'status' => UrsUserMapping::STATUS_VALID,
            ]);
            self::$isFirst[$userDto->id] = $ursUserId;

            DB::commit();

            Log::info('自动创建URS用户映射成功', [
                'urs_user_id' => $ursUserId,
                'farm_user_id' => $userDto->id,
                'username' => $username,
                'mapping_id' => $mapping->id
            ]);



            return $userDto->id;

        } catch (\Exception $e) {
            DB::rollBack();
            Log::error('自动创建URS用户映射失败', [
                'urs_user_id' => $ursUserId,
                'error' => $e->getMessage()
            ]);
            return null;
        }
    }

    /**
     * 根据农场用户ID获取URS用户ID
     *
     * @param int $farmUserId 农场用户ID
     * @return int|null URS用户ID，如果未找到返回null
     */
    public static function getUrsUserId(int $farmUserId): ?int
    {
        return self::getMappingUrsUserId($farmUserId);
    }

    /**
     * 批量获取URS用户ID对应的农场用户ID
     *
     * @param array $ursUserIds URS用户ID数组
     * @return array 映射关系数组 [urs_user_id => farm_user_id]
     */
    public static function batchGetFarmUserIds(array $ursUserIds): array
    {
        return UrsUserMapping::getFarmUserIdsByUrsUserIds($ursUserIds);
    }

    /**
     * 批量获取农场用户ID对应的URS用户ID
     *
     * @param array $farmUserIds 农场用户ID数组
     * @return array 映射关系数组 [farm_user_id => urs_user_id]
     */
    public static function batchGetUrsUserIds(array $farmUserIds): array
    {
        return UrsUserMapping::getUrsUserIdsByFarmUserIds($farmUserIds);
    }

    /**
     * 检查URS用户是否已进入农场
     *
     * @param int $ursUserId URS用户ID
     * @return bool
     */
    public static function hasEnteredFarm(int $ursUserId): bool
    {
        return UrsUserMapping::hasEnteredFarm($ursUserId);
    }

    /**
     * 获取已进入农场的URS用户ID列表
     *
     * @param array $ursUserIds URS用户ID数组
     * @return array 已进入农场的URS用户ID数组
     */
    public static function getEnteredFarmUsers(array $ursUserIds): array
    {
        return UrsUserMapping::getEnteredFarmUrsUserIds($ursUserIds);
    }

    /**
     * 禁用用户映射关系
     *
     * @param int $ursUserId URS用户ID
     * @return bool
     */
    public static function disableMapping(int $ursUserId): bool
    {
        try {
            $mapping = UrsUserMapping::where('urs_user_id', $ursUserId)->first();
            if (!$mapping) {
                return false;
            }

            $mapping->status = UrsUserMapping::STATUS_INVALID;
            $mapping->save();

            Log::info('URS用户映射已禁用', [
                'urs_user_id' => $ursUserId,
                'mapping_id' => $mapping->id
            ]);

            return true;

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

    /**
     * 启用用户映射关系
     *
     * @param int $ursUserId URS用户ID
     * @return bool
     */
    public static function enableMapping(int $ursUserId): bool
    {
        try {
            $mapping = UrsUserMapping::where('urs_user_id', $ursUserId)->first();
            if (!$mapping) {
                return false;
            }

            $mapping->status = UrsUserMapping::STATUS_VALID;
            $mapping->save();

            Log::info('URS用户映射已启用', [
                'urs_user_id' => $ursUserId,
                'mapping_id' => $mapping->id
            ]);

            return true;

        } catch (\Exception $e) {
            Log::error('URS用户映射启用失败', [
                'urs_user_id' => $ursUserId,
                'error' => $e->getMessage()
            ]);
            return false;
        }
    }

    /**
     * 获取映射统计信息
     *
     * @return array
     */
    public static function getMappingStats(): array
    {
        return [
            'total_mappings' => UrsUserMapping::count(),
            'valid_mappings' => UrsUserMapping::where('status', UrsUserMapping::STATUS_VALID)->count(),
            'invalid_mappings' => UrsUserMapping::where('status', UrsUserMapping::STATUS_INVALID)->count(),
            'today_mappings' => UrsUserMapping::whereDate('created_at', today())->count(),
        ];
    }

    /**
     * 获取用户映射详情
     *
     * @param int $ursUserId URS用户ID
     * @return UrsUserMappingDto|null
     */
    public static function getMappingDetail(int $ursUserId): ?UrsUserMappingDto
    {
        $mapping = UrsUserMapping::where('urs_user_id', $ursUserId)->first();
        if (!$mapping) {
            return null;
        }

        return UrsUserMappingDto::fromModel($mapping);
    }



    /**
     * 获取ursUserId
     * @param int $userId
     * @return int
     */
    public static function getMappingUrsUserId(int $userId): int
    {
        /**
         * @var UrsUserMapping $mapping
         */
        $mapping = UrsUserMapping::where('user_id', $userId)
            ->where('status', UrsUserMapping::STATUS_VALID)
            ->first();
        if (!$mapping) {
            return 0;
        }

        return $mapping->urs_user_id;
    }

    /**
     * 验证映射关系有效性
     *
     * @param UrsUserMapping $mapping 映射关系对象
     * @return array 验证结果 ['valid' => bool, 'updated' => bool, 'details' => array, 'reasons' => array]
     */
    public static function validateMapping(UrsUserMapping $mapping): array
    {
        $result = [
            'valid' => false,
            'updated' => false,
            'details' => [],
            'reasons' => []
        ];

        try {
            $isValid = true;
            $details = [];
            $reasons = [];

            // 检查URS用户ID是否有效
            if ($mapping->urs_user_id <= 0) {
                $isValid = false;
                $reasons[] = 'URS用户ID无效';
            } else {
                $details[] = "URS用户ID: {$mapping->urs_user_id}";
            }

            // 检查农场用户ID是否有效
            if ($mapping->user_id <= 0) {
                $isValid = false;
                $reasons[] = '农场用户ID无效';
            } else {
                // 检查农场用户是否存在
                $farmUser = \App\Module\User\Models\User::find($mapping->user_id);
                if (!$farmUser) {
                    $isValid = false;
                    $reasons[] = '农场用户不存在';
                } else {
                    $details[] = "农场用户: {$farmUser->username} (ID: {$mapping->user_id})";
                }
            }

            // 检查是否存在重复映射
            $duplicateUrsMapping = UrsUserMapping::where('urs_user_id', $mapping->urs_user_id)
                ->where('id', '!=', $mapping->id)
                ->first();
            if ($duplicateUrsMapping) {
                $isValid = false;
                $reasons[] = "URS用户ID {$mapping->urs_user_id} 存在重复映射";
            }

            $duplicateFarmMapping = UrsUserMapping::where('user_id', $mapping->user_id)
                ->where('id', '!=', $mapping->id)
                ->first();
            if ($duplicateFarmMapping) {
                $isValid = false;
                $reasons[] = "农场用户ID {$mapping->user_id} 存在重复映射";
            }

            // 检查映射时间是否合理
            if ($mapping->mapping_time && $mapping->mapping_time->isFuture()) {
                $isValid = false;
                $reasons[] = '映射时间不能是未来时间';
            } else if ($mapping->mapping_time) {
                $details[] = "映射时间: {$mapping->mapping_time->format('Y-m-d H:i:s')}";
            }

            // 更新映射状态
            $originalStatus = $mapping->status;
            $newStatus = $isValid ? UrsUserMapping::STATUS_VALID : UrsUserMapping::STATUS_INVALID;

            if ($originalStatus !== $newStatus) {
                $mapping->status = $newStatus;
                $mapping->save();
                $result['updated'] = true;

                Log::info('映射关系状态已更新', [
                    'mapping_id' => $mapping->id,
                    'urs_user_id' => $mapping->urs_user_id,
                    'farm_user_id' => $mapping->user_id,
                    'old_status' => $originalStatus,
                    'new_status' => $newStatus
                ]);
            }

            $result['valid'] = $isValid;
            $result['details'] = $details;
            $result['reasons'] = $reasons;

        } catch (\Exception $e) {
            Log::error('验证映射关系失败', [
                'mapping_id' => $mapping->id,
                'error' => $e->getMessage()
            ]);

            $result['reasons'][] = '验证过程发生异常: ' . $e->getMessage();
        }

        return $result;
    }

    /**
     * 同步用户信息
     *
     * @param UrsUserMapping $mapping 映射关系对象
     * @return array 同步结果 ['success' => bool, 'updated_fields' => array, 'sync_time' => string, 'error' => string]
     */
    public static function syncUserInfo(UrsUserMapping $mapping): array
    {
        $result = [
            'success' => false,
            'updated_fields' => [],
            'sync_time' => '',
            'error' => ''
        ];

        try {
            // 检查映射状态
            if ($mapping->status !== UrsUserMapping::STATUS_VALID) {
                $result['error'] = '映射关系状态无效，无法同步';
                return $result;
            }

            // 获取农场用户信息
            $farmUser = \App\Module\User\Models\User::find($mapping->user_id);
            if (!$farmUser) {
                $result['error'] = '农场用户不存在';
                return $result;
            }

            $updatedFields = [];
            $syncTime = now()->format('Y-m-d H:i:s');

            // 这里可以根据实际需求添加从URS系统同步用户信息的逻辑
            // 目前只是模拟同步过程，更新最后同步时间

            // 模拟同步用户昵称（如果需要的话）
            $expectedUsername = 'urs-' . $mapping->urs_user_id;
            if ($farmUser->username !== $expectedUsername) {
                // 检查新用户名是否已存在
                $existingUser = \App\Module\User\Models\User::where('username', $expectedUsername)
                    ->where('id', '!=', $farmUser->id)
                    ->first();

                if (!$existingUser) {
                    $oldUsername = $farmUser->username;
                    $farmUser->username = $expectedUsername;
                    $farmUser->save();
                    $updatedFields[] = "用户名: {$oldUsername} -> {$expectedUsername}";
                }
            }

            // 更新映射记录的最后同步时间（如果表中有这个字段的话）
            // $mapping->last_sync_time = now();
            // $mapping->save();

            $result['success'] = true;
            $result['updated_fields'] = $updatedFields;
            $result['sync_time'] = $syncTime;

            Log::info('用户信息同步成功', [
                'mapping_id' => $mapping->id,
                'urs_user_id' => $mapping->urs_user_id,
                'farm_user_id' => $mapping->user_id,
                'updated_fields' => $updatedFields,
                'sync_time' => $syncTime
            ]);

        } catch (\Exception $e) {
            Log::error('用户信息同步失败', [
                'mapping_id' => $mapping->id,
                'error' => $e->getMessage()
            ]);

            $result['error'] = '同步过程发生异常: ' . $e->getMessage();
        }

        return $result;
    }

    /**
     * 获取活跃用户统计信息
     *
     * @return array
     */
    public static function getActiveUserStats(): array
    {
        return UrsUserMapping::getActiveUserStats();
    }

    /**
     * 批量更新用户活跃状态
     *
     * @param array $activeData 活跃数据 [urs_user_id => ['is_active' => 1, 'active_days_count' => 5]]
     * @return int 更新的记录数
     */
    public static function batchUpdateActiveStatus(array $activeData): int
    {
        return UrsUserMapping::batchUpdateActiveStatus($activeData);
    }

    /**
     * 获取活跃的URS用户ID列表
     *
     * @param array $ursUserIds URS用户ID数组
     * @return array 活跃的URS用户ID数组
     */
    public static function getActiveUrsUserIds(array $ursUserIds): array
    {
        return UrsUserMapping::getActiveUrsUserIds($ursUserIds);
    }

    /**
     * 检查用户是否活跃
     *
     * @param int $ursUserId URS用户ID
     * @return bool
     */
    public static function isUserActive(int $ursUserId): bool
    {
        $mapping = UrsUserMapping::where('urs_user_id', $ursUserId)
            ->where('status', UrsUserMapping::STATUS_VALID)
            ->first();

        return $mapping ? $mapping->isActive() : false;
    }

    /**
     * 更新单个用户的活跃状态
     *
     * @param int $ursUserId URS用户ID
     * @return bool
     */
    public static function updateUserActiveStatus(int $ursUserId): bool
    {
        return UrsActiveUserService::updateUserActiveStatus($ursUserId);
    }

    // ==================== userKey相关方法 ====================

    /**
     * 根据userKey获取农场用户ID
     *
     * @param string $userKey 用户凭证
     * @return int|null 农场用户ID，如果未找到返回null
     */
    public static function getFarmUserIdByUserKey(string $userKey): ?int
    {
        return UrsUserMapping::getFarmUserIdByUserKey($userKey);
    }

    /**
     * 根据userKey获取URS用户ID
     *
     * @param string $userKey 用户凭证
     * @return int|null URS用户ID，如果未找到返回null
     */
    public static function getUrsUserIdByUserKey(string $userKey): ?int
    {
        return UrsUserMapping::getUrsUserIdByUserKey($userKey);
    }

    /**
     * 根据userKey获取用户映射详情
     *
     * @param string $userKey 用户凭证
     * @return UrsUserMappingDto|null
     */
    public static function getMappingByUserKey(string $userKey): ?UrsUserMappingDto
    {
        $mapping = UrsUserMapping::findByUserKey($userKey);
        if (!$mapping) {
            return null;
        }

        return UrsUserMappingDto::fromModel($mapping);
    }

    /**
     * 批量根据userKey获取映射关系
     *
     * @param array $userKeys 用户凭证数组
     * @return array 映射关系数组 [userKey => UrsUserMappingDto]
     */
    public static function batchGetMappingsByUserKeys(array $userKeys): array
    {
        $mappings = UrsUserMapping::getMappingsByUserKeys($userKeys);
        $result = [];

        foreach ($mappings as $userKey => $mappingData) {
            $mapping = new UrsUserMapping();
            $mapping->fill($mappingData);
            $result[$userKey] = UrsUserMappingDto::fromModel($mapping);
        }

        return $result;
    }

    /**
     * 更新用户映射的userKey
     *
     * @param int $ursUserId URS用户ID
     * @param string $userKey 新的用户凭证
     * @return bool
     */
    public static function updateUserKey(int $ursUserId, string $userKey): bool
    {
        try {
            $mapping = UrsUserMapping::where('urs_user_id', $ursUserId)
                ->where('status', UrsUserMapping::STATUS_VALID)
                ->first();

            if (!$mapping) {
                Log::error('更新userKey失败：映射关系不存在', [
                    'urs_user_id' => $ursUserId,
                    'user_key' => $userKey
                ]);
                return false;
            }

            // 检查新的userKey是否已被其他用户使用
            $existingMapping = UrsUserMapping::where('user_key', $userKey)
                ->where('id', '!=', $mapping->id)
                ->where('status', UrsUserMapping::STATUS_VALID)
                ->first();

            if ($existingMapping) {
                Log::error('更新userKey失败：userKey已被其他用户使用', [
                    'urs_user_id' => $ursUserId,
                    'user_key' => $userKey,
                    'existing_urs_user_id' => $existingMapping->urs_user_id
                ]);
                return false;
            }

            $oldUserKey = $mapping->user_key;
            $mapping->user_key = $userKey;
            $mapping->save();

            Log::info('userKey更新成功', [
                'urs_user_id' => $ursUserId,
                'old_user_key' => $oldUserKey,
                'new_user_key' => $userKey,
                'mapping_id' => $mapping->id
            ]);

            return true;

        } catch (\Exception $e) {
            Log::error('更新userKey失败', [
                'urs_user_id' => $ursUserId,
                'user_key' => $userKey,
                'error' => $e->getMessage()
            ]);
            return false;
        }
    }

    /**
     * 检查userKey是否已存在
     *
     * @param string $userKey 用户凭证
     * @return bool
     */
    public static function userKeyExists(string $userKey): bool
    {
        return UrsUserMapping::where('user_key', $userKey)
            ->where('status', UrsUserMapping::STATUS_VALID)
            ->exists();
    }

    /**
     * 根据userKey创建或获取农场用户ID（支持自动创建）
     *
     * @param string $userKey 用户凭证
     * @param int $ursUserId URS用户ID
     * @return int|null 农场用户ID，创建失败时返回null
     */
    public static function getFarmUserIdByUserKeyWithAutoCreate(string $userKey, int $ursUserId): ?int
    {
        // 首先尝试根据userKey查找现有映射
        $farmUserId = self::getFarmUserIdByUserKey($userKey);
        if ($farmUserId !== null) {
            return $farmUserId;
        }

        // 如果没有找到，尝试根据ursUserId查找并更新userKey
        $existingMapping = UrsUserMapping::where('urs_user_id', $ursUserId)
            ->where('status', UrsUserMapping::STATUS_VALID)
            ->first();

        if ($existingMapping) {
            // 更新现有映射的userKey
            if (self::updateUserKey($ursUserId, $userKey)) {
                return $existingMapping->user_id;
            }
            return null;
        }

        // 如果都没有找到，自动创建新的映射关系
        return self::getFarmUserId($ursUserId, $userKey);
    }
}