<?php

namespace App\Module\AppGame\Handler\Promotion;

use App\Module\AppGame\Handler\BaseHandler;
use App\Module\UrsPromotion\Services\UrsUserMappingService;
use App\Module\UrsPromotion\Services\UrsReferralService;
use App\Module\UrsPromotion\Services\UrsTalentService;
use App\Module\User\Services\UserActivityService;
use App\Module\Fund\Enums\FUND_TYPE;
use App\Module\Game\Enums\REWARD_SOURCE_TYPE;
use App\Module\Game\Models\GameRewardLog;
use App\Module\Fund\Models\FundLogModel;
use App\Module\GameItems\Models\ItemTransactionLog;
use Google\Protobuf\Internal\Message;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\DB;
use Uraus\Kku\Request\RequestPromotionInfo;
use Uraus\Kku\Response\ResponsePromotionInfo;
use Uraus\Kku\Common\Reward;
use Uraus\Kku\Common\RewardCoin;
use Carbon\Carbon;

/**
 * 处理推广团队信息请求
 *
 * 获取用户的推广团队统计信息，包括：
 * - 总人数、直推人数、间推人数
 * - 今日新增统计
 * - 团队活跃人数统计
 * - 达人等级信息
 */
class InfoHandler extends BaseHandler
{
    /**
     * 是否需要登录
     * @var bool
     */
    protected bool $need_login = true;

