// 种田功能测试场景

import Unit from '../../objects/Unit.js';
import Crop from '../../objects/Crop.js';
import { InputSystem } from '../../systems/InputSystem.js';
import { SelectionSystem } from '../../systems/SelectionSystem.js';
import { CommandSystem } from '../../systems/CommandSystem.js';
import { ItemManager } from '../../items/ItemManager.js';
import { Inventory } from '../../items/Inventory.js';
import { InventoryUI } from '../../ui/InventoryUI.js';

export default class FarmingTestScene extends Phaser.Scene {
  constructor() {
    super({ key: 'FarmingTestScene' });
    this.isPlantingMode = false;
    this.selectedSeed = null;
  }
  
  preload() {
    // 加载物品数据
    this.load.json('items', './data/items.json');
  }
  
  create() {
    // 物理世界和相机边界
    const worldSize = 1000;
    this.physics.world.setBounds(-worldSize, -worldSize, worldSize * 2, worldSize * 2);
    this.cameras.main.setBounds(-worldSize, -worldSize, worldSize * 2, worldSize * 2);
    
    // 初始化系统
    this.inputSystem = new InputSystem(this, {
      keyboard: true,
      mouse: true,
      joystick: false,
      selection: true
    });
    this.selectionSystem = new SelectionSystem(this);
    this.commandSystem = new CommandSystem(this);
    
    // 创建单位组
    this.unitGroup = this.add.group();
    
    // 创建背景
    this.createBackground();
    
    // 创建玩家
    this.createPlayer();
    
    // 初始化物品管理器
    this.itemManager = new ItemManager(this);
    
    // 初始化背包系统
    this.initInventory();
    
    // 创建作物组
    this.cropGroup = this.add.group();
    
    // 设置输入处理
    this.setupInput();
    
    // 创建侧边栏UI
    this.createSidebar();
    
    // 显示提示信息
    this.showInstructions();
    
    // 显示单位状态
    this.updateUnitStatus(this.player);
    
    // 显示默认提示
    this.generalInfoText.setText('欢迎使用种田功能测试场景');
    
    // 监听种植事件
    this.events.on('plant-seed', (seed, user) => {
      console.log('DEBUG: FarmingTestScene 收到 plant-seed 事件');
      this.startPlantingMode(seed, user);
    });
    
    // 监听作物收获事件
    this.events.on('crop-harvested', (crop) => {
      console.log('DEBUG: FarmingTestScene 收到 crop-harvested 事件');
      this.harvestCrop(crop);
    });
    
    // 监听显示消息事件
    this.events.on('show-message', (message) => {
      console.log(`DEBUG: FarmingTestScene 收到 show-message 事件: ${message}`);
      this.showMessage(message);
    });
    
    // 初始化测试物品
    this.itemManager.onDataLoaded(() => {
      this.initTestItems();
    });
  }
  
  /**
   * 创建背景
   */
  createBackground() {
    // 创建纯色背景
    this.add.rectangle(0, 0, this.sys.game.config.width, this.sys.game.config.height, 0x1a1a2e);
    
    // 创建网格地面
    const gridGraphics = this.add.graphics();
    gridGraphics.lineStyle(1, 0x333333, 0.5);
    
    const gridSize = 32;
    const gridCount = 50;
    
    for (let x = -gridCount; x <= gridCount; x++) {
      gridGraphics.moveTo(x * gridSize, -gridCount * gridSize);
      gridGraphics.lineTo(x * gridSize, gridCount * gridSize);
    }
    
    for (let y = -gridCount; y <= gridCount; y++) {
      gridGraphics.moveTo(-gridCount * gridSize, y * gridSize);
      gridGraphics.lineTo(gridCount * gridSize, y * gridSize);
    }
    
    gridGraphics.stroke();
  }
  
