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

<?php

namespace App\Module\Farm\Logics;

use App\Module\Farm\Dtos\LandInfoDto;
use App\Module\Farm\Enums\LAND_STATUS;
use App\Module\Farm\Enums\LAND_TYPE;
use App\Module\Farm\Enums\UPGRADE_TYPE;
use App\Module\Farm\Events\LandUpgradedEvent;
use App\Module\Farm\Models\FarmLand;
use App\Module\Farm\Models\FarmLandType;
use App\Module\Farm\Models\FarmLandUpgradeConfig;
use App\Module\Farm\Models\FarmUpgradeLog;
use App\Module\Farm\Models\FarmUser;
use App\Module\Game\Services\ConsumeService;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use UCore\Dto\Res;

use UCore\Exception\LogicException;

use function Laravel\Prompts\select;

/**
 * 土地管理逻辑
 */
class LandLogic
{

    /**
     * 获取用户的所有土地
     *
     * @param int $userId
     * @return Collection|LandInfoDto[]
     */
    public function getUserLands(int $userId): Collection
    {
        try {
            $lands = FarmLand::where('user_id', $userId)
                ->orderBy('position')
                ->get();

//            dd($lands);
            return $lands->map(function ($land) {
                return LandInfoDto::fromModel($land);
            });
        } catch (\Exception $e) {
            Log::error('获取用户土地失败', [
                'user_id' => $userId,
                'error'   => $e->getMessage(),
                'trace'   => $e->getTraceAsString()
            ]);

            return collect();
        }
    }

    /**
     * 获取用户指定位置的土地
     *
     * @param int $userId
     * @param int $position
     * @return LandInfoDto|null
     */
    public function getUserLandByPosition(int $userId, int $position): ?LandInfoDto
    {
        try {
            $land = FarmLand::where('user_id', $userId)
                ->where('position', $position)
                ->first();

            if (!$land) {
                return null;
            }

            return LandInfoDto::fromModel($land);
        } catch (\Exception $e) {
            Log::error('获取用户指定位置土地失败', [
                'user_id'  => $userId,
                'position' => $position,
                'error'    => $e->getMessage(),
                'trace'    => $e->getTraceAsString()
            ]);

            return null;
        }
    }

    /**
     * 创建土地
     *
     * @param int $userId
     * @param int $position
     * @param int $landType
     * @return FarmLand|null
     */
    public function createLand(int $userId, int $position, int $landType): ?FarmLand
    {
        try {
            // 检查位置是否已有土地
            $existingLand = FarmLand::where('user_id', $userId)
                ->where('position', $position)
                ->first();

            if ($existingLand) {
                return $existingLand;
            }

            // 创建新土地
            $land            = new FarmLand();
            $land->user_id   = $userId;
            $land->position  = $position;
            $land->land_type = $landType;
            $land->status    = LAND_STATUS::IDLE->value;
            $land->save();

            Log::info('创建土地成功', [
                'user_id'   => $userId,
                'position'  => $position,
                'land_type' => $landType,
                'land_id'   => $land->id
            ]);

            return $land;
        } catch (\Exception $e) {
            Log::error('创建土地失败', [
                'user_id'   => $userId,
                'position'  => $position,
                'land_type' => $landType,
                'error'     => $e->getMessage(),
                'trace'     => $e->getTraceAsString()
            ]);

            return null;
        }
    }

