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

<?php

namespace App\Module\Farm\Logics;

use App\Module\Farm\Dtos\CropInfoDto;
use App\Module\Farm\Dtos\HarvestResultDto;
use App\Module\Farm\Enums\GROWTH_STAGE;
use App\Module\Farm\Enums\LAND_STATUS;
use App\Module\Farm\Events\CropGrowthStageChangedEvent;
use App\Module\Farm\Events\CropHarvestedEvent;
use App\Module\Farm\Events\CropPlantedEvent;
use App\Module\Farm\Events\DisasterClearedEvent;
use App\Module\Farm\Events\LandStatusChangedEvent;
use App\Module\Farm\Models\FarmCrop;
use App\Module\Farm\Models\FarmHarvestLog;
use App\Module\Farm\Models\FarmLand;
use App\Module\Farm\Models\FarmSeed;
use App\Module\Farm\Models\FarmSeedOutput;
use App\Module\Farm\Models\FarmSowLog;
use App\Module\GameItems\Services\ItemService;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use UCore\Db\Helper;
use UCore\DcatAdmin\Herlper;
use UCore\Dto\Res;

/**
 * 作物管理逻辑
 */
class CropLogic
{
    /**
     * 获取作物信息
     *
     * @param int $cropId
     * @return CropInfoDto|null
     */
    public function getCropInfo(int $cropId): ?CropInfoDto
    {
        try {
            $crop = FarmCrop::find($cropId);

            if (!$crop) {
                return null;
            }

            return CropInfoDto::fromModel($crop);
        } catch (\Exception $e) {
            Log::error('获取作物信息失败', [
                'crop_id' => $cropId,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return null;
        }
    }

    /**
     * 获取土地上的作物信息
     *
     * @param int $landId
     * @return CropInfoDto|null
     */
    public function getCropByLandId(int $landId): ?CropInfoDto
    {
        try {
            $crop = FarmCrop::where('land_id', $landId)->first();

            if (!$crop) {
                return null;
            }

            return CropInfoDto::fromModel($crop);
        } catch (\Exception $e) {
            Log::error('获取土地作物信息失败', [
                'land_id' => $landId,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return null;
        }
    }

    /**
     * 种植作物
     *
     * @param int $userId
     * @param int $landId
     * @param int $itemId 种子物品ID
     * @return array|null 返回包含CropInfoDto和日志ID的数组，格式为['crop' => CropInfoDto, 'log_id' => int]
     * @throws \Exception
     */
    public function plantCrop(int $userId, int $landId, int $itemId): ?array
    {
        try {
            // 检查是否已开启事务
            \UCore\Db\Helper::check_tr();

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

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

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

            // 根据物品ID获取种子配置信息
            $seed = FarmSeed::where('item_id', $itemId)->first();

            if (!$seed) {
                throw new \Exception('种子配置不存在');
            }

            $seedId = $seed->id;

            // 创建作物记录
            $crop = new FarmCrop();
            $crop->land_id = $landId;
            $crop->user_id = $userId;
            $crop->seed_id = $seedId;
            $crop->plant_time = now();
            $crop->growth_stage = GROWTH_STAGE::SEED->value;
            $crop->stage_start_time = now(); // 设置当前阶段开始时间
            $crop->stage_end_time = now()->addSeconds($seed->seed_time);
            $crop->disasters = [];
            $crop->fertilized = false;
            $crop->last_disaster_check_time = null; // 初始化灾害检查时间
            $crop->can_disaster = false; // 种子期不能产生灾害
            $crop->save();

            // 创建种植日志
            $sowLog = new FarmSowLog();
            $sowLog->user_id = $userId;
            $sowLog->land_id = $landId;
            $sowLog->crop_id = $crop->id;
            $sowLog->seed_id = $seedId;
            $sowLog->sow_time = now();
            $sowLog->save();

            // 更新土地状态
            $land->status = LAND_STATUS::PLANTING->value;
            $land->save();

            // 触发作物种植事件
            event(new CropPlantedEvent($userId, $land, $crop));

            Log::info('作物种植成功', [
                'user_id' => $userId,
                'land_id' => $landId,
                'seed_id' => $seedId,
                'crop_id' => $crop->id,
                'sow_log_id' => $sowLog->id
            ]);

            return [
                'crop' => CropInfoDto::fromModel($crop),
                'log_id' => $sowLog->id
            ];
        } catch (\Exception $e) {
            // 回滚事务
            DB::rollBack();

            Log::error('作物种植失败', [
                'user_id' => $userId,
                'land_id' => $landId,
                'seed_id' => $seedId,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return null;
        }
    }

    /**
     * 收获作物
     *
     * @param int $userId
     * @param int $landId
     * @return HarvestResultDto|null
     */
    public function harvestCrop(int $userId, int $landId): Res
    {
        try {
//            事务检查

            Helper::check_tr();

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

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

            // 检查土地状态
//            if ($land->status !== LAND_STATUS::HARVESTABLE->value) {
//                throw new \Exception('土地状态不允许收获');
//            }

            // 获取作物信息
            $crop = FarmCrop::where('land_id', $landId)->first();

            if (!$crop) {
                throw new \Exception('作物不存在');
            }

            // 检查作物生长阶段
            if ($crop->growth_stage !== GROWTH_STAGE::MATURE) {
                throw new \Exception('作物未成熟，不能收获');
            }

            // 获取种子信息
            $seed = $crop->seed;

            if (!$seed) {
                throw new \Exception('种子信息不存在');
            }

            // 使用发芽期确定的最终产出果实ID，如果没有则随机选择
            if ($crop->final_output_item_id) {
                $outputItemId = $crop->final_output_item_id;
                // 获取对应的产出配置来确定数量范围
                $outputInfo = $this->getOutputInfoByItemId($seed->id, $outputItemId);
                $outputAmount = mt_rand($outputInfo['min_amount'], $outputInfo['max_amount']);

                Log::info('使用发芽期确定的最终产出果实', [
                    'crop_id' => $crop->id,
                    'final_output_item_id' => $outputItemId,
                    'output_amount' => $outputAmount
                ]);
            } else {
                // 兼容旧数据：如果没有预设的最终产出果实ID，则随机选择
                $outputInfo = $this->getRandomOutput($seed->id);
                $outputItemId = $outputInfo['item_id'];
                $outputAmount = mt_rand($outputInfo['min_amount'], $outputInfo['max_amount']);

                Log::warning('作物没有预设最终产出果实ID，使用随机选择', [
                    'crop_id' => $crop->id,
                    'seed_id' => $seed->id,
                    'random_output_item_id' => $outputItemId
                ]);
            }

            // 创建收获记录
            $harvestLog = new FarmHarvestLog();
            $harvestLog->user_id = $userId;
            $harvestLog->land_id = $landId;
            $harvestLog->crop_id = $crop->id;
            $harvestLog->seed_id = $seed->id;
            $harvestLog->output_amount = $outputAmount;
            $harvestLog->harvest_time = now();
            $harvestLog->created_at = now();
            $harvestLog->save();

            // 删除作物记录
            $crop->delete();

            // 更新土地状态
            $land->status = LAND_STATUS::IDLE;
            $land->save();




            // 触发作物收获事件
            event(new CropHarvestedEvent($userId, $land, $crop, $harvestLog, $outputItemId, $outputAmount));

            Log::info('作物收获成功', [
                'user_id' => $userId,
                'land_id' => $landId,
                'crop_id' => $crop->id,
                'seed_id' => $seed->id,
                'output_item_id' => $outputItemId,
                'output_amount' => $outputAmount,
                'harvest_log_id' => $harvestLog->id
            ]);
            // 物品入包
            ItemService::addItem($userId, $outputItemId, $outputAmount,[
                'source'=>'FarmHarve',
                'FarmHarvestLog'=>$harvestLog->id
            ]);


            return Res::success();
        } catch (\Exception $e) {
            // 回滚事务


            Log::error('作物收获失败', [
                'user_id' => $userId,
                'land_id' => $landId,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return Res::error('');
        }
    }

    /**
     * 使用化肥
     *
     * @param int $userId
     * @param int $landId
     * @return bool
     */
    public function useFertilizer(int $userId, int $landId,int $crop_growth_time): Res
    {
        try {
            Helper::check_tr();
            // 获取土地信息
            /**
             * @var FarmLand $land
             */
            $land = FarmLand::where('id', $landId)
                ->where('user_id', $userId)
                ->first();

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

            // 检查土地状态
            if ($land->status !== LAND_STATUS::PLANTING->valueInt()) {
                throw new \Exception('土地状态不允许使用化肥');
            }

            // 获取作物信息
            /**
             * @var FarmCrop $crop
             */
            $crop = FarmCrop::where('land_id', $landId)->first();

            if (!$crop) {
                throw new \Exception('作物不存在');
            }

            // 检查作物生长阶段
            if (!GROWTH_STAGE::canUseFertilizer($crop->growth_stage)) {
                throw new \Exception('当前生长阶段不能使用化肥');
            }

            // 检查是否已经使用过化肥
            if ($crop->fertilized) {
                throw new \Exception('当前阶段已经使用过化肥');
            }

            // 更新作物信息
            $crop->fertilized = true;

            // 根据 crop_growth_time 参数减少当前阶段时间
            if ($crop->stage_end_time) {
                $currentTime = now();
                $endTime = $crop->stage_end_time;
//                dd($endTime);
                $remainingTime = $currentTime->diffInSeconds($endTime, false);

                if ($remainingTime > 0) {
                    // 确保减少的时间不超过剩余时间
                    $reducedTime = min($crop_growth_time, $remainingTime);
                    $crop->stage_end_time = $endTime->subSeconds($reducedTime);

                    Log::info('化肥减少生长时间', [
                        'crop_id' => $crop->id,
                        'reduced_time' => $reducedTime,
                        'original_end_time' => $endTime->toDateTimeString(),
                        'new_end_time' => $crop->stage_end_time->toDateTimeString(),
                        'stage_start_time' => $crop->stage_start_time->toDateTimeString()
                    ]);
                }
            }

            $crop->save();

            // 触发土地状态变更事件，确保前端能够获取到土地状态变更
            // 虽然土地状态没有实际变化，但我们需要通知前端作物状态已更新
            event(new LandStatusChangedEvent(
                $userId,
                $landId,
                $land->status,  // 旧状态
                $land->status   // 新状态（实际上没有变化，但需要触发事件）
            ));

            Log::info('使用化肥成功', [
                'user_id' => $userId,
                'land_id' => $landId,
                'crop_id' => $crop->id,
                'growth_stage' => $crop->growth_stage,
                'stage_end_time' => $crop->stage_end_time
            ]);

            return Res::success('',[
                'crop_id' => $crop->id,
            ]);
        } catch (\Exception $e) {
            Log::error('使用化肥失败', [
                'user_id' => $userId,
                'land_id' => $landId,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return Res::error('使用化肥失败');
        }
    }

    /**
     * 清理灾害
     *
     * @param int $userId
     * @param int $landId
     * @param int $disasterType
     * @return bool
     */
    public function clearDisaster(int $userId, int $landId, int $disasterType): bool
    {
        try {
            // 获取土地信息
            $land = FarmLand::where('id', $landId)
                ->where('user_id', $userId)
                ->first();

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

            // 检查土地状态
            if ($land->status !== LAND_STATUS::DISASTER->value) {
                throw new \Exception('土地没有灾害');
            }

            // 获取作物信息
            $crop = FarmCrop::where('land_id', $landId)->first();

            if (!$crop) {
                throw new \Exception('作物不存在');
            }

            // 检查灾害是否存在
            $disasters = $crop->disasters ?? [];
            $disasterIndex = -1;
            $disasterInfo = null;

            foreach ($disasters as $index => $disaster) {
                if (($disaster['type'] ?? 0) == $disasterType && ($disaster['status'] ?? '') === 'active') {
                    $disasterIndex = $index;
                    $disasterInfo = $disaster;
                    break;
                }
            }

            if ($disasterIndex === -1 || !$disasterInfo) {
                throw new \Exception('指定类型的灾害不存在');
            }

            // 更新灾害状态
            $disasters[$disasterIndex]['status'] = 'cleared';
            $disasters[$disasterIndex]['cleared_at'] = now()->toDateTimeString();
            $crop->disasters = $disasters;

            // 检查是否还有其他活跃灾害
            $hasActiveDisaster = false;

            foreach ($disasters as $disaster) {
                if (($disaster['status'] ?? '') === 'active') {
                    $hasActiveDisaster = true;
                    break;
                }
            }

            // 如果没有其他活跃灾害，更新土地状态
            $oldLandStatus = $land->status;
            if (!$hasActiveDisaster) {
                $land->status = LAND_STATUS::PLANTING->value;
            }

            // 保存更改
            $crop->save();
            $land->save();

            // 如果土地状态发生了变化，触发土地状态变更事件
            if ($oldLandStatus !== $land->status) {
                event(new LandStatusChangedEvent($userId, $landId, $oldLandStatus, $land->status));
            }

            // 触发灾害清理事件
            event(new DisasterClearedEvent($userId, $crop, $disasterType, $disasterInfo));

            Log::info('灾害清理成功', [
                'user_id' => $userId,
                'land_id' => $landId,
                'crop_id' => $crop->id,
                'disaster_type' => $disasterType
            ]);

            return true;
        } catch (\Exception $e) {
            Log::error('灾害清理失败', [
                'user_id' => $userId,
                'land_id' => $landId,
                'disaster_type' => $disasterType,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return false;
        }
    }

    /**
     * 铲除作物
     *
     * @param int $userId
     * @param int $landId
     * @return bool
     */
    public function removeCrop(int $userId, int $landId): bool
    {
        try {
            // 开启事务
            DB::beginTransaction();

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

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

            // 检查土地状态
            if ($land->status === LAND_STATUS::IDLE->value) {
                throw new \Exception('土地上没有作物');
            }

            // 获取作物信息
            $crop = FarmCrop::where('land_id', $landId)->first();

            if (!$crop) {
                // 如果没有作物但土地状态不是空闲，修正土地状态
                $land->status = LAND_STATUS::IDLE->value;
                $land->save();

                DB::commit();
                return true;
            }

            // 删除作物记录
            $crop->delete();

            // 更新土地状态
            $land->status = LAND_STATUS::IDLE->value;
            $land->save();

            // 提交事务
            DB::commit();

            Log::info('铲除作物成功', [
                'user_id' => $userId,
                'land_id' => $landId,
                'crop_id' => $crop->id
            ]);

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

            Log::error('铲除作物失败', [
                'user_id' => $userId,
                'land_id' => $landId,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return false;
        }
    }

    /**
     * 更新作物生长阶段
     *
     * @param int $cropId
     * @return bool
     */
    public function updateGrowthStage(int $cropId): bool
    {
        try {
            // 获取作物信息
            $crop = FarmCrop::find($cropId);

            if (!$crop) {
                throw new \Exception('作物不存在');
            }

            // 检查是否需要更新
            if (!$crop->stage_end_time || $crop->stage_end_time > now()) {
                return false;
            }

            // 获取当前生长阶段
            $oldStage = $crop->growth_stage;

            // 计算新的生长阶段
            $newStage = $this->calculateNextStage($crop);

            // 如果阶段没有变化，不需要更新
            if ($newStage === $oldStage) {
                return false;
            }

            // 计算新阶段的结束时间
            $stageEndTime = $this->calculateStageEndTime($crop, $newStage);

            // 更新作物信息
            $crop->growth_stage = $newStage;
            $crop->stage_start_time = now(); // 设置新阶段的开始时间
            $crop->stage_end_time = $stageEndTime;
            $crop->fertilized = false; // 重置施肥状态

            // 如果进入发芽期，确定最终产出果实ID
            if ($newStage === GROWTH_STAGE::SPROUT->value && !$crop->final_output_item_id) {
                $outputInfo = $this->getRandomOutput($crop->seed_id);
                $crop->final_output_item_id = $outputInfo['item_id'];

                Log::info('作物进入发芽期，确定最终产出果实', [
                    'crop_id' => $crop->id,
                    'user_id' => $crop->user_id,
                    'seed_id' => $crop->seed_id,
                    'final_output_item_id' => $crop->final_output_item_id
                ]);
            }

            $crop->save();

            // 触发生长阶段变更事件
            event(new CropGrowthStageChangedEvent($crop->user_id, $crop, $oldStage->value, $newStage));

            Log::info('作物生长阶段更新成功', [
                'crop_id' => $cropId,
                'user_id' => $crop->user_id,
                'old_stage' => $oldStage,
                'new_stage' => $newStage,
                'stage_end_time' => $stageEndTime
            ]);

            return true;
        } catch (\Exception $e) {
            Log::error('作物生长阶段更新失败', [
                'crop_id' => $cropId,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return false;
        }
    }

    /**
     * 计算下一个生长阶段
     *
     * @param FarmCrop $crop
     * @return int
     */
    public function calculateNextStage(FarmCrop $crop): int
    {
        $currentStage = $crop->growth_stage;

        // 如果当前是成熟期，且超过一定时间，则进入枯萎期
        if ($currentStage === GROWTH_STAGE::MATURE->value) {
            // 成熟期持续时间，默认为24小时
            $matureDuration = 24 * 60 * 60;

            // 如果成熟期已经超过指定时间，则进入枯萎期
            if ($crop->stage_end_time && $crop->stage_end_time instanceof \Carbon\Carbon) {
                $endTimeMinusDuration = $crop->stage_end_time->copy()->subSeconds($matureDuration);
                if (now()->diffInSeconds($endTimeMinusDuration) > $matureDuration) {
                    return GROWTH_STAGE::WITHERED->value;
                }
            }

            return GROWTH_STAGE::MATURE->value;
        }

        // 使用阶段映射确定下一个阶段
        $stageMap = [
            GROWTH_STAGE::SEED->value => GROWTH_STAGE::SPROUT->value,
            GROWTH_STAGE::SPROUT->value => GROWTH_STAGE::GROWTH->value,
            GROWTH_STAGE::GROWTH->value => GROWTH_STAGE::MATURE->value,
            GROWTH_STAGE::MATURE->value => GROWTH_STAGE::WITHERED->value,
            GROWTH_STAGE::WITHERED->value => GROWTH_STAGE::WITHERED->value, // 枯萎期保持不变
        ];

        // 确保返回整数值
        return $stageMap[$currentStage->value()] ?? GROWTH_STAGE::WITHERED->value;
    }

    /**
     * 计算阶段结束时间
     *
     * @param FarmCrop $crop
     * @param int $stage
     * @return \Carbon\Carbon|null
     */
    private function calculateStageEndTime(FarmCrop $crop, int $stage)
    {
        $seed = $crop->seed;

        if (!$seed) {
            return null;
        }

        $now = now();

        switch ($stage) {
            case GROWTH_STAGE::SEED->value:
                return $now->addSeconds($seed->seed_time);

            case GROWTH_STAGE::SPROUT->value:
                return $now->addSeconds($seed->sprout_time);

            case GROWTH_STAGE::GROWTH->value:
                return $now->addSeconds($seed->growth_time);

            case GROWTH_STAGE::MATURE->value:
                // 成熟期持续24小时后进入枯萎期
                return $now->addHours(24);

            case GROWTH_STAGE::WITHERED->value:
                // 枯萎期没有结束时间
                return null;

            default:
                return null;
        }
    }

    /**
     * 获取随机产出
     *
     * @param int $seedId
     * @return array
     */
    private function getRandomOutput(int $seedId): array
    {
        // 获取种子的所有产出配置
        $outputs = FarmSeedOutput::where('seed_id', $seedId)->get();

        if ($outputs->isEmpty()) {
            // 如果没有产出配置，使用种子的默认产出
            $seed = FarmSeed::find($seedId);

            return [
                'item_id' => $seed->item_id,
                'min_amount' => $seed->min_output,
                'max_amount' => $seed->max_output,
            ];
        }

        // 按概率排序
        $outputs = $outputs->sortByDesc('probability');

        // 获取默认产出
        $defaultOutput = $outputs->firstWhere('is_default', true);

        // 随机选择产出
        $random = mt_rand(1, 100);
        $cumulativeProbability = 0;

        foreach ($outputs as $output) {
            $cumulativeProbability += $output->probability;

            if ($random <= $cumulativeProbability) {
                return [
                    'item_id' => $output->item_id,
                    'min_amount' => $output->min_amount,
                    'max_amount' => $output->max_amount,
                ];
            }
        }

        // 如果随机值超过了所有概率之和，使用默认产出
        if ($defaultOutput) {
            return [
                'item_id' => $defaultOutput->item_id,
                'min_amount' => $defaultOutput->min_amount,
                'max_amount' => $defaultOutput->max_amount,
            ];
        }

        // 如果没有默认产出，使用第一个产出
        $firstOutput = $outputs->first();

        return [
            'item_id' => $firstOutput->item_id,
            'min_amount' => $firstOutput->min_amount,
            'max_amount' => $firstOutput->max_amount,
        ];
    }

    /**
     * 根据物品ID获取产出配置信息
     *
     * @param int $seedId
     * @param int $itemId
     * @return array
     */
    private function getOutputInfoByItemId(int $seedId, int $itemId): array
    {
        // 获取种子的所有产出配置
        $outputs = FarmSeedOutput::where('seed_id', $seedId)->get();

        // 查找匹配的产出配置
        $targetOutput = $outputs->firstWhere('item_id', $itemId);

        if ($targetOutput) {
            return [
                'item_id' => $targetOutput->item_id,
                'min_amount' => $targetOutput->min_amount,
                'max_amount' => $targetOutput->max_amount,
            ];
        }

        // 如果没有找到匹配的产出配置，使用种子的默认产出
        $seed = FarmSeed::find($seedId);

        return [
            'item_id' => $itemId, // 使用传入的物品ID
            'min_amount' => $seed->min_output,
            'max_amount' => $seed->max_output,
        ];
    }
}