  /**
   * 创建玩家
   */
  createPlayer() {
    // 为玩家创建纯色纹理
    if (!this.textures.exists('player')) {
      const canvas = document.createElement('canvas');
      canvas.width = 32;
      canvas.height = 32;
      const ctx = canvas.getContext('2d');
      ctx.fillStyle = '#4a90e2';
      ctx.beginPath();
      ctx.arc(16, 16, 16, 0, Math.PI * 2);
      ctx.fill();
      this.textures.addCanvas('player', canvas);
    }
    
    // 创建玩家单位
    this.player = new Unit(this, 0, 0, 'player');
    
    // 设置玩家属性
    this.player.name = '测试玩家';
    this.player.health = 100;
    this.player.nutrition = 100;
    this.player.hydration = 100;
    this.player.equipWeapon = function(weapon) {
      this.weapon = weapon;
      console.log(`${this.name} 装备了 ${weapon.name}`);
    };
    
    // 添加到单位组
    this.unitGroup.add(this.player);
    
    // 自动选中玩家
    this.events.emit('select-unit', this.player);
    
    // 添加碰撞检测
    this.physics.add.collider(this.unitGroup, this.unitGroup);
    
    // 保持相机中心在世界原点
    this.cameras.main.centerOn(0, 0);
  }
  
  /**
   * 初始化背包系统
   */
  initInventory() {
    // 创建背包（6x4网格）
    this.player.inventory = new Inventory(6, 4);
    
    // 创建背包UI
    this.inventoryUI = new InventoryUI(this, this.player.inventory, 40);
  }
  
  /**
   * 初始化测试物品
   */
  initTestItems() {
    // 给玩家添加一些种子
    const wheatSeed = this.itemManager.createItem('wheat_seed', 0, 0);
    const carrotSeed = this.itemManager.createItem('carrot_seed', 0, 0);
    
    // 将种子添加到玩家背包
    if (wheatSeed) {
      this.player.inventory.addItem(wheatSeed);
      wheatSeed.destroy();
    }
    
    if (carrotSeed) {
      this.player.inventory.addItem(carrotSeed);
      carrotSeed.destroy();
    }
    
    // 更新背包UI
    this.inventoryUI.updateUI();
  }
  
  /**
   * 设置输入处理
   */
  setupInput() {
    console.log('DEBUG: setupInput 方法被调用');
    
    // 键盘输入
    this.cursors = this.input.keyboard.createCursorKeys();
    
    // 背包快捷键（B键）
    this.input.keyboard.on('keydown-B', () => {
      console.log('DEBUG: B键被按下，切换背包显示');
      this.inventoryUI.toggle();
    });
    
    // 使用物品快捷键（Q键）
    this.input.keyboard.on('keydown-Q', () => {
      console.log('DEBUG: Q键被按下，尝试使用选中的物品');
      if (this.inventoryUI && this.inventoryUI.selectedItem) {
        console.log('DEBUG: 有选中的物品，调用useItem方法');
        this.inventoryUI.useItem(this.inventoryUI.selectedItem);
      }
    });
    
    // 空格键返回启动场景
    this.input.keyboard.on('keydown-SPACE', () => {
      console.log('DEBUG: 空格键被按下，返回启动场景');
      this.scene.start('BootScene');
    });
    
    // 鼠标点击处理
    this.input.on('pointerdown', (pointer) => {
      console.log(`DEBUG: 鼠标点击事件触发，按键: ${pointer.button}, 位置: x=${pointer.x}, y=${pointer.y}`);
      console.log(`DEBUG: 当前种植模式状态: isPlantingMode=${this.isPlantingMode}, selectedSeed=${this.selectedSeed ? this.selectedSeed.name : 'null'}`);
      
      // 检查点击位置是否在UI元素上（背包UI或侧边栏）
      const isUIClick = this.isPointInUI(pointer);
      console.log(`DEBUG: 是否点击在UI元素上: ${isUIClick}`);
      
      if (pointer.rightButtonDown()) {
        // 右键点击取消种植模式
        console.log('DEBUG: 鼠标右键点击，取消种植模式');
        this.cancelPlantingMode();
      } else if (this.isPlantingMode && this.selectedSeed && !isUIClick) {
        // 左键点击地面种植作物，确保不是点击UI元素
        console.log('DEBUG: 满足种植条件且不是UI点击，调用 plantSeedAt 方法');
        this.plantSeedAt(pointer);
      }
    });
    
    // 创建交互按钮
    this.createButtons();
    console.log('DEBUG: 输入处理设置完成');
  }
  
