<?php

namespace App\Module\GameItems\Commands;

use App\Module\Game\DCache\DismantleJsonConfig;
use Illuminate\Console\Command;
use App\Module\GameItems\Models\ItemDismantleRule;

use Illuminate\Support\Facades\Log;

/**
 * 生成物品分解配方配置表JSON数据命令
 *
 * 该命令用于从数据库中的物品分解规则表生成JSON数据文件，供客户端使用。
 * 生成的JSON文件包含分解规则的基本信息，如规则ID、适用物品、分解结果等。
 * 该命令通常在分解规则数据更新后运行，以确保客户端获取最新的分解规则数据。
 */
class GenerateDismantleJsonCommand extends Command
{
    /**
     * 命令名称和签名
     *
     * @var string
     */
    protected $signature = 'gameitems:generate-dismantle-json';

    /**
     * 命令描述
     *
     * @var string
     */
    protected $description = 'Generate dismantle.json from ItemDismantleRule table';

    /**
     * 生成分解规则JSON数据
     *
     * @return array|bool 生成的数据或失败标志
     */
    public static function generateJson()
    {
        try {
            // 查询ItemDismantleRule表中的数据，并预加载关联数据
            $rules = ItemDismantleRule::query()
                ->with([
                    'item',
                    'category',
                    'consumeGroup.consumeItems',
                    'rewardGroup.rewardItems',
                    'conditionGroup.conditionItems',
                    'results.resultItem' // 保留兼容性
                ])
                ->where('is_active', 1)
                ->orderBy('priority', 'desc')
                ->orderBy('sort_order', 'desc')
                ->get()
                ->map(function ($rule) {
                    // 构建规则数据
                    $ruleData = [
                        'id' => $rule->id,
                        'name' => $rule->name,
                        'code' => $rule->code,
                        'description' => $rule->description,
                        'priority' => $rule->priority,
                        'sort_order' => $rule->sort_order,
                        'min_rarity' => $rule->min_rarity,
                        'max_rarity' => $rule->max_rarity,
                    ];

                    // 根据规则类型添加不同的字段
                    if ($rule->item_id) {
                        $ruleData['rule_type'] = 'item';
                        $ruleData['item_id'] = $rule->item_id;
                        $ruleData['item_name'] = $rule->item->name ?? '未知物品';
                    } elseif ($rule->category_id) {
                        $ruleData['rule_type'] = 'category';
                        $ruleData['category_id'] = $rule->category_id;
                        $ruleData['category_name'] = $rule->category->name ?? '未知分类';
                    } else {
                        $ruleData['rule_type'] = 'general';
                    }

                    // 消耗组数据
                    if ($rule->consume_group_id && $rule->consumeGroup) {
                        $ruleData['consume_group'] = [
                            'id' => $rule->consumeGroup->id,
                            'name' => $rule->consumeGroup->name,
                            'items' => $rule->consumeGroup->consumeItems->map(function ($item) {
                                return [
                                    'consume_type' => $item->consume_type,
                                    'target_id' => $item->target_id,
                                    'quantity' => $item->quantity,
                                ];
                            })->toArray()
                        ];
                    }

                    // 奖励组数据
                    if ($rule->reward_group_id && $rule->rewardGroup) {
                        $ruleData['reward_group'] = [
                            'id' => $rule->rewardGroup->id,
                            'name' => $rule->rewardGroup->name,
                            'is_random' => $rule->rewardGroup->is_random,
                            'random_count' => $rule->rewardGroup->random_count,
                            'items' => $rule->rewardGroup->rewardItems->map(function ($item) {
                                return [
                                    'reward_type' => $item->reward_type,
                                    'target_id' => $item->target_id,
                                    'quantity' => $item->quantity,
                                    'weight' => $item->weight,
                                    'is_guaranteed' => $item->is_guaranteed,
                                ];
                            })->toArray()
                        ];
                    }

                    // 条件组数据
                    if ($rule->condition_group_id && $rule->conditionGroup) {
                        $ruleData['condition_group'] = [
                            'id' => $rule->conditionGroup->id,
                            'name' => $rule->conditionGroup->name,
                            'logic_type' => $rule->conditionGroup->logic_type,
                            'items' => $rule->conditionGroup->conditionItems->map(function ($item) {
                                return [
                                    'condition_type' => $item->condition_type,
                                    'target_id' => $item->target_id,
                                    'operator' => $item->operator,
                                    'value' => $item->value,
                                ];
                            })->toArray()
                        ];
                    }

                    // 兼容旧系统：处理分解结果数据
                    if ($rule->results && $rule->results->isNotEmpty()) {
                        $ruleData['legacy_results'] = $rule->results->map(function ($result) {
                            return [
                                'result_item_id' => $result->result_item_id,
                                'result_item_name' => $result->resultItem->name ?? '未知物品',
                                'min_quantity' => $result->min_quantity,
                                'max_quantity' => $result->max_quantity,
                                'base_chance' => $result->base_chance,
                                'rarity_factor' => $result->rarity_factor,
                                'quality_factor' => $result->quality_factor,
                            ];
                        })->toArray();
                    }

                    return $ruleData;
                })
                ->toArray();

            // 准备完整数据，包含生成时间
            $data = [
                'generated_ts' => time(),
                'dismantle_rules' => $rules
            ];

            return $data;
        } catch (\Exception $e) {
            Log::error('Generate dismantle.json failed: ' . $e->getMessage());
            return false;
        }
    }


    /**
     * 执行命令
     */
    public function handle()
    {
        $this->info('Generating dismantle JSON data...');

        if (DismantleJsonConfig::getData([], true)) {
            $this->info('Successfully generated dismantle.json with timestamp');
        } else {
            $this->error('Failed to generate dismantle.json');
        }
    }
}