    /**
     * 处理推广团队信息请求
     *
     * @param RequestPromotionInfo $data 推广团队信息请求数据
     * @return ResponsePromotionInfo 推广团队信息响应
     */
    public function handle(Message $data): Message
    {
        // 创建响应对象
        $response = new ResponsePromotionInfo();

        try {
            // 更新用户活动时间
            $this->updateUserActivityTime();

            // 获取当前农场用户对应的URS用户ID
            $ursUserId = UrsUserMappingService::getUrsUserId($this->user_id);
            if (!$ursUserId) {
                // 用户未进入URS推广系统，返回空数据
                Log::info('用户未进入URS推广系统', [
                    'user_id' => $this->user_id
                ]);
                return $this->setEmptyResponse($response);
            }

            // 获取推广关系统计
            $referralStats = UrsReferralService::getReferralStats($ursUserId);
            
            // 获取今日统计数据
            $todayStats = $this->getTodayStats($ursUserId);
            
            // 获取活跃用户统计
            $activeStats = $this->getActiveStats($ursUserId);

            // 获取收益统计
            $rewardStats = $this->getRewardStats($ursUserId);

            // 获取达人等级信息
            $talentInfo = UrsTalentService::getTalentInfo($ursUserId);
            $starLevel = $talentInfo ? $talentInfo->talentLevel : 0;

            // 设置响应数据
            $response->setTotalCount($referralStats['total_team_count'] ?? 0);
            $response->setDirectCount($referralStats['direct_count'] ?? 0);
            $response->setIndirectCount($referralStats['indirect_count'] ?? 0);
            $response->setDayRecentCount($todayStats['team_new_count'] ?? 0);
            $response->setDayDirectCount($todayStats['direct_new_count'] ?? 0);
            $response->setActiveCount($activeStats['team_active_count'] ?? 0);
            $response->setDirectActiveCount($activeStats['direct_active_count'] ?? 0);
            $response->setStarLevel($starLevel);

            // 设置收益数据
            if ($rewardStats['today_reward']) {
                $response->setTodayReward($rewardStats['today_reward']);
            }
            if ($rewardStats['total_reward']) {
                $response->setTotalReward($rewardStats['total_reward']);
            }

            Log::info('推广团队信息获取成功', [
                'user_id' => $this->user_id,
                'urs_user_id' => $ursUserId,
                'total_count' => $referralStats['total_team_count'] ?? 0,
                'direct_count' => $referralStats['direct_count'] ?? 0
            ]);

        } catch (\Exception $e) {
            Log::error('获取推广团队信息失败', [
                'user_id' => $this->user_id,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);
            
            // 发生错误时返回空数据
            return $this->setEmptyResponse($response);
        }

        return $response;
    }

    /**
     * 设置空响应数据
     *
     * @param ResponsePromotionInfo $response
     * @return ResponsePromotionInfo
     */
    private function setEmptyResponse(ResponsePromotionInfo $response): ResponsePromotionInfo
    {
        $response->setTotalCount(0);
        $response->setDirectCount(0);
        $response->setIndirectCount(0);
        $response->setDayRecentCount(0);
        $response->setDayDirectCount(0);
        $response->setActiveCount(0);
        $response->setDirectActiveCount(0);
        
        return $response;
    }

    /**
     * 获取今日统计数据
     *
     * @param int $ursUserId URS用户ID
     * @return array
     */
    private function getTodayStats(int $ursUserId): array
    {
        try {
            $teamMembers = UrsReferralService::getTeamMembers($ursUserId);
            
            $directNewCount = 0;
            $teamNewCount = 0;
            
            // 统计今日新增的直推用户
            if (!empty($teamMembers[1])) {
                foreach ($teamMembers[1] as $directMember) {
                    $farmUserId = UrsUserMappingService::getFarmUserId($directMember);
                    if ($farmUserId) {
                        // 检查用户映射创建时间是否为今日
                        $mapping = UrsUserMappingService::getMappingDetail($directMember);
                        if ($mapping && $mapping->mappingTime && 
                            Carbon::parse($mapping->mappingTime)->isToday()) {
                            $directNewCount++;
                            $teamNewCount++;
                        }
                    }
                }
            }
            
            // 统计今日新增的间推和三推用户
            foreach ([2, 3] as $level) {
                if (!empty($teamMembers[$level])) {
                    foreach ($teamMembers[$level] as $member) {
                        $farmUserId = UrsUserMappingService::getFarmUserId($member);
                        if ($farmUserId) {
                            $mapping = UrsUserMappingService::getMappingDetail($member);
                            if ($mapping && $mapping->mappingTime && 
                                Carbon::parse($mapping->mappingTime)->isToday()) {
                                $teamNewCount++;
                            }
                        }
                    }
                }
            }
            
            return [
                'direct_new_count' => $directNewCount,
                'team_new_count' => $teamNewCount
            ];
            
        } catch (\Exception $e) {
            Log::error('获取今日统计数据失败', [
                'urs_user_id' => $ursUserId,
                'error' => $e->getMessage()
            ]);

            return [
                'direct_new_count' => 0,
                'team_new_count' => 0
            ];
        }
    }

    /**
     * 获取活跃用户统计
     *
     * @param int $ursUserId URS用户ID
     * @return array
     */
    private function getActiveStats(int $ursUserId): array
    {
        try {
            $teamMembers = UrsReferralService::getTeamMembers($ursUserId);
            $activeThreshold = Carbon::now()->subHours(24); // 24小时内活跃

            $directActiveCount = 0;
            $teamActiveCount = 0;

            // 统计直推活跃用户
            if (!empty($teamMembers[1])) {
                foreach ($teamMembers[1] as $directMember) {
                    $farmUserId = UrsUserMappingService::getFarmUserId($directMember);
                    if ($farmUserId) {
                        $lastActivity = UserActivityService::getLastActivityTime($farmUserId);
                        if ($lastActivity && $lastActivity->gt($activeThreshold)) {
                            $directActiveCount++;
                            $teamActiveCount++;
                        }
                    }
                }
            }

            // 统计间推和三推活跃用户
            foreach ([2, 3] as $level) {
                if (!empty($teamMembers[$level])) {
                    foreach ($teamMembers[$level] as $member) {
                        $farmUserId = UrsUserMappingService::getFarmUserId($member);
                        if ($farmUserId) {
                            $lastActivity = UserActivityService::getLastActivityTime($farmUserId);
                            if ($lastActivity && $lastActivity->gt($activeThreshold)) {
                                $teamActiveCount++;
                            }
                        }
                    }
                }
            }

            return [
                'direct_active_count' => $directActiveCount,
                'team_active_count' => $teamActiveCount
            ];

        } catch (\Exception $e) {
            Log::error('获取活跃用户统计失败', [
                'urs_user_id' => $ursUserId,
                'error' => $e->getMessage()
            ]);

            return [
                'direct_active_count' => 0,
                'team_active_count' => 0
            ];
        }
    }

    /**
     * 获取收益统计
     *
     * @param int $ursUserId URS用户ID
     * @return array
     */
    private function getRewardStats(int $ursUserId): array
    {
        try {
            // 获取对应的农场用户ID
            $farmUserId = UrsUserMappingService::getFarmUserId($ursUserId);
            if (!$farmUserId) {
                Log::info('URS用户未映射到农场用户', ['urs_user_id' => $ursUserId]);
                return [
                    'today_reward' => null,
                    'total_reward' => null
                ];
            }

            // 获取今日收益统计
            $today = Carbon::today()->format('Y-m-d');
            $tomorrow = Carbon::tomorrow()->format('Y-m-d');
            $todayStats = $this->getRewardStatsFromLogs($farmUserId, $today, $tomorrow);

            // 获取总收益统计
            $totalStats = $this->getRewardStatsFromLogs($farmUserId);

            // 构建今日收益Reward对象
            $todayReward = null;
            if ($todayStats['total_amount'] > 0) {
                $todayReward = $this->buildRewardFromStats($todayStats);
            }

            // 构建总收益Reward对象
            $totalReward = null;
            if ($totalStats['total_amount'] > 0) {
                $totalReward = $this->buildRewardFromStats($totalStats);
            }

            return [
                'today_reward' => $todayReward,
                'total_reward' => $totalReward
            ];

        } catch (\Exception $e) {
            Log::error('获取收益统计失败', [
                'urs_user_id' => $ursUserId,
                'error' => $e->getMessage()
            ]);

            return [
                'today_reward' => null,
                'total_reward' => null
            ];
        }
    }

    /**
     * 从物品模块和资金模块的日志中获取收益统计
     *
     * @param int $farmUserId 农场用户ID
     * @param string|null $startDate 开始日期
     * @param string|null $endDate 结束日期
     * @return array
     */
    private function getRewardStatsFromLogs(int $farmUserId, ?string $startDate = null, ?string $endDate = null): array
    {
        $stats = [
            'total_amount' => 0,
            'total_count' => 0,
            'by_source_type' => []
        ];

        try {
            // URS推广相关的收益来源类型
            $ursPromotionSourceTypes = [
                REWARD_SOURCE_TYPE::URSPROMOTION_HAVEST->value,
                REWARD_SOURCE_TYPE::URSPROMOTION_BACKFILL->value,
                REWARD_SOURCE_TYPE::URSPROMOTION_REWARD->value,
                REWARD_SOURCE_TYPE::URSPROMOTION_REGISTER->value,
                REWARD_SOURCE_TYPE::URSPROMOTION_LEVEL->value,
            ];

            // 1. 从奖励日志表中统计物品奖励
            $rewardQuery = GameRewardLog::where('user_id', $farmUserId)
                ->whereIn('source_type', $ursPromotionSourceTypes);

            if ($startDate) {
                $rewardQuery->where('created_at', '>=', $startDate);
            }
            if ($endDate) {
                $rewardQuery->where('created_at', '<=', $endDate);
            }

            $rewardLogs = $rewardQuery->get();

            foreach ($rewardLogs as $log) {
                $stats['total_count']++;

                // 解析奖励物品，计算等价钻石价值
                $rewardItems = is_array($log->reward_items) ? $log->reward_items : (json_decode($log->reward_items, true) ?? []);
                $itemValue = $this->calculateItemsValue($rewardItems);
                $stats['total_amount'] += $itemValue;

                // 按来源类型统计
                $sourceType = $log->source_type;
                if (!isset($stats['by_source_type'][$sourceType])) {
                    $stats['by_source_type'][$sourceType] = ['amount' => 0, 'count' => 0];
                }
                $stats['by_source_type'][$sourceType]['amount'] += $itemValue;
                $stats['by_source_type'][$sourceType]['count']++;
            }

            // 2. 从资金日志表中统计钻石奖励
            $fundQuery = FundLogModel::where('user_id', $farmUserId)
                ->where('fund_id', FUND_TYPE::FUND2->value) // 钻石类型
                ->where('amount', '>', 0) // 只统计收入
                ->where('remark', 'like', '%推广%'); // 包含推广关键词的备注

            if ($startDate) {
                $fundQuery->where('create_time', '>=', strtotime($startDate));
            }
            if ($endDate) {
                $fundQuery->where('create_time', '<=', strtotime($endDate));
            }

            $fundLogs = $fundQuery->get();

            foreach ($fundLogs as $log) {
                $stats['total_count']++;
                $stats['total_amount'] += (float)$log->amount;

                // 按备注内容推断来源类型
                $sourceType = $this->inferSourceTypeFromRemark($log->remark);
                if (!isset($stats['by_source_type'][$sourceType])) {
                    $stats['by_source_type'][$sourceType] = ['amount' => 0, 'count' => 0];
                }
                $stats['by_source_type'][$sourceType]['amount'] += (float)$log->amount;
                $stats['by_source_type'][$sourceType]['count']++;
            }

        } catch (\Exception $e) {
            Log::error('从日志获取收益统计失败', [
                'farm_user_id' => $farmUserId,
                'start_date' => $startDate,
                'end_date' => $endDate,
                'error' => $e->getMessage()
            ]);
        }

        return $stats;
    }

    /**
     * 计算物品的等价钻石价值
     *
     * @param array $rewardItems 奖励物品数组
     * @return float
     */
    private function calculateItemsValue(array $rewardItems): float
    {
        $totalValue = 0;

        foreach ($rewardItems as $item) {
            // 简单的物品价值计算，可以根据实际需求调整
            // 这里假设每个物品价值1钻石，实际应该查询物品配置表
            $quantity = $item['quantity'] ?? 1;
            $totalValue += $quantity * 1; // 每个物品按1钻石计算
        }

        return $totalValue;
    }

    /**
     * 从备注推断收益来源类型
     *
     * @param string $remark 备注内容
     * @return string
     */
    private function inferSourceTypeFromRemark(string $remark): string
    {
        if (strpos($remark, '收获') !== false) {
            return REWARD_SOURCE_TYPE::URSPROMOTION_HAVEST->value;
        }
        if (strpos($remark, '补发') !== false) {
            return REWARD_SOURCE_TYPE::URSPROMOTION_BACKFILL->value;
        }
        if (strpos($remark, '注册') !== false) {
            return REWARD_SOURCE_TYPE::URSPROMOTION_REGISTER->value;
        }
        if (strpos($remark, '等级') !== false) {
            return REWARD_SOURCE_TYPE::URSPROMOTION_LEVEL->value;
        }

        return REWARD_SOURCE_TYPE::URSPROMOTION_REWARD->value; // 默认推广奖励
    }

    /**
     * 从统计数据构建Reward对象
     *
     * @param array $stats 统计数据
     * @return Reward
     */
    private function buildRewardFromStats(array $stats): Reward
    {
        $reward = new Reward();

        // 创建代币奖励列表
        $coins = [];

        // 推广收益和种植收益都以钻石形式显示
        if ($stats['total_amount'] > 0) {
            $rewardCoin = new RewardCoin();
            $rewardCoin->setType(FUND_TYPE::FUND2->value); // 钻石类型
            $rewardCoin->setQuantity((float)$stats['total_amount']);
            $coins[] = $rewardCoin;
        }

        $reward->setCoins($coins);

        // 其他奖励类型暂时为空
        $reward->setItems([]);
        $reward->setGods([]);
        $reward->setLands([]);
        $reward->setPets([]);
        $reward->setPetPowers([]);
        $reward->setSkins([]);

        return $reward;
    }
}