  /**
   * 创建交互按钮
   */
  createButtons() {
    const buttonWidth = 200;
    const buttonHeight = 40;
    const buttonY = this.sys.game.config.height - 150;
    
    // 创建拾取物品按钮
    this.createButton(this.sys.game.config.width - buttonWidth - 10, buttonY - 50, '拾取物品(F)', () => {
      // 调用与F键相同的拾取功能
      this.inputSystem.handleQuickPickup();
    });
    
    // 创建背包按钮
    this.createButton(this.sys.game.config.width - buttonWidth - 10, buttonY, '打开/关闭背包', () => {
      this.inventoryUI.toggle();
    });
    
    // 创建随机物品按钮
    this.createButton(this.sys.game.config.width - buttonWidth - 10, buttonY + 50, '创建随机种子', () => {
      const seedTypes = ['wheat_seed', 'carrot_seed'];
      const randomSeedType = seedTypes[Math.floor(Math.random() * seedTypes.length)];
      this.itemManager.createItem(randomSeedType, this.player.x + 50, this.player.y);
    });
    
    // 创建返回菜单按钮
    this.createButton(this.sys.game.config.width - buttonWidth - 10, buttonY + 100, '返回菜单', () => {
      this.scene.start('BootScene');
    });
  }
  
  /**
   * 创建按钮
   */
  createButton(x, y, text, callback) {
    // 创建按钮背景
    const button = this.add.rectangle(x, y, 200, 40, 0x333333);
    button.setOrigin(0.5, 0.5);
    button.setScrollFactor(0, 0);
    button.setDepth(15);
    
    // 创建按钮文本
    const buttonText = this.add.text(x, y, text, {
      fontSize: '16px',
      fill: '#ffffff',
      fontFamily: 'Arial'
    });
    buttonText.setOrigin(0.5, 0.5);
    buttonText.setScrollFactor(0, 0);
    buttonText.setDepth(16);
    
    // 设置按钮交互
    button.setInteractive({
      useHandCursor: true
    });
    
    // 按钮事件
    button.on('pointerdown', callback);
    
    button.on('pointerover', () => {
      button.setFillStyle(0x555555);
    });
    
    button.on('pointerout', () => {
      button.setFillStyle(0x333333);
    });
  }
  
  /**
   * 开始种植模式
   */
  startPlantingMode(seed, user) {
    console.log('DEBUG: startPlantingMode 方法被调用');
    console.log(`DEBUG: 种子信息: ${JSON.stringify(seed.getInfo())}`);
    
    this.isPlantingMode = true;
    this.selectedSeed = seed;
    console.log(`DEBUG: 设置 isPlantingMode = ${this.isPlantingMode}, selectedSeed = ${this.selectedSeed.name}`);
    
    this.generalInfoText.setText(`点击地面种植 ${seed.name}`);
    console.log(`DEBUG: 更新提示信息: 点击地面种植 ${seed.name}`);
    
    // 显示种植光标，初始位置设置为当前鼠标位置
    console.log(`DEBUG: 当前鼠标位置: x=${this.input.mousePointer.x}, y=${this.input.mousePointer.y}`);
    this.plantingCursor = this.add.text(this.input.mousePointer.x, this.input.mousePointer.y, '🌱', { 
      fontSize: '24px' 
    });
    
    console.log(`DEBUG: 种植光标创建结果: ${this.plantingCursor ? '成功' : '失败'}`);
    
    this.plantingCursor.setOrigin(0.5, 0.5);
    this.plantingCursor.setScrollFactor(0, 0);
    this.plantingCursor.setDepth(100);
    
    console.log(`DEBUG: 种植光标属性设置完成: origin=${this.plantingCursor.originX},${this.plantingCursor.originY}, scrollFactor=${this.plantingCursor.scrollFactorX}, depth=${this.plantingCursor.depth}`);
    
    // 存储当前场景引用，确保回调函数中this指向正确
    const scene = this;
    
    // 跟随鼠标移动 - 使用命名的事件监听器，方便后续移除
    this.mouseMoveListener = (pointer) => {
      console.log(`DEBUG: 鼠标移动事件触发，指针位置: x=${pointer.x}, y=${pointer.y}`);
      // 检查种植光标是否存在，避免null引用错误
      if (scene.plantingCursor) {
        scene.plantingCursor.setPosition(pointer.x, pointer.y);
      }
    };
    
    // 添加鼠标移动事件监听
    console.log('DEBUG: 添加鼠标移动事件监听');
    this.input.on('pointermove', this.mouseMoveListener);
    
    // 更新背包UI，切换到取消种植按钮
    if (this.inventoryUI) {
      console.log('DEBUG: 更新背包UI，切换到取消种植按钮');
      this.inventoryUI.updatePlantButtonState(true);
    }
    
    console.log('DEBUG: 种植模式启动完成');
  }
  