    /**
     * 升级土地
     * 调用前已经检查，确保用户有足够的材料，且已经检查了升级路径
     *
     * @param int $userId
     * @param int $landId
     * @param int $targetType
     * @param array $materials 消耗的材料
     * @return bool
     */
    public function upgradeLand(int $userId, int $landId, int $targetType): bool
    {
        try {


            // 开启事务
            DB::beginTransaction();




            // 获取土地信息
            /**
             * @var FarmLand $land
             */
            $land = FarmLand::where('id', $landId)
                ->where('user_id', $userId)
                ->first();

            if (!$land) {
                throw new LogicException('土地不存在');
            }

            // 检查路径可用
            $check = self::checkUpgradePath($userId, $land->land_type, $targetType);
            if ($check->error) {
                throw new LogicException('升级路径检查不通过！');
            }
            /**
             *
             * @var FarmLandUpgradeConfig $config
             */
            $config = $check->data['config'];

            // 检查土地状态
            if ($land->status !== LAND_STATUS::IDLE->value) {
                throw new LogicException('土地状态不允许升级');
            }

            // 获取当前土地类型
            $currentType = $land->land_type;

            // 检查是否已经是目标类型
            if ($currentType === $targetType) {
                throw new LogicException('土地已经是目标类型');
            }


            // 更新土地类型
            $oldType         = $land->land_type;
            $land->land_type = $targetType;
            $land->save();


            // 创建升级记录
            $upgradeLog               = new FarmUpgradeLog();
            $upgradeLog->user_id      = $userId;
            $upgradeLog->upgrade_type = UPGRADE_TYPE::LAND->value;
            $upgradeLog->target_id    = $landId;
            $upgradeLog->old_level    = $oldType;
            $upgradeLog->new_level    = $targetType;
            $upgradeLog->materials_consumed = [];
            $upgradeLog->upgrade_time = now();
            $upgradeLog->created_at   = now();
            $upgradeLog->save();
            // 进行消耗
            $ec = ConsumeService::executeConsume($userId, $config->materials, 'land_upgrade', $upgradeLog->id, false);
            if ($ec->error) {
                throw new LogicException('消耗失败');
            }
            $upgradeLog->materials_consumed = $ec->data['list'];
            $upgradeLog->save();
            // 提交事务
            DB::commit();

            // 触发土地升级事件
            event(new LandUpgradedEvent($userId, $land, $oldType, $targetType, $upgradeLog));

            Log::info('土地升级成功', [
                'user_id'        => $userId,
                'land_id'        => $landId,
                'old_type'       => $oldType,
                'new_type'       => $targetType,
                'upgrade_log_id' => $upgradeLog->id
            ]);

            return true;
        } catch (\Exception $e) {
            // 回滚事务
            DB::rollBack();

            Log::error('土地升级失败', [
                'user_id'     => $userId,
                'land_id'     => $landId,
                'target_type' => $targetType,
                'error'       => $e->getMessage(),
                'trace'       => $e->getTraceAsString()
            ]);

            return false;
        }
    }

    /**
     * 检查升级路径
     *
     * @param $userId
     * @param $currentType
     * @param $targetType
     * @param bool $checkM 是否检查消耗
     * @return Res
     * @throws \Exception
     */
    static public function checkUpgradePath(int $userId, int $currentType, int $targetType, bool $checkM = true): Res
    {

        // 获取升级配置
        /**
         * @var FarmLandUpgradeConfig $upgradeConfig
         */
        $upgradeConfig = FarmLandUpgradeConfig::where('from_type_id', $currentType)
            ->where('to_type_id', $targetType)
            ->first();

        if (!$upgradeConfig) {
            Log::error('升级路径不存在', [
                'user_id'      => $userId,
                'current_type' => $currentType,
                'target_type'  => $targetType
            ]);
            return Res::error('升级路径不存在', [
                'user_id'      => $userId,
                'current_type' => $currentType,
                'target_type'  => $targetType
            ]);

        }

        // 检查用户房屋等级是否满足要求
        $targetLandType = FarmLandType::find($targetType);
        $farmUser       = FarmUser::where('user_id', $userId)->first();

        if (!$farmUser || $farmUser->house_level < $targetLandType->unlock_house_level) {
            Log::error('房屋等级不足，无法升级到该土地类型', [
                'user_id'            => $userId,
                'current_type'       => $currentType,
                'target_type'        => $targetType,
                'house_level'        => $farmUser->house_level,
                'unlock_house_level' => $targetLandType->unlock_house_level
            ]);
            return Res::error('房屋等级不足，无法升级到该土地类型', [
                'user_id'            => $userId,
                'current_type'       => $currentType,
                'target_type'        => $targetType,
                'house_level'        => $farmUser->house_level,
                'unlock_house_level' => $targetLandType->unlock_house_level
            ]);

        }

        // 检查特殊土地数量限制
        if ($targetLandType->is_special) {
            $specialLandCount = FarmLand::where('user_id', $userId)
                ->whereIn('land_type', [ LAND_TYPE::GOLD->value, LAND_TYPE::BLUE->value, LAND_TYPE::PURPLE->value ])
                ->count();

            $houseConfig = $farmUser->houseConfig;

            if ($specialLandCount >= $houseConfig->special_land_limit) {
                Log::error('特殊土地数量已达上限', [
                    'user_id'            => $userId,
                    'current_type'       => $currentType,
                    'target_type'        => $targetType,
                    'special_land_count' => $specialLandCount,
                    'special_land_limit' => $houseConfig->special_land_limit
                ]);
                return Res::error('特殊土地数量已达上限', [
                    'user_id'            => $userId,
                    'current_type'       => $currentType,
                    'target_type'        => $targetType,
                    'special_land_count' => $specialLandCount,
                    'special_land_limit' => $houseConfig->special_land_limit
                ]);


            }
        }

        // 检查消耗
        if ($checkM) {
            $res = ConsumeService::checkConsume($userId, $upgradeConfig->materials);
            if ($res->error) {
                Log::error('当前路径资源不足', [
                    'user_id'      => $userId,
                    'current_type' => $currentType,
                    'target_type'  => $targetType,
                    'error'        => $res->message
                ]);
                return Res::error('当前路径资源不足', [
                    'msg' => $res->message
                ]);
            }

        }

        return Res::success('升级路径可用', [
            'config' => $upgradeConfig
        ]);
    }

