<?php

namespace App\Module\UrsPromotion\Test;

use App\Module\UrsPromotion\Logics\UrsRelationCacheLogic;
use App\Module\UrsPromotion\Models\UrsUserReferral;
use App\Module\UrsPromotion\Models\UrsUserRelationCache;
use App\Module\UrsPromotion\Services\UrsReferralService;
use App\Module\UrsPromotion\Services\UrsUserMappingService;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

/**
 * URS关系缓存测试类
 */
class UrsRelationCacheTest extends TestCase
{
    use RefreshDatabase;

    private UrsRelationCacheLogic $logic;

    protected function setUp(): void
    {
        parent::setUp();
        $this->logic = new UrsRelationCacheLogic();
    }

    /**
     * 测试生成单个用户关系缓存
     */
    public function testGenerateUserRelationCache()
    {
        // 创建测试数据：A -> B -> C 的推荐关系
        $ursUserA = 1001;
        $ursUserB = 1002;
        $ursUserC = 1003;
        
        $farmUserA = 2001;
        $farmUserB = 2002;
        $farmUserC = 2003;

        // 模拟用户映射关系
        $this->mockUserMapping($ursUserA, $farmUserA);
        $this->mockUserMapping($ursUserB, $farmUserB);
        $this->mockUserMapping($ursUserC, $farmUserC);

        // 创建推荐关系：B推荐A，C推荐B
        $this->createReferral($ursUserA, $ursUserB, $farmUserA, $farmUserB);
        $this->createReferral($ursUserB, $ursUserC, $farmUserB, $farmUserC);

        // 生成用户A的关系缓存
        $result = $this->logic->generateUserRelationCache($ursUserA);
        $this->assertTrue($result);

        // 验证缓存数据
        $caches = UrsUserRelationCache::where('urs_user_id', $ursUserA)->get();
        $this->assertCount(2, $caches); // A应该有2个上级：B（直接）和C（间接）

        // 验证直接关系
        $directCache = $caches->where('depth', 1)->first();
        $this->assertNotNull($directCache);
        $this->assertEquals($farmUserA, $directCache->user_id);
        $this->assertEquals($farmUserB, $directCache->related_user_id);
        $this->assertEquals($ursUserA, $directCache->urs_user_id);
        $this->assertEquals($ursUserB, $directCache->urs_related_user_id);
        $this->assertEquals(1, $directCache->level);
        $this->assertEquals(1, $directCache->depth);

        // 验证间接关系
        $indirectCache = $caches->where('depth', 2)->first();
        $this->assertNotNull($indirectCache);
        $this->assertEquals($farmUserA, $indirectCache->user_id);
        $this->assertEquals($farmUserC, $indirectCache->related_user_id);
        $this->assertEquals($ursUserA, $indirectCache->urs_user_id);
        $this->assertEquals($ursUserC, $indirectCache->urs_related_user_id);
        $this->assertEquals(2, $indirectCache->level);
        $this->assertEquals(2, $indirectCache->depth);
    }

    /**
     * 测试清除用户关系缓存
     */
    public function testClearUserRelationCache()
    {
        $ursUserId = 1001;
        $farmUserId = 2001;

        // 创建测试缓存数据
        UrsUserRelationCache::create([
            'user_id' => $farmUserId,
            'related_user_id' => 2002,
            'urs_user_id' => $ursUserId,
            'urs_related_user_id' => 1002,
            'level' => 1,
            'path' => '2002',
            'urs_path' => '1002',
            'depth' => 1,
        ]);

        // 模拟用户映射
        $this->mockUserMapping($ursUserId, $farmUserId);

        // 清除缓存
        $result = $this->logic->clearUserRelationCache($ursUserId);
        $this->assertTrue($result);

        // 验证缓存已清除
        $count = UrsUserRelationCache::where('urs_user_id', $ursUserId)->count();
        $this->assertEquals(0, $count);
    }

    /**
     * 测试检查缓存完整性
     */
    public function testCheckRelationCacheIntegrity()
    {
        // 创建推荐关系但不生成缓存
        $this->createReferral(1001, 1002, 2001, 2002);

        $result = $this->logic->checkRelationCacheIntegrity();

        $this->assertArrayHasKey('total_users', $result);
        $this->assertArrayHasKey('users_with_cache', $result);
        $this->assertArrayHasKey('missing_users', $result);
        $this->assertEquals(1, $result['total_users']);
        $this->assertEquals(0, $result['users_with_cache']);
        $this->assertEquals(1, $result['missing_users']);
    }

    /**
     * 测试修复缓存问题
     */
    public function testFixRelationCacheIssues()
    {
        // 创建推荐关系
        $ursUserA = 1001;
        $ursUserB = 1002;
        $farmUserA = 2001;
        $farmUserB = 2002;

        $this->mockUserMapping($ursUserA, $farmUserA);
        $this->mockUserMapping($ursUserB, $farmUserB);
        $this->createReferral($ursUserA, $ursUserB, $farmUserA, $farmUserB);

        // 修复问题
        $result = $this->logic->fixRelationCacheIssues();

        $this->assertArrayHasKey('integrity', $result);
        $this->assertArrayHasKey('fixed', $result);
        $this->assertEquals(1, $result['fixed']['missing_users']);
    }

    /**
     * 创建推荐关系
     */
    private function createReferral(int $ursUserId, int $ursReferrerId, int $farmUserId, int $farmReferrerId): void
    {
        UrsUserReferral::create([
            'urs_user_id' => $ursUserId,
            'urs_referrer_id' => $ursReferrerId,
            'user_id' => $farmUserId,
            'referrer_id' => $farmReferrerId,
            'referral_time' => now(),
            'status' => UrsUserReferral::STATUS_VALID,
        ]);
    }

    /**
     * 模拟用户映射关系
     */
    private function mockUserMapping(int $ursUserId, int $farmUserId): void
    {
        // 这里应该模拟UrsUserMappingService::getFarmUserId方法
        // 在实际测试中，可能需要使用Mock或者创建真实的映射数据
    }
}