  /**
   * 取消种植模式
   */
  cancelPlantingMode() {
    console.log('DEBUG: cancelPlantingMode 方法被调用');
    
    this.isPlantingMode = false;
    this.selectedSeed = null;
    console.log(`DEBUG: 重置种植模式状态: isPlantingMode=${this.isPlantingMode}, selectedSeed=${this.selectedSeed}`);
    
    this.generalInfoText.setText('欢迎使用种田功能测试场景');
    console.log('DEBUG: 重置提示信息');
    
    if (this.plantingCursor) {
      console.log('DEBUG: 销毁种植光标');
      this.plantingCursor.destroy();
      this.plantingCursor = null;
      console.log(`DEBUG: 种植光标销毁结果: ${this.plantingCursor ? '失败' : '成功'}`);
    }
    
    // 移除鼠标移动事件监听 - 使用存储的监听器引用
    if (this.mouseMoveListener) {
      console.log('DEBUG: 移除鼠标移动事件监听');
      this.input.off('pointermove', this.mouseMoveListener);
      this.mouseMoveListener = null;
      console.log(`DEBUG: 鼠标移动监听器移除结果: ${this.mouseMoveListener ? '失败' : '成功'}`);
    }
    
    // 更新背包UI，切换回种植按钮
    if (this.inventoryUI) {
      console.log('DEBUG: 更新背包UI，切换回种植按钮');
      this.inventoryUI.updatePlantButtonState(false);
      // 取消背包中选中的物品，保持UI一致性
      console.log('DEBUG: 取消背包中选中的物品');
      this.inventoryUI.deselectItem();
    }
    
    console.log('DEBUG: 种植模式取消完成');
  }
  
  /**
   * 在指定位置种植种子
   */
  plantSeedAt(pointer) {
    console.log('DEBUG: plantSeedAt 方法被调用');
    
    // 检查背包中是否还有该种子
    let seedItem = null;
    if (this.player.inventory) {
      // 查找背包中是否还有该类型的种子
      const allItems = this.player.inventory.getAllItems();
      if (allItems instanceof Map) {
        allItems.forEach(item => {
          if (item.itemTypeId === this.selectedSeed.itemTypeId) {
            seedItem = item;
          }
        });
      } else {
        seedItem = allItems.find(item => item.itemTypeId === this.selectedSeed.itemTypeId);
      }
    }
    
    if (!seedItem) {
      console.log('DEBUG: 背包中没有该种子，取消种植');
      this.showMessage(`背包中没有 ${this.selectedSeed.name}，无法种植`);
      this.cancelPlantingMode();
      return;
    }
    
    // 将屏幕坐标转换为世界坐标
    const worldPoint = this.cameras.main.getWorldPoint(pointer.x, pointer.y);
    console.log(`DEBUG: 屏幕坐标转世界坐标: 屏幕(${pointer.x},${pointer.y}) -> 世界(${worldPoint.x},${worldPoint.y})`);
    
    // 创建作物
    console.log(`DEBUG: 准备创建作物，类型: ${this.selectedSeed.properties.crop_type}, 生长时间: ${this.selectedSeed.properties.growth_time}`);
    
    const crop = new Crop(
      this, 
      worldPoint.x, 
      worldPoint.y, 
      this.selectedSeed.properties.crop_type, 
      this.selectedSeed.properties.growth_time
    );
    
    console.log(`DEBUG: 作物创建结果: ${crop ? '成功' : '失败'}`);
    
    if (crop) {
      // 从背包中移除种子
      if (this.player.inventory) {
        console.log(`DEBUG: 从背包中移除种子 ${seedItem.id}`);
        this.player.inventory.removeItem(seedItem.id);
        // 更新背包UI
        this.inventoryUI.updateUI();
      }
      
      // 添加到作物组
      this.cropGroup.add(crop);
      console.log(`DEBUG: 作物已添加到作物组，当前作物数量: ${this.cropGroup.getLength()}`);
      
      // 显示种植成功消息
      this.showMessage(`已种植 ${this.selectedSeed.name}`);
      console.log(`DEBUG: 显示种植成功消息: 已种植 ${this.selectedSeed.name}`);
    } else {
      console.log('DEBUG: 作物创建失败');
      this.showMessage(`种植 ${this.selectedSeed.name} 失败`);
    }
    
    // 取消种植模式
    this.cancelPlantingMode();
    console.log('DEBUG: 种植完成，取消种植模式');
  }
  