    /**
     * 获取升级所需材料
     *
     * @param int $currentType 当前土地类型
     * @param int $targetType 目标土地类型
     * @return array 升级所需材料
     */
    public function getUpgradeMaterials(int $currentType, int $targetType): array
    {
        try {
            // 从数据库中获取升级配置
            $upgradeConfig = FarmLandUpgradeConfig::where('from_type_id', $currentType)
                ->where('to_type_id', $targetType)
                ->first();

            if (!$upgradeConfig) {
                return [];
            }

            // 使用模型的 getUpgradeMaterials 方法获取材料
            return $upgradeConfig->getUpgradeMaterials();
        } catch (\Exception $e) {
            Log::error('获取升级所需材料失败', [
                'current_type' => $currentType,
                'target_type'  => $targetType,
                'error'        => $e->getMessage(),
                'trace'        => $e->getTraceAsString()
            ]);

            return [];
        }
    }

    /**
     * 获取可用的升级路径(不进行消耗检查)
     *
     * @param int $userId 用户ID
     * @param int $landId 土地ID
     * @param int|null $toType 目标土地类型ID（可选）
     * @return FarmLandUpgradeConfig[]
     *
     */
    public function getAvailableUpgradePaths(int $userId, int $landId, ?int $toType = null): array
    {
        try {
            // 获取土地信息
            $land = FarmLand::where('id', $landId)
                ->where('user_id', $userId)
                ->first();

            if (!$land) {
                return [];
            }

            // 获取当前土地类型
            $currentType = $land->land_type;

            // 获取用户房屋等级
            /**
             * @var FarmUser $farmUser
             */
            $farmUser = FarmUser::where('user_id', $userId)->first();

            if (!$farmUser) {
                return [];
            }

            $houseLevel = $farmUser->house_level;

            // 获取可用的升级路径
            $query = FarmLandUpgradeConfig::where('from_type_id', $currentType)
                ->with('toType');

            // 如果指定了目标类型，则只获取该类型的升级路径
            if ($toType !== null) {
                $query->where('to_type_id', $toType);
            }

            $upgradePaths = $query->get();

            // 过滤出符合房屋等级要求的升级路径
            $availablePaths = $upgradePaths->filter(function ($path) use ($houseLevel) {
                return $path->toType->unlock_house_level <= $houseLevel;
            });


            // 检查特殊土地数量限制
            $specialLandCount = FarmLand::where('user_id', $userId)
                ->whereIn('land_type', [ LAND_TYPE::GOLD->value, LAND_TYPE::BLUE->value, LAND_TYPE::PURPLE->value ])
                ->count();

            $houseConfig = $farmUser->houseConfig;

            // 如果没有找到对应的房屋配置，使用默认值0
            $specialLandLimit = $houseConfig ? $houseConfig->special_land_limit : 0;

            // 如果特殊土地已达上限，过滤掉特殊土地升级路径
            if ($specialLandCount >= $specialLandLimit) {
                $availablePaths = $availablePaths->filter(function ($path) {
                    return !$path->toType->is_special;
                });
            }

            // 格式化返回结果
            return $availablePaths->toArray();
        } catch (\Exception $e) {
            Log::error('获取可用升级路径失败', [
                'user_id' => $userId,
                'land_id' => $landId,
                'error'   => $e->getMessage(),
                'trace'   => $e->getTraceAsString()
            ]);

            return [];
        }
    }

}