kknongchang_2506/app/Module/Farm/Logics/HouseLogic.php

<?php

namespace App\Module\Farm\Logics;

use App\Module\Farm\Dtos\HouseRankDto;
use App\Module\Farm\Dtos\HouseRankItemDto;
use App\Module\Farm\Dtos\WealthRankDto;
use App\Module\Farm\Dtos\WealthRankItemDto;
use App\Module\Farm\Enums\UPGRADE_TYPE;
use App\Module\Farm\Events\HouseUpgradedEvent;
use App\Module\Farm\Models\FarmHouseConfig;
use App\Module\Farm\Models\FarmUpgradeLog;
use App\Module\Farm\Models\FarmUser;
use App\Module\Fund\Enums\FUND_TYPE;
use App\Module\User\Models\User;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

/**
 * 房屋管理逻辑
 */
class HouseLogic
{

    /**
     * 缓存键前缀
     *
     * @var string
     */
    private $cachePrefix = 'farm:house2:';

    /**
     * 缓存过期时间（秒）
     *
     * @var int
     */
    private $cacheExpiration = 20; // 24小时

    /**
     * 获取房屋配置
     *
     * @param int $level
     * @return FarmHouseConfig|null
     */
    public function getHouseConfig(int $level): ?FarmHouseConfig
    {
        try {
            // 尝试从缓存获取
            $cacheKey     = $this->cachePrefix . 'config:' . $level;
            $cachedConfig = Cache::get($cacheKey);

            if ($cachedConfig) {
                return $cachedConfig;
            }

            // 从数据库获取
            $config = FarmHouseConfig::where('level', $level)->first();

            if (!$config) {
                return null;
            }

            // 缓存结果
            Cache::put($cacheKey, $config, $this->cacheExpiration);

            return $config;
        } catch (\Exception $e) {
            Log::error('获取房屋配置失败', [
                'level' => $level,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return null;
        }
    }

    /**
     * 获取所有房屋配置
     *
     * @return array
     */
    public function getAllHouseConfigs(): array
    {
        try {
            // 尝试从缓存获取
            $cacheKey      = $this->cachePrefix . 'configs:all';
            $cachedConfigs = Cache::get($cacheKey);

            if ($cachedConfigs) {
                return $cachedConfigs;
            }

            // 从数据库获取
            $configs = FarmHouseConfig::orderBy('level')->get();

            $result = [];
            foreach ($configs as $config) {
                $result[$config->level] = [
                    'level'              => $config->level,
                    'output_bonus'       => $config->output_bonus,
                    'special_land_limit' => $config->special_land_limit,
                    'upgrade_materials'  => $config->upgrade_materials,
                    'downgrade_days'     => $config->downgrade_days,
                    'available_lands'    => $config->available_lands,
                ];
            }

            // 缓存结果
            Cache::put($cacheKey, $result, $this->cacheExpiration);

            return $result;
        } catch (\Exception $e) {
            Log::error('获取所有房屋配置失败', [
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return [];
        }
    }

    /**
     * 获取下一级房屋配置
     *
     * @param int $currentLevel
     * @return FarmHouseConfig|null
     */
    public function getNextLevelConfig(int $currentLevel): ?FarmHouseConfig
    {
        try {
            // 尝试从缓存获取
            $cacheKey     = $this->cachePrefix . 'config:' . ($currentLevel + 1);
            $cachedConfig = Cache::get($cacheKey);

            if ($cachedConfig) {
                return $cachedConfig;
            }

            // 从数据库获取
            $config = FarmHouseConfig::where('level', $currentLevel + 1)->first();

            if (!$config) {
                return null;
            }

            // 缓存结果
            Cache::put($cacheKey, $config, $this->cacheExpiration);

            return $config;
        } catch (\Exception $e) {
            Log::error('获取下一级房屋配置失败', [
                'current_level' => $currentLevel,
                'error'         => $e->getMessage(),
                'trace'         => $e->getTraceAsString()
            ]);

            return null;
        }
    }

    /**
     * 升级房屋
     *
     * 注意：此方法不处理消耗逻辑，只负责升级房屋等级和记录升级日志
     * 消耗处理应在调用此方法前完成，并将消耗的材料信息传入
     *
     * @param int $userId 用户ID
     * @param array $materials 消耗的材料记录（已经消耗完成的）
     * @return bool 升级是否成功
     */
    public function upgradeHouse(int $userId, array $materials): bool
    {
        try {
            // 获取用户农场信息
            $farmUser = FarmUser::where('user_id', $userId)->first();

            if (!$farmUser) {
                throw new \Exception('用户农场不存在');
            }

            // 获取当前房屋等级
            $currentLevel = $farmUser->house_level;

            // 获取下一级房屋配置
            $nextLevelConfig = $this->getNextLevelConfig($currentLevel);

            if (!$nextLevelConfig) {
                throw new \Exception('已达到最高等级');
            }

            // 更新用户房屋等级
            $oldLevel = $farmUser->house_level;
            $newLevel = $oldLevel + 1;

            $farmUser->house_level       = $newLevel;
            $farmUser->last_upgrade_time = now();
            $farmUser->save();

            // 创建升级记录
            $upgradeLog                     = new FarmUpgradeLog();
            $upgradeLog->user_id            = $userId;
            $upgradeLog->upgrade_type       = UPGRADE_TYPE::HOUSE->value;
            $upgradeLog->old_level          = $oldLevel;
            $upgradeLog->new_level          = $newLevel;
            $upgradeLog->materials_consumed = $materials;
            $upgradeLog->upgrade_time       = now();
            $upgradeLog->created_at         = now();
            $upgradeLog->save();

            Log::debug('HouseUpgradedEvent', []);
            // 触发房屋升级事件
            event(new HouseUpgradedEvent($userId, $farmUser, $oldLevel, $newLevel, $upgradeLog));

            Log::info('房屋升级成功', [
                'user_id'        => $userId,
                'old_level'      => $oldLevel,
                'new_level'      => $newLevel,
                'upgrade_log_id' => $upgradeLog->id
            ]);

            return true;
        } catch (\Exception $e) {
            Log::error('房屋升级失败', [
                'user_id' => $userId,
                'error'   => $e->getMessage(),
                'trace'   => $e->getTraceAsString()
            ]);

            return false;
        }
    }

    /**
     * 获取房屋等级可用的土地数量
     *
     * @param int $level 房屋等级
     * @return int 可用土地数量
     */
    public function getAvailableLandsCount(int $level): int
    {
        try {
            $config = $this->getHouseConfig($level);

            if (!$config) {
                return 0;
            }

            // 确保返回整数类型
            return $config->available_lands ? (int)$config->available_lands : 0;
        } catch (\Exception $e) {
            Log::error('获取房屋等级可用土地数量失败', [
                'level' => $level,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return 0;
        }
    }

    /**
     * 获取房屋排行榜数据
     *
     * @param int $userId 当前用户ID
     * @param int $page 页码
     * @param int $pageSize 每页数量
     * @return HouseRankDto
     */
    public function getHouseRankList(int $userId, int $page = 1, int $pageSize = 20): HouseRankDto
    {


        // 限制只显示前100名
        $maxRankLimit   = 100;
        $offset         = ($page - 1) * $pageSize;
        $cachedRankList = $this->getHouseRankListCache($userId, $page, $pageSize);
        // 调整查询限制，确保不超过前100名
        $actualLimit = min($pageSize, $maxRankLimit - $offset);
        // 从缓存数据中获取当前页的数据
        $rankList = array_slice($cachedRankList, $offset, $actualLimit);

        // 转换为DTO对象
        $rankItems = [];
        foreach ($rankList as $index => $item) {
            $rank        = $offset + $index + 1;
            $rankItems[] = HouseRankItemDto::fromArray((array)$item, $rank);
        }

        // 查询用户自己的排名

        $userRank = 0;
        foreach ($cachedRankList as $index => $item) {
            if ($item->user_id == $userId) {
                $rank     = $offset + $index + 1;
                $userRank = $rank;
            }
        }

        // 构建分页信息
        $pageInfo = [
            'page'     => $page,
            'per_page' => $pageSize,
            'total'    => min($maxRankLimit, $this->getTotalHouseRankCount())
        ];

        return new HouseRankDto($rankItems, $userRank, 1, $pageInfo);


    }

    /**
     * 排行榜缓存
     *
     * @param int $userId
     * @param int $page
     * @param int $pageSize
     * @return HouseRankDto
     */
    protected function getHouseRankListCache(int $userId, int $page = 1, int $pageSize = 20): array
    {

        // 限制只显示前100名
        $maxRankLimit = 100;
        $offset       = ($page - 1) * $pageSize;

        // 如果请求的数据超出前100名，返回空结果
        if ($offset >= $maxRankLimit) {
            return new HouseRankDto([], 0, 1, [
                'page'     => $page,
                'per_page' => $pageSize,
                'total'    => min($maxRankLimit, $this->getTotalHouseRankCount())
            ]);
        }


        // 尝试从缓存获取排行榜数据
        $cacheKey       = $this->cachePrefix . 'house_rank:top100';
        $cachedRankList = Cache::get($cacheKey);

        if (!$cachedRankList) {
            // 查询前100名排行榜数据，按房屋等级降序排列，同时获取财富值
            $cachedRankList = DB::table('farm_users as fu')
                ->join('user_infos as u', 'fu.user_id', '=', 'u.user_id')
                ->leftJoin('fund as f', function ($join) {
                    $join->on('fu.user_id', '=', 'f.user_id')
                        ->where('f.fund_id', '=', 2); // 钻石资金类型
                })
                ->select([
                             'fu.user_id',
                             'fu.house_level',
                             'u.nickname as nickname',
                             'fu.last_upgrade_time',
                             'f.balance'
                         ])
                ->orderBy('fu.house_level', 'desc')
                ->orderBy('fu.last_upgrade_time', 'asc') // 同等级按升级时间排序
                ->limit($maxRankLimit)
                ->get()
                ->toArray();

            // 缓存10分钟
            Cache::put($cacheKey, $cachedRankList, 600);
        }

        return $cachedRankList;
    }


    /**
     * 获取房屋排行榜总数（限制前100名）
     *
     * @return int
     */
    private function getTotalHouseRankCount(): int
    {
        try {
            // 获取实际用户总数，但最多返回100
            $actualCount = FarmUser::count();

            return min($actualCount, 100);
        } catch (\Exception $e) {
            Log::error('获取房屋排行榜总数失败', [
                'error' => $e->getMessage()
            ]);

            return 0;
        }
    }

    /**
     * 获取财富排行榜数据
     *
     * @param int $userId 当前用户ID
     * @param int $page 页码
     * @param int $pageSize 每页数量
     * @return WealthRankDto
     */
    public function getWealthRankList(int $userId, int $page = 1, int $pageSize = 20): WealthRankDto
    {
        try {
            // 限制只显示前100名
            $maxRankLimit = 100;
            $offset       = ($page - 1) * $pageSize;

            // 如果请求的数据超出前100名，返回空结果
            if ($offset >= $maxRankLimit) {
                return new WealthRankDto([], 0, 1, [
                    'page'     => $page,
                    'per_page' => $pageSize,
                    'total'    => min($maxRankLimit, $this->getTotalWealthRankCount())
                ]);
            }
            // 从缓存获取前100名数据
            $cachedRankList = $this->getWealthRankListCache();
//            dd($cachedRankList);
            // 调整查询限制，确保不超过前100名
            $actualLimit = min($pageSize, $maxRankLimit - $offset);
            // 从缓存数据中获取当前页的数据
            $rankList = array_slice($cachedRankList, $offset, $actualLimit);


            // 转换为DTO对象
            $rankItems = [];
            foreach ($rankList as $index => $item) {

                $rank        = $offset + $index + 1;
                $rankItems[] = WealthRankItemDto::fromArray((array)$item, $rank);
            }
            // 查询用户自己的排名
            $userRank = 0;
            foreach ($cachedRankList as $index => $item) {
                if ($item->user_id == $userId) {
                    $rank     = $offset + $index + 1;
                    $userRank = $rank;
                }
            }
            // 构建分页信息
            $pageInfo = [
                'page'     => $page,
                'per_page' => $pageSize,
                'total'    => min($maxRankLimit, $this->getTotalWealthRankCount())
            ];
            dd($rankItems);

            return new WealthRankDto($rankItems, $userRank, 1, $pageInfo);

        } catch (\Exception $e) {
            Log::error('获取财富排行榜失败', [
                'user_id'   => $userId,
                'page'      => $page,
                'page_size' => $pageSize,
                'error'     => $e->getMessage(),
                'trace'     => $e->getTraceAsString()
            ]);

            return new WealthRankDto();
        }
    }

    /**
     * 获取财富排行榜缓存数据
     *
     * @return array
     */
    private function getWealthRankListCache(): array
    {
        // 限制只显示前100名
        $maxRankLimit = 100;

        // 尝试从缓存获取排行榜数据
        $cacheKey       = $this->cachePrefix . 'wealth_rank:top100_2';
        $cachedRankList = Cache::get($cacheKey);

        if (!$cachedRankList) {
            // 查询前100名财富排行榜数据，按钻石余额降序排列，同余额按房屋等级降序排列
            $cachedRankList = DB::table('fund as f')
                ->join('user_infos as u', 'f.user_id', '=', 'u.user_id')
                ->leftJoin('farm_users as fu', 'f.user_id', '=', 'fu.user_id')
                ->select([
                             'f.user_id',
                             'f.balance',
                             'u.nickname',
                             'fu.house_level'
                         ])
                ->where('f.fund_id', FUND_TYPE::FUND2) // 钻石资金类型
                ->where('f.user_id', '>', 10000)
                ->orderBy('f.balance', 'desc')
                ->orderBy('fu.house_level', 'desc') // 同钻石余额按房屋等级排序
                ->limit($maxRankLimit)
                ->get()
                ->toArray();

            // 缓存10分钟
            Cache::put($cacheKey, $cachedRankList, 600);
        }

        return $cachedRankList;
    }


    /**
     * 获取财富排行榜总数（限制前100名）
     *
     * @return int
     */
    private function getTotalWealthRankCount(): int
    {
        try {
            // 获取实际用户总数，但最多返回100
            $actualCount = DB::table('fund')
                ->where('fund_id', 2) // 钻石资金类型
                ->count();

            return min($actualCount, 100);
        } catch (\Exception $e) {
            Log::error('获取财富排行榜总数失败', [
                'error' => $e->getMessage()
            ]);

            return 0;
        }
    }

    /**
     * 清除房屋配置缓存
     *
     * @param int|null $level
     * @return bool
     */
    public function clearHouseConfigCache(?int $level = null): bool
    {
        try {
            if ($level) {
                // 清除指定等级的缓存
                Cache::forget($this->cachePrefix . 'config:' . $level);
            } else {
                // 清除所有房屋配置缓存
                Cache::forget($this->cachePrefix . 'configs:all');

                // 清除各等级缓存
                $maxLevel = 12; // 假设最高等级为12
                for ($i = 1; $i <= $maxLevel; $i++) {
                    Cache::forget($this->cachePrefix . 'config:' . $i);
                }
            }

            return true;
        } catch (\Exception $e) {
            Log::error('清除房屋配置缓存失败', [
                'level' => $level,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return false;
        }
    }

}