  /**
   * 收获作物
   */
  harvestCrop(crop) {
    // 创建对应的作物物品
    const cropItemId = crop.cropType;
    const cropItem = this.itemManager.createItem(cropItemId, crop.x, crop.y);
    
    // 尝试将作物添加到玩家背包
    if (cropItem) {
      if (this.player.inventory) {
        const success = this.player.inventory.addItem(cropItem);
        if (success) {
          // 更新背包UI
          this.inventoryUI.updateUI();
          this.showMessage(`收获了 ${cropItem.name}`);
          cropItem.destroy(); // 从地面移除，已添加到背包
        } else {
          // 背包满了，作物掉在地上
          this.showMessage(`背包已满，${cropItem.name} 掉在地上了`);
        }
      }
    }
    
    // 销毁作物对象
    crop.destroy();
    console.log('DEBUG: 作物已销毁');
  }
  
  /**
   * 显示提示信息
   */
  showInstructions() {
    const titleText = this.add.text(10, 10, '种田功能测试场景', {
      fontSize: '20px',
      fill: '#ffffff'
    });
    titleText.setScrollFactor(0, 0);
    titleText.setDepth(10);
    
    const moveText = this.add.text(10, 40, 'WASD或方向键移动单位，左键点击选择单位', {
      fontSize: '16px',
      fill: '#ffffff'
    });
    moveText.setScrollFactor(0, 0);
    moveText.setDepth(10);
    
    const inventoryText = this.add.text(10, 70, '按B键打开/关闭背包', {
      fontSize: '16px',
      fill: '#ffffff'
    });
    inventoryText.setScrollFactor(0, 0);
    inventoryText.setDepth(10);
    
    const plantingText = this.add.text(10, 100, '在背包中使用种子，然后点击地面种植', {
      fontSize: '16px',
      fill: '#ffffff'
    });
    plantingText.setScrollFactor(0, 0);
    plantingText.setDepth(10);
    
    const harvestText = this.add.text(10, 130, '点击成熟的作物进行收获', {
      fontSize: '16px',
      fill: '#ffffff'
    });
    harvestText.setScrollFactor(0, 0);
    harvestText.setDepth(10);
    
    const spaceText = this.add.text(10, 160, '按空格键返回启动场景', {
      fontSize: '16px',
      fill: '#ffffff'
    });
    spaceText.setScrollFactor(0, 0);
    spaceText.setDepth(10);
  }
  
  /**
   * 创建侧边栏UI
   */
  createSidebar() {
    // 侧边栏宽度
    const sidebarWidth = 300;
    const sidebarDepth = 5;
    
    // 创建侧边栏背景
    this.sidebar = this.add.rectangle(
      this.sys.game.config.width - sidebarWidth, 
      0, 
      sidebarWidth, 
      this.sys.game.config.height, 
      0x111111, 
      0.9
    );
    this.sidebar.setOrigin(0, 0);
    this.sidebar.setScrollFactor(0, 0);
    this.sidebar.setDepth(sidebarDepth);
    
    // 添加侧边栏边框
    this.sidebarBorder = this.add.rectangle(
      this.sys.game.config.width - sidebarWidth, 
      0, 
      sidebarWidth, 
      this.sys.game.config.height, 
      0x444444, 
      0
    );
    this.sidebarBorder.setOrigin(0, 0);
    this.sidebarBorder.setStrokeStyle(2, 0x444444, 1);
    this.sidebarBorder.setScrollFactor(0, 0);
    this.sidebarBorder.setDepth(sidebarDepth + 1);
    
    // 侧边栏标题
    const title = this.add.text(
      this.sys.game.config.width - sidebarWidth + 20, 
      20, 
      '游戏信息面板', 
      {
        fontSize: '20px',
        fill: '#ffffff',
        fontWeight: 'bold'
      }
    );
    title.setScrollFactor(0, 0);
    title.setDepth(sidebarDepth + 2);
    
    // 通用信息区域标题
    const generalTitle = this.add.text(
      this.sys.game.config.width - sidebarWidth + 20, 
      50, 
      '通用信息:', 
      {
        fontSize: '16px',
        fill: '#4CAF50',
        fontWeight: 'bold'
      }
    );
    generalTitle.setScrollFactor(0, 0);
    generalTitle.setDepth(sidebarDepth + 2);
    
    this.generalInfoText = this.add.text(
      this.sys.game.config.width - sidebarWidth + 20, 
      75, 
      '', 
      {
        fontSize: '14px',
        fill: '#ffffff',
        wordWrap: {
          width: sidebarWidth - 40
        }
      }
    );
    this.generalInfoText.setScrollFactor(0, 0);
    this.generalInfoText.setDepth(sidebarDepth + 2);
    
    // 角色属性区域标题
    const characterTitle = this.add.text(
      this.sys.game.config.width - sidebarWidth + 20, 
      120, 
      '角色属性:', 
      {
        fontSize: '16px',
        fill: '#2196F3',
        fontWeight: 'bold'
      }
    );
    characterTitle.setScrollFactor(0, 0);
    characterTitle.setDepth(sidebarDepth + 2);
    
    this.unitStatusText = this.add.text(
      this.sys.game.config.width - sidebarWidth + 20, 
      145, 
      '', 
      {
        fontSize: '14px',
        fill: '#ffffff',
        wordWrap: {
          width: sidebarWidth - 40
        }
      }
    );
    this.unitStatusText.setScrollFactor(0, 0);
    this.unitStatusText.setDepth(sidebarDepth + 2);
  }
  
  /**
   * 更新单位状态显示
   */
  updateUnitStatus(unit) {
    let statusText = `${unit.name} 状态:\n`;
    statusText += `生命值: ${unit.health}\n`;
    statusText += `营养值: ${unit.nutrition}\n`;
    statusText += `水分值: ${unit.hydration}\n`;
    if (unit.weapon) {
      statusText += `武器: ${unit.weapon.name}`;
    }
    
    this.unitStatusText.setText(statusText);
  }
  
  /**
   * 检查点击位置是否在UI元素上
   * @param {Phaser.Input.Pointer} pointer - 指针对象
   * @returns {boolean} 是否点击在UI元素上
   */
  isPointInUI(pointer) {
    // 检查是否点击在背包UI上
    if (this.inventoryUI && this.inventoryUI.isOpen) {
      const uiRect = this.inventoryUI.container.getBounds();
      if (Phaser.Geom.Rectangle.Contains(uiRect, pointer.x - this.inventoryUI.container.x, pointer.y - this.inventoryUI.container.y)) {
        return true;
      }
    }
    
    // 检查是否点击在侧边栏上
    if (this.sidebar) {
      const sidebarRect = this.sidebar.getBounds();
      if (Phaser.Geom.Rectangle.Contains(sidebarRect, pointer.x, pointer.y)) {
        return true;
      }
    }
    
    // 检查是否点击在物品信息面板上
    if (this.inventoryUI && this.inventoryUI.itemInfoPanel) {
      const infoRect = this.inventoryUI.itemInfoPanel.getBounds();
      if (Phaser.Geom.Rectangle.Contains(infoRect, pointer.x, pointer.y)) {
        return true;
      }
    }
    
    // 检查是否点击在作物详情面板上
    if (this.cropDetailsPanel) {
      const detailsRect = this.cropDetailsPanel.getBounds();
      if (Phaser.Geom.Rectangle.Contains(detailsRect, pointer.x, pointer.y)) {
        return true;
      }
    }
    
    // 检查是否点击在交互按钮上（返回菜单按钮等）
    // 这里可以添加按钮的点击区域检查
    
    return false;
  }
  
  /**
   * 显示作物详情信息
   * @param {Crop} crop - 作物对象
   */
  showCropDetails(crop) {
    console.log('DEBUG: showCropDetails 方法被调用');
    
    // 销毁之前的作物详情面板
    this.hideCropDetails();
    
    // 创建作物详情面板
    const panelWidth = 250;
    const panelHeight = 150;
    const panelX = this.sys.game.config.width - panelWidth - 20;
    const panelY = 100;
    
    this.cropDetailsPanel = this.add.rectangle(
      panelX,
      panelY,
      panelWidth,
      panelHeight,
      0x000000,
      0.8
    );
    this.cropDetailsPanel.setOrigin(0, 0);
    this.cropDetailsPanel.setStrokeStyle(2, 0x4CAF50);
    this.cropDetailsPanel.setDepth(200);
    this.cropDetailsPanel.setScrollFactor(0, 0);
    
    // 阻止事件冒泡
    this.cropDetailsPanel.setInteractive();
    this.cropDetailsPanel.on('pointerdown', (pointer) => {
      return false;
    });
    
    // 作物信息文本
    const cropInfo = crop.getInfo();
    const growthProgress = Math.min(100, Math.floor(((Date.now() - cropInfo.plantedTime) / cropInfo.growthTime) * 100));
    const stageNames = ['种子', '幼苗', '成长中', '成熟'];
    
    let detailsText = `${cropInfo.type} 作物\n`;
    detailsText += `生长阶段: ${stageNames[cropInfo.growthStage]}\n`;
    detailsText += `生长进度: ${growthProgress}%\n`;
    detailsText += `可收获: ${cropInfo.isHarvestable ? '是' : '否'}`;
    
    this.cropDetailsText = this.add.text(
      panelX + 10,
      panelY + 10,
      detailsText,
      { font: '14px Arial', fill: '#ffffff', wordWrap: { width: panelWidth - 20 } }
    );
    this.cropDetailsText.setDepth(210);
    this.cropDetailsText.setScrollFactor(0, 0);
    
    // 如果作物可收获，添加收获按钮
    if (cropInfo.isHarvestable) {
      this.harvestButton = this.add.text(
        panelX + 10,
        panelY + 100,
        '[收获作物]',
        { font: '14px Arial', fill: '#00ff00' }
      );
      this.harvestButton.setDepth(210);
      this.harvestButton.setScrollFactor(0, 0);
      this.harvestButton.setInteractive({
        useHandCursor: true,
        cursor: 'pointer'
      });
      
      // 绑定收获按钮事件
      this.harvestButton.on('pointerdown', (pointer) => {
        console.log('DEBUG: 点击收获按钮');
        this.harvestCrop(crop);
        this.hideCropDetails();
        return false; // 阻止事件冒泡，防止触发角色移动
      });
      
      this.harvestButton.on('pointerover', (pointer) => {
        this.harvestButton.setFill('#ffff00');
        return false;
      });
      
      this.harvestButton.on('pointerout', (pointer) => {
        this.harvestButton.setFill('#00ff00');
        return false;
      });
    }
    
    // 添加关闭按钮
    this.closeCropDetailsButton = this.add.text(
      panelX + panelWidth - 25,
      panelY + 5,
      'X',
      { font: '18px Arial', fill: '#ffffff' }
    );
    this.closeCropDetailsButton.setDepth(210);
    this.closeCropDetailsButton.setScrollFactor(0, 0);
    this.closeCropDetailsButton.setInteractive({
      useHandCursor: true,
      cursor: 'pointer'
    });
    
    this.closeCropDetailsButton.on('pointerdown', (pointer) => {
      this.hideCropDetails();
      return false;
    });
    
    this.closeCropDetailsButton.on('pointerover', (pointer) => {
      this.closeCropDetailsButton.setFill('#ff0000');
      return false;
    });
    
    this.closeCropDetailsButton.on('pointerout', (pointer) => {
      this.closeCropDetailsButton.setFill('#ffffff');
      return false;
    });
  }
  
  /**
   * 隐藏作物详情信息
   */
  hideCropDetails() {
    if (this.cropDetailsPanel) {
      this.cropDetailsPanel.destroy();
      this.cropDetailsPanel = null;
    }
    
    if (this.cropDetailsText) {
      this.cropDetailsText.destroy();
      this.cropDetailsText = null;
    }
    
    if (this.harvestButton) {
      this.harvestButton.destroy();
      this.harvestButton = null;
    }
    
    if (this.closeCropDetailsButton) {
      this.closeCropDetailsButton.destroy();
      this.closeCropDetailsButton = null;
    }
  }
  
  /**
   * 显示消息
   */
  showMessage(message) {
    // 创建消息
    const messageText = this.add.text(
      this.player.x,
      this.player.y - 50,
      message,
      {
        font: '20px Arial',
        fill: '#ffffff',
        backgroundColor: '#000000',
        padding: { x: 10, y: 5 }
      }
    );
    messageText.setOrigin(0.5, 0.5);
    messageText.setDepth(20);
    messageText.setScrollFactor(1);
    
    // 3秒后自动移除消息
    this.time.delayedCall(3000, () => {
      if (messageText) {
        messageText.destroy();
      }
    });
  }
  
  update() {
    this.inputSystem.update();
    
    // 更新所有单位
    this.unitGroup.getChildren().forEach(unit => {
      if (unit.update) {
        unit.update();
      }
      unit.updateMovement();
      // 更新单位状态显示
      this.updateUnitStatus(unit);
    });
  }
}