/**
 * TeamGameScene.js
 * Unified battle scene for online multiplayer (supports 1v1 PVP and 3v3 Team modes).
 * Configurable via battleMode parameter ('1v1' or '3v3').
 * Base HP system, unlimited respawns, network-synced input, team-based win/lose logic.
 */

const {
  SCREEN_WIDTH,
  SCREEN_HEIGHT,
  COLORS,
  SCENE,
  MAP_OFFSET_X,
  MAP_OFFSET_Y,
  MAP_WIDTH,
  MAP_HEIGHT,
  TILE_SIZE,
  DIRECTION,
  DIR_VECTORS,
  TERRAIN,
  NET_MSG,
  TEAM_RESPAWN_DELAY,
  TEAM_BASE_HP,
  TEAM_SIZE,
  TANK_CONFIG,
  TANK_TYPE,
  PVP_BASE_HP,
  PVP_RESPAWN_DELAY,
  BATTLE_CONFIG,
} = require('../base/GameGlobal');
const { t } = require('../i18n/I18n');

const ObjectPool = require('../base/ObjectPool');
const MapManager = require('../managers/MapManager');
const PlayerTank = require('../entities/PlayerTank');
const BotTank = require('../entities/BotTank');
const Bullet = require('../entities/Bullet');
const Explosion = require('../entities/Explosion');
const Joystick = require('../ui/Joystick');
const FireButton = require('../ui/FireButton');
const { getTeamMap, getPvpMap } = require('../data/LevelData');

// Team colors
const TEAM_A_COLOR = '#4A90D9'; // blue
const TEAM_B_COLOR = '#E94560'; // red
const LOCAL_PLAYER_COLOR = '#FFD700'; // gold highlight

// 1v1 PVP player colors
const PLAYER1_COLOR = '#FFD700'; // gold
const PLAYER2_COLOR = '#00BFFF'; // deep sky blue

const TeamGameScene = {
  _initialized: false,
  _gameOver: false,
  _paused: false,
  _winner: '', // '' | 'A' | 'B'
  _winReason: '',

  // Reconnection state
  _isDisconnected: false,
  _reconnectTimer: 0,
  _reconnectAttempts: 0,
  _maxReconnectAttempts: 5,
  _reconnectInterval: 3, // seconds between attempts

  // Network
  _networkManager: null,
  _myPlayerId: '',
  _myTeam: '', // 'A' or 'B'
  _teamId: '',
  _unsubscribers: [],

  // Map
  _mapManager: null,
  _mapData: null,

  // Controls
  _joystick: null,
  _fireButton: null,

  // Players: { playerId, tank, isBot, team, isLocal, spawnPoint, respawnTimer }
  _players: [],
  _localPlayer: null,

  // Entity lists
  _bullets: [],
  _explosions: [],

  // Object pools
  _bulletPool: null,
  _explosionPool: null,

  // Battle config (1v1 or 3v3)
  _battleMode: '3v3', // '1v1' or '3v3'
  _battleConfig: null,

  // Game state
  _elapsedTime: 0, // seconds since game started (count up)
  _teamABaseHp: TEAM_BASE_HP,
  _teamBBaseHp: TEAM_BASE_HP,
  _gameOverDelay: 0,
  _gameOverDelayDuration: 3,

  // Stats
  _stats: {}, // { playerId: { kills, deaths, assists, baseDamage } }

  // Sync
  _syncTimer: 0,
  _syncInterval: 0.05,
  _lastSentInput: null,

  // Remote state targets for interpolation
  _remoteTargets: {}, // { playerId: { x, y, direction } }

  enter(params) {
    this._teamId = (params && params.teamId) || '';
    this._myPlayerId = (params && params.myPlayerId) || '';
    this._gameOver = false;
    this._paused = false;
    this._winner = '';
    this._winReason = '';
    this._gameOverDelay = 0;
    this._elapsedTime = 0;
    this._syncTimer = 0;
    this._lastSentInput = null;
    this._stats = {};
    this._remoteTargets = {};
    this._isDisconnected = false;
    this._reconnectTimer = 0;
    this._reconnectAttempts = 0;

    // Determine battle mode from params
    this._battleMode = (params && params.battleMode) || '3v3';
    this._battleConfig = BATTLE_CONFIG[this._battleMode] || BATTLE_CONFIG['3v3'];

    const baseHp = (params && params.teamABaseHp) || this._battleConfig.baseHp;
    this._teamABaseHp = baseHp;
    this._teamBBaseHp = (params && params.teamBBaseHp) || baseHp;

    this._networkManager = GameGlobal.networkManager;

    // Initialize object pools
    this._bulletPool = new ObjectPool(() => new Bullet(), null, 40);
    this._explosionPool = new ObjectPool(() => new Explosion(), null, 20);
    this._bullets = [];
    this._explosions = [];

    // Load map based on battle mode
    if (this._battleConfig.mapPool === 'pvp') {
      this._mapData = getPvpMap(params && params.mapId, params && params.roomId);
    } else {
      this._mapData = getTeamMap(params && params.mapId);
    }
    this._mapManager = new MapManager();
    this._mapManager.loadGrid(this._mapData.grid);

    // Determine which team the local player is on
    const teamAMembers = (params && params.teamA) || [];
    const teamBMembers = (params && params.teamB) || [];

    console.log(`[TeamGameScene] teamA: ${JSON.stringify(teamAMembers.map(m => ({ playerId: m.playerId, isBot: m.isBot })))}`);
    console.log(`[TeamGameScene] teamB: ${JSON.stringify(teamBMembers.map(m => ({ playerId: m.playerId, isBot: m.isBot })))}`);
    console.log(`[TeamGameScene] myPlayerId: ${this._myPlayerId}`);

    this._myTeam = teamAMembers.find(m => m.playerId === this._myPlayerId) ? 'A' : 'B';

    // Create all player tanks
    this._players = [];
    this._createTeamPlayers(teamAMembers, 'A', this._mapData.teamASpawns);
    this._createTeamPlayers(teamBMembers, 'B', this._mapData.teamBSpawns);

    // Log _players for duplicate check
    const playerIds = this._players.map(p => p.playerId);
    const duplicates = playerIds.filter((id, idx) => playerIds.indexOf(id) !== idx);
    if (duplicates.length > 0) {
      console.error(`[TeamGameScene] DUPLICATE playerIds: ${JSON.stringify(duplicates)}`);
    }
    console.log(`[TeamGameScene] All players: ${JSON.stringify(this._players.map(p => ({ playerId: p.playerId, team: p.team, isLocal: p.isLocal, isBot: p.isBot })))}`);

    // Find local player
    this._localPlayer = this._players.find(p => p.isLocal);

    // Check if enemy team has no human players (all bots) —
    // if so, this client must run enemy bot AI locally since no remote
    // client exists to act as authority
    const enemyTeam = this._myTeam === 'A' ? 'B' : 'A';
    this._enemyTeamAllBots = !this._players.some(
      p => p.team === enemyTeam && !p.isBot && !p.isLocal
    );

    // Initialize stats
    for (const p of this._players) {
      this._stats[p.playerId] = { kills: 0, deaths: 0, assists: 0, baseDamage: 0 };
    }

    // Initialize controls
    this._joystick = new Joystick();
    this._fireButton = new FireButton();
    this._fireButton.onFire(() => this._localFire());

    // Setup network events
    this._setupNetworkEvents();

    this._initialized = true;
    console.log(`[TeamGameScene] Started (${this._battleMode}). Team: ${this._teamId}, Player: ${this._myPlayerId}, MyTeam: ${this._myTeam}`);
  },

  _createTeamPlayers(members, team, spawnPoints) {
    for (let i = 0; i < members.length; i++) {
      const member = members[i];
      const spawn = spawnPoints[i % spawnPoints.length];
      const isLocal = member.playerId === this._myPlayerId;
      const isMyTeam = team === this._myTeam;
      const isBot = member.isBot || false;

      // Determine color based on battle mode
      let tankColor;
      if (this._battleMode === '1v1') {
        // 1v1: use P1/P2 colors based on team
        if (isLocal) {
          tankColor = team === 'A' ? PLAYER1_COLOR : PLAYER2_COLOR;
        } else {
          tankColor = team === 'A' ? PLAYER1_COLOR : PLAYER2_COLOR;
        }
      } else {
        // 3v3: Team A = blue, Team B = red
        // Local player uses team color too (gold border drawn separately for identification)
        tankColor = team === 'A' ? TEAM_A_COLOR : TEAM_B_COLOR;
      }

      let tank;
      if (isBot) {
        // Use BotTank for AI-controlled players
        tank = new BotTank({
          col: spawn.col,
          row: spawn.row,
          team,
          playerId: member.playerId,
          color: tankColor,
        });
        // Set target base: bots attack the enemy base
        const enemyBase = team === 'A' ? this._mapData.teamBBase : this._mapData.teamABase;
        if (enemyBase && enemyBase.length > 0) {
          tank.setTargetBase({
            x: MAP_OFFSET_X + enemyBase[0].col * TILE_SIZE + TILE_SIZE / 2,
            y: MAP_OFFSET_Y + enemyBase[0].row * TILE_SIZE + TILE_SIZE / 2,
          });
        }
      } else {
        // Use PlayerTank for human players
        tank = new PlayerTank({
          col: spawn.col,
          row: spawn.row,
        });
        tank.color = tankColor;
        // Unlimited lives for 3v3
        tank.lives = 999;
        // Apply equipped skin — only non-default skins override team color
        if (GameGlobal.skinManager) {
          const skinId = isLocal
            ? GameGlobal.skinManager.getEquippedSkinId()
            : (member.skinId || '');
          if (skinId && skinId !== 'default') {
            const skinDef = GameGlobal.skinManager.getSkin(skinId);
            if (skinDef && skinDef.colors) {
              tank._skinColors = skinDef.colors;
              tank._skinId = skinId;
            }
          }
        }
      }

      tank.activateShield(3000);

      // Mark local player's tank for gold-border rendering
      if (isLocal) {
        tank._isLocal = true;
      }

      // Set initial direction based on team
      if (team === 'A') {
        tank.direction = DIRECTION.RIGHT;
      } else {
        tank.direction = DIRECTION.LEFT;
      }

      // Clear spawn area
      this._clearSpawnArea(spawn.col, spawn.row);

      const playerData = {
        playerId: member.playerId,
        nickname: member.nickname || '',
        tank,
        isBot,
        team,
        isLocal,
        spawnPoint: spawn,
        respawnTimer: 0,
        isRespawning: false,
      };

      this._players.push(playerData);

      // Initialize remote target
      if (!isLocal) {
        this._remoteTargets[member.playerId] = {
          x: tank.x,
          y: tank.y,
          direction: tank.direction,
        };
      }
    }
  },

  exit() {
    this._initialized = false;
    this._cleanupNetworkEvents();
    this._bullets = [];
    this._explosions = [];
    this._players = [];
  },

  _setupNetworkEvents() {
    this._cleanupNetworkEvents();
    const nm = this._networkManager;
    if (!nm) return;

    const unsubs = [];

    // Receive player state sync from other players
    unsubs.push(nm.on(NET_MSG.PLAYER_STATE, (data) => {
      if (data.playerId && data.playerId !== this._myPlayerId) {
        this._updateRemotePlayerState(data);
      }
    }));

    // Receive player input from other players
    unsubs.push(nm.on(NET_MSG.PLAYER_INPUT, (data) => {
      if (data.playerId && data.playerId !== this._myPlayerId) {
        const player = this._players.find(p => p.playerId === data.playerId);
        if (player) {
          player._remoteInput = {
            direction: data.direction !== undefined ? data.direction : -1,
            moving: data.moving || false,
          };
        }
      }
    }));

    // Receive bullet fire from other players
    unsubs.push(nm.on(NET_MSG.BULLET_FIRE, (data) => {
      if (!data.playerId) return;
      // Ignore our own bullets (local player or our team's bots) — we already
      // created them locally. Only spawn remote bullets for enemy players/bots.
      const shooter = this._players.find(p => p.playerId === data.playerId);
      if (shooter && shooter.team === this._myTeam) return;
      if (data.playerId === this._myPlayerId) return;
      this._spawnRemoteBullet(data);
    }));

    // Receive player killed notification
    unsubs.push(nm.on(NET_MSG.PLAYER_KILLED, (data) => {
      if (data.victimId) {
        const victim = this._players.find(p => p.playerId === data.victimId);
        if (victim && victim.tank.alive) {
          victim.tank.alive = false;
          this._spawnExplosion(victim.tank.x, victim.tank.y, true);
          this._startRespawn(victim);
        }
        // Update stats
        if (data.killerId && this._stats[data.killerId]) {
          this._stats[data.killerId].kills++;
        }
        if (this._stats[data.victimId]) {
          this._stats[data.victimId].deaths++;
        }
      }
    }));

    // Receive player respawn
    unsubs.push(nm.on(NET_MSG.PLAYER_RESPAWN, (data) => {
      if (data.playerId && data.playerId !== this._myPlayerId) {
        const player = this._players.find(p => p.playerId === data.playerId);
        if (player) {
          this._respawnPlayer(player);
        }
      }
    }));

    // Receive base hit
    unsubs.push(nm.on(NET_MSG.BASE_HIT, (data) => {
      if (data.teamABaseHp !== undefined) this._teamABaseHp = data.teamABaseHp;
      if (data.teamBBaseHp !== undefined) this._teamBBaseHp = data.teamBBaseHp;

      // Check if base destroyed (immediate client-side feedback)
      if (!this._gameOver) {
        if (this._teamABaseHp <= 0) {
          this._winner = 'B';
          this._winReason = 'base_destroyed';
          this._gameOver = true;
          GameGlobal.audioManager.playSFX(this._myTeam === 'B' ? 'victory' : 'gameover');
        } else if (this._teamBBaseHp <= 0) {
          this._winner = 'A';
          this._winReason = 'base_destroyed';
          this._gameOver = true;
          GameGlobal.audioManager.playSFX(this._myTeam === 'A' ? 'victory' : 'gameover');
        }
      }
    }));

    // Receive base destroyed / game over
    unsubs.push(nm.on(NET_MSG.BASE_DESTROYED, (data) => {
      if (data.team === 'A') {
        this._teamABaseHp = 0;
        this._winner = 'B';
      } else {
        this._teamBBaseHp = 0;
        this._winner = 'A';
      }
      this._winReason = 'base_destroyed';
      this._gameOver = true;
    }));

    unsubs.push(nm.on(NET_MSG.TEAM_GAME_OVER, (data) => {
      this._winner = data.winner || '';
      this._winReason = data.reason || 'base_destroyed';
      this._teamABaseHp = data.teamABaseHp;
      this._teamBBaseHp = data.teamBBaseHp;
      this._gameOver = true;
    }));

    // Receive game over (1v1 mode uses GAME_OVER instead of TEAM_GAME_OVER)
    unsubs.push(nm.on(NET_MSG.GAME_OVER, (data) => {
      this._winner = data.winner || '';
      this._winReason = data.reason || 'base_destroyed';
      if (data.teamABaseHp !== undefined) this._teamABaseHp = data.teamABaseHp;
      if (data.teamBBaseHp !== undefined) this._teamBBaseHp = data.teamBBaseHp;
      this._gameOver = true;
    }));

    // Opponent left (1v1 mode)
    unsubs.push(nm.on(NET_MSG.OPPONENT_LEFT, () => {
      if (!this._gameOver) {
        this._winner = this._myTeam;
        this._winReason = 'disconnected';
        this._gameOver = true;
      }
    }));

    // Player disconnect
    unsubs.push(nm.on(NET_MSG.PLAYER_DISCONNECT, (data) => {
      console.log(`[TeamGameScene] Player disconnected: ${data.playerId}`);
    }));

    // Bot takeover
    unsubs.push(nm.on(NET_MSG.BOT_TAKEOVER, (data) => {
      const player = this._players.find(p => p.playerId === data.playerId);
      if (player) {
        player.isBot = true;
        console.log(`[TeamGameScene] Bot takeover: ${data.playerId}`);
      }
    }));

    unsubs.push(nm.on(NET_MSG.RECONNECT_OK, (data) => {
      console.log('[TeamGameScene] Reconnected successfully');
      this._isDisconnected = false;
      this._reconnectAttempts = 0;
      // Restore game state from server
      if (data.teamABaseHp !== undefined) this._teamABaseHp = data.teamABaseHp;
      if (data.teamBBaseHp !== undefined) this._teamBBaseHp = data.teamBBaseHp;
    }));

    unsubs.push(nm.on('disconnected', () => {
      if (!this._gameOver) {
        this._isDisconnected = true;
        this._reconnectTimer = 0;
        this._reconnectAttempts = 0;
        console.log('[TeamGameScene] Disconnected, attempting reconnect...');
      }
    }));

    // Receive live team roster updates — keeps every tank's overhead label in
    // sync with the real WeChat nickname, which may be granted AFTER the match
    // has already started (via MenuScene's UserInfoButton).
    unsubs.push(nm.on(NET_MSG.TEAM_STATE, (data) => {
      if (!data) return;
      const rosterA = Array.isArray(data.teamA) ? data.teamA : [];
      const rosterB = Array.isArray(data.teamB) ? data.teamB : [];
      const byId = Object.create(null);
      for (const m of rosterA) if (m && m.playerId) byId[m.playerId] = m.nickname || '';
      for (const m of rosterB) if (m && m.playerId) byId[m.playerId] = m.nickname || '';
      let changed = false;
      for (const p of this._players) {
        const nn = byId[p.playerId];
        if (nn && p.nickname !== nn) {
          p.nickname = nn;
          changed = true;
        }
      }
      if (changed) {
        console.log('[TeamGameScene] Roster nicknames refreshed.');
      }
    }));

    // Receive terrain changes from remote client (brick/steel/base_wall destruction)
    unsubs.push(nm.on(NET_MSG.TERRAIN_CHANGE, (data) => {
      if (data.row !== undefined && data.col !== undefined && data.terrain !== undefined) {
        const currentTerrain = this._mapManager.getTerrain(data.row, data.col);
        // Only apply if the terrain still matches the original type (avoid double-apply)
        // Accept EMPTY→EMPTY as no-op, but apply any real change
        if (currentTerrain !== data.terrain) {
          this._mapManager.setTerrain(data.row, data.col, data.terrain);
        }
      }
    }));

    // Receive bot state from remote client (enemy team bots)
    unsubs.push(nm.on(NET_MSG.BOT_STATE, (data) => {
      if (data.playerId) {
        this._updateRemotePlayerState(data);
      }
    }));

    this._unsubscribers = unsubs;
  },

  _cleanupNetworkEvents() {
    for (const unsub of this._unsubscribers) {
      if (typeof unsub === 'function') unsub();
    }
    this._unsubscribers = [];
  },

  _updateRemotePlayerState(data) {
    const target = this._remoteTargets[data.playerId];
    if (target) {
      // Convert normalized grid coords back to local pixel coords
      if (data.col !== undefined && data.row !== undefined) {
        target.x = MAP_OFFSET_X + data.col * TILE_SIZE;
        target.y = MAP_OFFSET_Y + data.row * TILE_SIZE;
      } else {
        target.x = data.x;
        target.y = data.y;
      }
      target.direction = data.direction;
    }
    const player = this._players.find(p => p.playerId === data.playerId);
    if (player) {
      if (data.hp !== undefined) player.tank.hp = data.hp;
      if (data.alive !== undefined) player.tank.alive = data.alive;
    }
  },

  // ============================================================
  // Update
  // ============================================================
  update(dt) {
    if (!this._initialized || this._paused) return;

    // Handle reconnection
    if (this._isDisconnected) {
      this._reconnectTimer += dt;
      if (this._reconnectTimer >= this._reconnectInterval) {
        this._reconnectTimer = 0;
        this._attemptReconnect();
      }
      return; // Pause game updates while disconnected
    }

    // Game over delay
    if (this._gameOver) {
      this._gameOverDelay += dt;
      this._updateExplosions(dt);
      if (this._gameOverDelay >= this._gameOverDelayDuration) {
        this._transitionToResult();
      }
      return;
    }

    // Elapsed time (count up, for display only)
    this._elapsedTime += dt;

    // Update map
    this._mapManager.update(dt);

    // Update all players
    for (const player of this._players) {
      if (player.isRespawning) {
        player.respawnTimer -= dt * 1000;
        if (player.respawnTimer <= 0 && (player.isLocal || player.isBot)) {
          this._respawnPlayer(player);
          // Notify server
          if (this._networkManager) {
            this._networkManager.send(NET_MSG.PLAYER_RESPAWN, {
              playerId: player.playerId,
            });
          }
        }
        continue;
      }

      if (!player.tank.alive) continue;

      if (player.isLocal) {
        // Local player movement
        if (this._joystick.active && this._joystick.direction >= 0) {
          player.tank.move(this._joystick.direction, dt, this._mapManager);
        }
      } else if (!player.isBot) {
        // Remote player interpolation
        this._interpolateRemoteTank(player, dt);
      } else if (player.team === this._myTeam) {
        // Our team's bot — we are the authority, run AI locally
        this._updateBotAI(player, dt);
      } else if (this._enemyTeamAllBots) {
        // Enemy team's bot but enemy has no human players —
        // run AI locally since no remote client exists to drive them
        this._updateBotAI(player, dt);
      } else {
        // Enemy team's bot — interpolated from remote state (authority is on their side)
        this._interpolateRemoteTank(player, dt);
      }

      player.tank.update(dt);
    }

    // Update bullets
    for (const bullet of this._bullets) {
      bullet.update(dt);
    }

    // Collision detection
    this._checkCollisions();

    // Update explosions
    this._updateExplosions(dt);

    // Cleanup
    this._cleanup();

    // Send local state periodically
    this._syncTimer += dt;
    if (this._syncTimer >= this._syncInterval) {
      this._syncTimer = 0;
      this._sendLocalState();
    }

    // Send input changes
    this._sendInputIfChanged();
  },

  _interpolateRemoteTank(player, dt) {
    const target = this._remoteTargets[player.playerId];
    if (!target) return;

    const tank = player.tank;
    tank.direction = target.direction;

    const dx = target.x - tank.x;
    const dy = target.y - tank.y;
    const dist = Math.abs(dx) + Math.abs(dy);

    if (dist > TILE_SIZE * 3) {
      // Too far away (e.g. respawn / teleport) — snap directly
      tank.x = target.x;
      tank.y = target.y;
    } else if (dist > 0.5) {
      // Interpolate towards target position.
      // No local terrain collision check — the remote position is authoritative
      // from the opponent's client. Local terrain may differ (bullets destroy
      // bricks independently on each client), so blocking here would cause
      // the remote tank to get stuck at the wrong position.
      // No input prediction — it causes accumulated drift because Tank.move()
      // has grid-snapping and terrain-sliding that differ between clients.
      const lerpSpeed = Math.min(20 * dt, 1); // cap at 1 to avoid overshoot

      tank.x += dx * lerpSpeed;
      tank.y += dy * lerpSpeed;
    } else {
      // Close enough — snap to target
      tank.x = target.x;
      tank.y = target.y;
    }
  },

  _updateBotAI(player, dt) {
    const tank = player.tank;

    // Use BotTank's built-in AI if available
    if (typeof tank.updateAI === 'function') {
      tank.updateAI(dt, this._mapManager, (bot) => {
        this._botFire(player);
      });
      return;
    }

    // Fallback: simple bot AI for non-BotTank instances
    if (!player._botTimer) player._botTimer = 0;
    if (!player._botShootTimer) player._botShootTimer = 0;
    if (!player._botDirection) player._botDirection = Math.floor(Math.random() * 4);

    player._botTimer += dt;
    player._botShootTimer += dt;

    // Change direction every 1-3 seconds
    if (player._botTimer > 1 + Math.random() * 2) {
      player._botTimer = 0;
      player._botDirection = Math.floor(Math.random() * 4);
    }

    // Move
    tank.move(player._botDirection, dt, this._mapManager);

    // Shoot every 1-2 seconds
    if (player._botShootTimer > 1 + Math.random()) {
      player._botShootTimer = 0;
      this._botFire(player);
    }
  },

  _sendLocalState() {
    if (!this._networkManager || !this._localPlayer) return;
    const tank = this._localPlayer.tank;
    // Send normalized grid coordinates instead of pixel coordinates
    // so that different screen sizes produce the same grid position.
    this._networkManager.send(NET_MSG.PLAYER_STATE, {
      playerId: this._myPlayerId,
      col: (tank.x - MAP_OFFSET_X) / TILE_SIZE,
      row: (tank.y - MAP_OFFSET_Y) / TILE_SIZE,
      direction: tank.direction,
      hp: tank.hp,
      alive: tank.alive,
    });

    // Also sync our team's bot states
    this._sendBotStates();
  },

  _sendInputIfChanged() {
    if (!this._networkManager) return;

    const currentInput = {
      direction: this._joystick.direction,
      moving: this._joystick.active && this._joystick.direction >= 0,
    };

    if (
      !this._lastSentInput ||
      this._lastSentInput.direction !== currentInput.direction ||
      this._lastSentInput.moving !== currentInput.moving
    ) {
      this._lastSentInput = { ...currentInput };
      this._networkManager.send(NET_MSG.PLAYER_INPUT, {
        playerId: this._myPlayerId,
        ...currentInput,
      });
    }
  },

  _sendTerrainChange(row, col, newTerrain) {
    if (!this._networkManager) return;
    this._networkManager.send(NET_MSG.TERRAIN_CHANGE, {
      row,
      col,
      terrain: newTerrain,
    });
  },

  _sendBotStates() {
    if (!this._networkManager) return;
    // Only sync bots on OUR team (we are the authority for our team's bots)
    const myBots = this._players.filter(p => p.isBot && p.team === this._myTeam);
    for (const bot of myBots) {
      const tank = bot.tank;
      this._networkManager.send(NET_MSG.BOT_STATE, {
        playerId: bot.playerId,
        col: (tank.x - MAP_OFFSET_X) / TILE_SIZE,
        row: (tank.y - MAP_OFFSET_Y) / TILE_SIZE,
        direction: tank.direction,
        alive: tank.alive,
        hp: tank.hp,
      });
    }
  },

  // ============================================================
  // Collision Detection
  // ============================================================
  _checkCollisions() {
    const aliveBullets = this._bullets.filter(b => b.alive);

    // Bullet vs terrain (including bases)
    for (const bullet of aliveBullets) {
      if (!bullet.alive) continue;
      this._checkBulletTerrain(bullet);
    }

    // Bullet vs tanks (team-aware)
    for (const bullet of aliveBullets) {
      if (!bullet.alive) continue;
      this._checkBulletVsTanks(bullet);
    }

    // Bullet vs bullet
    this._checkBulletVsBullet(aliveBullets);

    // Tank vs tank (push apart)
    const alivePlayers = this._players.filter(p => p.tank.alive && !p.isRespawning);
    for (let i = 0; i < alivePlayers.length; i++) {
      for (let j = i + 1; j < alivePlayers.length; j++) {
        if (alivePlayers[i].tank.collidesWith(alivePlayers[j].tank)) {
          this._separateTanks(alivePlayers[i].tank, alivePlayers[j].tank);
        }
      }
    }
  },

  _checkBulletTerrain(bullet) {
    const { row, col } = this._mapManager.pixelToGrid(bullet.x, bullet.y);

    if (row < 0 || row >= this._mapData.grid.length || col < 0 || col >= this._mapData.grid[0].length) {
      bullet.destroy();
      this._spawnExplosion(bullet.x, bullet.y, false);
      return;
    }

    const terrain = this._mapManager.getTerrain(row, col);
    const bulletOwner = this._players.find(p => p.playerId === bullet.ownerPlayerId);
    // Only our team's bullets can modify terrain locally; enemy bullets are
    // visual-only and their terrain changes come via TERRAIN_CHANGE messages.
    const isAuthority = bulletOwner && bulletOwner.team === this._myTeam;

    if (terrain === TERRAIN.BRICK) {
      if (isAuthority) {
        this._mapManager.setTerrain(row, col, TERRAIN.EMPTY);
        this._sendTerrainChange(row, col, TERRAIN.EMPTY);
      }
      bullet.destroy();
      this._spawnExplosion(bullet.x, bullet.y, false);
    } else if (terrain === TERRAIN.BASE_WALL) {
      // Determine which team this base wall belongs to
      const wallTeam = this._getBaseWallTeam(row, col);

      // Friendly-fire immunity: own team's bullets don't damage own base walls
      if (bulletOwner && wallTeam && bulletOwner.team === wallTeam) {
        bullet.destroy();
        return;
      }

      if (isAuthority) {
        // Base wall has HP — use bulletHitTerrain for proper HP tracking
        const prevTerrain = this._mapManager.getTerrain(row, col);
        this._mapManager.bulletHitTerrain(row, col, bullet.canBreakSteel);
        const newTerrain = this._mapManager.getTerrain(row, col);
        if (prevTerrain !== newTerrain) {
          this._sendTerrainChange(row, col, newTerrain);
        }
      }
      bullet.destroy();
      this._spawnExplosion(bullet.x, bullet.y, false);
    } else if (terrain === TERRAIN.STEEL) {
      if (bullet.canBreakSteel && isAuthority) {
        this._mapManager.setTerrain(row, col, TERRAIN.EMPTY);
        this._sendTerrainChange(row, col, TERRAIN.EMPTY);
      }
      bullet.destroy();
      this._spawnExplosion(bullet.x, bullet.y, false);
    } else if (terrain === TERRAIN.BASE) {
      // Base hit! Determine which team's base
      bullet.destroy();
      this._spawnExplosion(bullet.x, bullet.y, true);
      this._handleBaseHit(bullet, row, col);
    }
  },

  /**
   * Determine which team a BASE_WALL tile belongs to based on proximity to team bases.
   * @param {number} row
   * @param {number} col
   * @returns {string} 'A', 'B', or '' if unknown
   */
  _getBaseWallTeam(row, col) {
    // Check proximity to each team's base positions
    let minDistA = Infinity;
    let minDistB = Infinity;

    if (this._mapData.teamABase) {
      for (const base of this._mapData.teamABase) {
        const dist = Math.abs(row - base.row) + Math.abs(col - base.col);
        if (dist < minDistA) minDistA = dist;
      }
    }
    if (this._mapData.teamBBase) {
      for (const base of this._mapData.teamBBase) {
        const dist = Math.abs(row - base.row) + Math.abs(col - base.col);
        if (dist < minDistB) minDistB = dist;
      }
    }

    if (minDistA < minDistB) return 'A';
    if (minDistB < minDistA) return 'B';
    // Fallback: use column position (left = A, right = B)
    return col < this._mapData.grid[0].length / 2 ? 'A' : 'B';
  },

  _handleBaseHit(bullet, row, col) {
    // Determine which team's base was hit based on position
    const bulletOwner = this._players.find(p => p.playerId === bullet.ownerPlayerId);
    if (!bulletOwner) return;

    // Check if the base belongs to team A or team B
    let targetTeam = '';
    if (this._mapData.teamABase) {
      for (const base of this._mapData.teamABase) {
        if (base.row === row && base.col === col) {
          targetTeam = 'A';
          break;
        }
      }
    }
    if (!targetTeam && this._mapData.teamBBase) {
      for (const base of this._mapData.teamBBase) {
        if (base.row === row && base.col === col) {
          targetTeam = 'B';
          break;
        }
      }
    }

    // If we can't determine by exact position, use column position
    if (!targetTeam) {
      targetTeam = col < this._mapData.grid[0].length / 2 ? 'A' : 'B';
    }

    // Friendly-fire immunity: bullets do not damage their own team's base
    if (bulletOwner.team === targetTeam) {
      return; // ignore friendly base hit
    }

    // Local player or our team's bot reports base hits to server.
    // Also report when enemy team is all bots (we are the authority for them).
    const isLocalAuthority = bulletOwner.isLocal || (bulletOwner.isBot && bulletOwner.team === this._myTeam);
    const isEnemyBotAuthority = this._enemyTeamAllBots && bulletOwner.isBot && bulletOwner.team !== this._myTeam;
    if ((isLocalAuthority || isEnemyBotAuthority) && this._networkManager) {
      this._networkManager.send(NET_MSG.BASE_HIT, {
        targetTeam,
        damage: 1,
        attackerId: bulletOwner.playerId,
      });

      // Update local stats
      if (this._stats[bulletOwner.playerId]) {
        this._stats[bulletOwner.playerId].baseDamage++;
      }
    }
  },

  _checkBulletVsTanks(bullet) {
    const bb = bullet.getBounds();
    const bulletOwner = this._players.find(p => p.playerId === bullet.ownerPlayerId);
    if (!bulletOwner) return;

    // Only perform tank hit detection for bullets from our team.
    // Enemy bullets are visual-only on our side; the enemy client is the
    // authority for those hits and will send PLAYER_KILLED.
    // Exception: when the enemy team has no human players (all bots),
    // we run enemy bot AI locally and must also resolve their bullet hits.
    if (bulletOwner.team !== this._myTeam && !this._enemyTeamAllBots) return;

    for (const player of this._players) {
      if (!player.tank.alive || player.isRespawning) continue;

      // Friendly fire protection: don't hit teammates
      if (player.team === bulletOwner.team) continue;

      const tb = player.tank.getBounds();
      if (this._rectsOverlap(bb, tb)) {
        const destroyed = player.tank.takeDamage(1);
        bullet.destroy();

        if (destroyed) {
          this._spawnExplosion(player.tank.x, player.tank.y, true);
          this._handlePlayerDeath(player, bulletOwner);
        } else {
          this._spawnExplosion(bullet.x, bullet.y, false);
        }
        return;
      }
    }
  },

  _checkBulletVsBullet(bullets) {
    for (let i = 0; i < bullets.length; i++) {
      if (!bullets[i].alive) continue;
      for (let j = i + 1; j < bullets.length; j++) {
        if (!bullets[j].alive) continue;

        // Only cancel bullets from different teams
        const ownerI = this._players.find(p => p.playerId === bullets[i].ownerPlayerId);
        const ownerJ = this._players.find(p => p.playerId === bullets[j].ownerPlayerId);
        if (ownerI && ownerJ && ownerI.team === ownerJ.team) continue;

        const a = bullets[i].getBounds();
        const b = bullets[j].getBounds();
        if (this._rectsOverlap(a, b)) {
          const mx = (bullets[i].x + bullets[j].x) / 2;
          const my = (bullets[i].y + bullets[j].y) / 2;
          bullets[i].destroy();
          bullets[j].destroy();
          this._spawnExplosion(mx, my, false);
        }
      }
    }
  },

  _separateTanks(tankA, tankB) {
    const a = tankA.getBounds();
    const b = tankB.getBounds();
    const overlapX = Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x);
    const overlapY = Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y);

    if (overlapX <= 0 || overlapY <= 0) return;

    // Save original positions in case push causes terrain collision
    const origAX = tankA.x, origAY = tankA.y;
    const origBX = tankB.x, origBY = tankB.y;

    if (overlapX < overlapY) {
      const sign = tankA.x < tankB.x ? -1 : 1;
      const push = overlapX / 2;
      tankA.x += sign * push;
      tankB.x -= sign * push;
    } else {
      const sign = tankA.y < tankB.y ? -1 : 1;
      const push = overlapY / 2;
      tankA.y += sign * push;
      tankB.y -= sign * push;
    }

    // Validate pushed positions against terrain; revert if stuck in wall
    if (this._mapManager) {
      const leftA = tankA.x - tankA.halfSize;
      const topA = tankA.y - tankA.halfSize;
      if (this._mapManager.rectCollidesWithTerrain(leftA, topA, tankA.size, tankA.size)) {
        tankA.x = origAX;
        tankA.y = origAY;
      }
      const leftB = tankB.x - tankB.halfSize;
      const topB = tankB.y - tankB.halfSize;
      if (this._mapManager.rectCollidesWithTerrain(leftB, topB, tankB.size, tankB.size)) {
        tankB.x = origBX;
        tankB.y = origBY;
      }
    }
  },

  _rectsOverlap(a, b) {
    return (
      a.x < b.x + b.w &&
      a.x + a.w > b.x &&
      a.y < b.y + b.h &&
      a.y + a.h > b.y
    );
  },

  // ============================================================
  // Game Logic
  // ============================================================
  _localFire() {
    if (!this._localPlayer || !this._localPlayer.tank.alive) return;
    if (!this._localPlayer.tank.canFire()) return;
    if (this._gameOver || this._paused) return;

    const tank = this._localPlayer.tank;
    const vec = DIR_VECTORS[tank.direction];
    const bullet = this._bulletPool.get();
    bullet.init({
      x: tank.x + vec.dx * tank.halfSize,
      y: tank.y + vec.dy * tank.halfSize,
      direction: tank.direction,
      owner: 'local',
      canBreakSteel: tank.canBreakSteel(),
      ownerTank: tank,
    });
    bullet.ownerPlayerId = this._myPlayerId;
    bullet._isAlly = true; // local player's bullets are always ally
    tank.activeBullets++;
    this._bullets.push(bullet);
    GameGlobal.audioManager.playSFX('shoot');

    // Send to network — use normalized grid coordinates
    if (this._networkManager) {
      this._networkManager.send(NET_MSG.BULLET_FIRE, {
        playerId: this._myPlayerId,
        col: (bullet.x - MAP_OFFSET_X) / TILE_SIZE,
        row: (bullet.y - MAP_OFFSET_Y) / TILE_SIZE,
        direction: bullet.direction,
        canBreakSteel: bullet.canBreakSteel,
      });
    }
  },

  _botFire(player) {
    if (!player.tank.alive || !player.tank.canFire()) return;

    const tank = player.tank;
    const vec = DIR_VECTORS[tank.direction];
    const bullet = this._bulletPool.get();
    bullet.init({
      x: tank.x + vec.dx * tank.halfSize,
      y: tank.y + vec.dy * tank.halfSize,
      direction: tank.direction,
      owner: 'bot',
      canBreakSteel: false,
      ownerTank: tank,
    });
    bullet.ownerPlayerId = player.playerId;
    bullet._isAlly = player.team === this._myTeam; // bot on my team = ally
    tank.activeBullets++;
    this._bullets.push(bullet);

    // Sync our team's bot bullets to the remote client
    if (player.team === this._myTeam && this._networkManager) {
      this._networkManager.send(NET_MSG.BULLET_FIRE, {
        playerId: player.playerId,
        col: (bullet.x - MAP_OFFSET_X) / TILE_SIZE,
        row: (bullet.y - MAP_OFFSET_Y) / TILE_SIZE,
        direction: bullet.direction,
        canBreakSteel: false,
      });
    }
  },

  _spawnRemoteBullet(data) {
    const player = this._players.find(p => p.playerId === data.playerId);
    if (!player) return;

    // Convert normalized grid coords back to local pixel coords
    let bx, by;
    if (data.col !== undefined && data.row !== undefined) {
      bx = MAP_OFFSET_X + data.col * TILE_SIZE;
      by = MAP_OFFSET_Y + data.row * TILE_SIZE;
    } else {
      bx = data.x;
      by = data.y;
    }

    const bullet = this._bulletPool.get();
    bullet.init({
      x: bx,
      y: by,
      direction: data.direction,
      owner: 'remote',
      canBreakSteel: data.canBreakSteel || false,
      ownerTank: player.tank,
    });
    bullet.ownerPlayerId = data.playerId;
    bullet._isAlly = player.team === this._myTeam; // remote on my team = ally
    player.tank.activeBullets++;
    this._bullets.push(bullet);
  },

  _spawnExplosion(x, y, isBig) {
    const exp = this._explosionPool.get();
    exp.init(x, y, isBig);
    this._explosions.push(exp);
    GameGlobal.audioManager.playSFX(isBig ? 'explosion_big' : 'explosion_small');
  },

  _clearSpawnArea(col, row) {
    // Clear a 3x3 area around the spawn point to ensure the tank
    // (whose size is ~0.85 tiles) won't overlap adjacent blocking tiles
    for (let dr = -1; dr <= 1; dr++) {
      for (let dc = -1; dc <= 1; dc++) {
        const r = row + dr;
        const c = col + dc;
        const terrain = this._mapManager.getTerrain(r, c);
        // Clear any tank-blocking terrain except BASE and RIVER
        if (terrain === TERRAIN.BRICK || terrain === TERRAIN.STEEL || terrain === TERRAIN.BASE_WALL) {
          this._mapManager.setTerrain(r, c, TERRAIN.EMPTY);
        }
      }
    }
  },

  _handlePlayerDeath(victim, killer) {
    // Update stats
    if (this._stats[killer.playerId]) {
      this._stats[killer.playerId].kills++;
    }
    if (this._stats[victim.playerId]) {
      this._stats[victim.playerId].deaths++;
    }

    // Start respawn timer
    this._startRespawn(victim);

    // If local player or our team's bot killed someone, notify server.
    // Also notify when enemy team is all bots (we are the authority for them).
    const isLocalAuthority = killer.isLocal || (killer.isBot && killer.team === this._myTeam);
    const isEnemyBotAuthority = this._enemyTeamAllBots && killer.isBot && killer.team !== this._myTeam;
    if ((isLocalAuthority || isEnemyBotAuthority) && this._networkManager) {
      this._networkManager.send(NET_MSG.PLAYER_KILLED, {
        killerId: killer.playerId,
        victimId: victim.playerId,
      });
    }

    // Play sound
    if (victim.isLocal) {
      GameGlobal.audioManager.playSFX('gameover');
    }
  },

  _startRespawn(player) {
    player.isRespawning = true;
    player.respawnTimer = this._battleConfig ? this._battleConfig.respawnDelay : TEAM_RESPAWN_DELAY;
    player.tank.alive = false;
  },

  _respawnPlayer(player) {
    player.isRespawning = false;
    player.respawnTimer = 0;
    player.tank.alive = true;
    player.tank.hp = 1;

    // Respawn at team spawn point
    const spawn = player.spawnPoint;
    // Clear spawn area to prevent getting stuck in rebuilt terrain
    this._clearSpawnArea(spawn.col, spawn.row);
    player.tank.x = MAP_OFFSET_X + spawn.col * TILE_SIZE + TILE_SIZE / 2;
    player.tank.y = MAP_OFFSET_Y + spawn.row * TILE_SIZE + TILE_SIZE / 2;
    player.tank.activateShield(3000);

    // Update remote target
    if (!player.isLocal) {
      this._remoteTargets[player.playerId] = {
        x: player.tank.x,
        y: player.tank.y,
        direction: player.tank.direction,
      };
    }
  },

  _updateExplosions(dt) {
    for (const exp of this._explosions) {
      exp.update(dt);
    }
  },

  _cleanup() {
    for (let i = this._bullets.length - 1; i >= 0; i--) {
      if (!this._bullets[i].alive) {
        this._bulletPool.put(this._bullets[i]);
        this._bullets.splice(i, 1);
      }
    }
    for (let i = this._explosions.length - 1; i >= 0; i--) {
      if (!this._explosions[i].alive) {
        this._explosionPool.put(this._explosions[i]);
        this._explosions.splice(i, 1);
      }
    }
  },

  _transitionToResult() {
    const sm = GameGlobal.sceneManager;
    if (!sm._scenes.has(SCENE.TEAM_RESULT)) {
      const TeamResultScene = require('./TeamResultScene');
      sm.register(SCENE.TEAM_RESULT, TeamResultScene);
    }

    const didWin = this._winner === this._myTeam;

    sm.switchTo(SCENE.TEAM_RESULT, {
      winner: this._winner,
      winReason: this._winReason,
      myTeam: this._myTeam,
      didWin,
      isDraw: false, // No draw in base-destruction mode
      teamABaseHp: this._teamABaseHp,
      teamBBaseHp: this._teamBBaseHp,
      stats: this._stats,
      players: this._players.map(p => ({
        playerId: p.playerId,
        nickname: p.nickname || '',
        team: p.team,
        isBot: p.isBot,
        isLocal: p.isLocal,
      })),
      elapsedTime: Math.floor(this._elapsedTime),
      teamId: this._teamId,
      battleMode: this._battleMode,
    });
  },

  // ============================================================
  // Render
  // ============================================================
  render(ctx) {
    if (!this._initialized) return;

    // Game area background
    ctx.fillStyle = '#111111';
    ctx.fillRect(MAP_OFFSET_X, MAP_OFFSET_Y, MAP_WIDTH, MAP_HEIGHT);

    // Render map
    this._mapManager.render(ctx);

    // Render all tanks
    for (const player of this._players) {
      if (player.tank.alive && !player.isRespawning) {
        player.tank.render(ctx);

        // Name & team indicator above the tank
        const tx = player.tank.x;
        const labelY = player.tank.y - player.tank.halfSize - 4;
        const nameY = labelY - 10;

        // Per-tank team color:
        // - local player   → gold
        // - Team A (ally or enemy) → blue
        // - Team B (ally or enemy) → red
        let labelColor;
        if (player.isLocal) labelColor = LOCAL_PLAYER_COLOR;
        else labelColor = player.team === 'A' ? TEAM_A_COLOR : TEAM_B_COLOR;

        ctx.fillStyle = labelColor;
        ctx.textAlign = 'center';
        ctx.textBaseline = 'middle';

        // Arrow / bot tag
        ctx.font = 'bold 8px Arial';
        let marker;
        if (player.isLocal) marker = '★';
        else if (player.isBot) marker = '🤖';
        else marker = (player.team === this._myTeam) ? '▲' : '▼';
        ctx.fillText(marker, tx, labelY);

        // Nickname (truncated to 4 Chinese-equivalent chars)
        const name = this._getTankLabel(player);
        if (name) {
          ctx.font = 'bold 9px Arial';
          // Outline for readability on busy backgrounds
          ctx.lineWidth = 3;
          ctx.strokeStyle = 'rgba(0,0,0,0.7)';
          ctx.strokeText(name, tx, nameY);
          ctx.fillText(name, tx, nameY);
        }
      }
    }

    // Render forest overlay
    this._mapManager.renderForestOverlay(ctx);

    // Render bullets
    for (const bullet of this._bullets) {
      bullet.render(ctx);
    }

    // Render explosions
    for (const exp of this._explosions) {
      exp.render(ctx);
    }

    // Render HUD
    this._renderHUD(ctx);

    // Render controls
    this._joystick.render(ctx);
    this._fireButton.render(ctx);

    // Respawn overlay
    if (this._localPlayer && this._localPlayer.isRespawning) {
      this._renderRespawnOverlay(ctx);
    }

    // Pause overlay
    if (this._paused) {
      this._renderPauseOverlay(ctx);
    }

    // Game over overlay
    if (this._gameOver) {
      this._renderGameOverOverlay(ctx);
    }

    // Disconnection overlay
    if (this._isDisconnected) {
      this._renderDisconnectOverlay(ctx);
    }
  },

  _getTeamStats(team) {
    let kills = 0, deaths = 0;
    for (const p of this._players) {
      if (p.team === team && this._stats[p.playerId]) {
        kills += this._stats[p.playerId].kills;
        deaths += this._stats[p.playerId].deaths;
      }
    }
    return { kills, deaths };
  },

  /**
   * Compute a short label (≤ 4 Chinese-equivalent chars) to draw above a tank.
   * Uses real WeChat nickname if available, otherwise a stable fallback.
   * @private
   */
  _getTankLabel(player) {
    if (!player) return '';
    const profile = GameGlobal.playerProfile;
    let raw = '';
    if (player.isLocal) {
      // For local player prefer the freshest profile nickname if granted.
      if (profile && profile.nickname) raw = profile.nickname;
      else raw = player.nickname || '';
    } else {
      // For remote players, use the server-provided nickname.
      // Do NOT fall back to profile.getDisplayName() because that returns
      // the LOCAL player's nickname when set, which would show the wrong
      // name for every remote player.
      raw = player.nickname || '';
    }
    if (!raw) {
      if (player.isBot) {
        raw = ''; // bot — we already draw the 🤖 marker, skip name
      } else if (player.playerId && typeof player.playerId === 'string') {
        // Derive a stable anonymous tag from the remote player's own ID.
        const tail = player.playerId.slice(-4).toUpperCase();
        raw = `Tanker_${tail}`;
      } else {
        raw = '';
      }
    }
    if (!raw) return '';
    if (profile && typeof profile.truncate === 'function') {
      return profile.truncate(raw, 4);
    }
    return raw.length > 8 ? raw.substring(0, 8) + '..' : raw;
  },

  _renderHUD(ctx) {
    const hudY = 4;

    // Team A base HP (left)
    const barWidth = 80;
    const barHeight = 12;
    const barY = hudY + 2;
    const timeGap = 30; // half-width reserved for the timer in the center

    // Team A label + HP bar
    const teamALabel = this._battleMode === '1v1' ? 'P1' : t('team.teamA');
    const teamBLabel = this._battleMode === '1v1' ? 'P2' : t('team.teamB');
    ctx.fillStyle = this._battleMode === '1v1' ? PLAYER1_COLOR : TEAM_A_COLOR;
    ctx.font = 'bold 10px Arial';
    ctx.textAlign = 'right';
    ctx.textBaseline = 'top';
    ctx.fillText(teamALabel, SCREEN_WIDTH / 2 - timeGap - barWidth - 5, barY);

    // Team A HP bar background
    const barAX = SCREEN_WIDTH / 2 - timeGap;
    ctx.fillStyle = '#333333';
    ctx.fillRect(barAX, barY, -barWidth, barHeight);

    // Team A HP bar fill
    const maxBaseHp = this._battleConfig ? this._battleConfig.baseHp : TEAM_BASE_HP;
    const hpRatioA = this._teamABaseHp / maxBaseHp;
    const teamADisplayColor = this._battleMode === '1v1' ? PLAYER1_COLOR : TEAM_A_COLOR;
    const teamBDisplayColor = this._battleMode === '1v1' ? PLAYER2_COLOR : TEAM_B_COLOR;
    ctx.fillStyle = hpRatioA > 0.3 ? teamADisplayColor : '#FF4444';
    ctx.fillRect(barAX, barY, -barWidth * hpRatioA, barHeight);

    // Team A HP text
    ctx.fillStyle = '#FFFFFF';
    ctx.font = 'bold 9px Arial';
    ctx.textAlign = 'center';
    ctx.fillText(`${this._teamABaseHp}`, barAX - barWidth / 2, barY + barHeight / 2 + 1);

    // Elapsed time (center, count up)
    const minutes = Math.floor(this._elapsedTime / 60);
    const seconds = Math.floor(this._elapsedTime % 60);
    const timeStr = `${minutes}:${seconds.toString().padStart(2, '0')}`;

    ctx.fillStyle = '#FFFFFF';
    ctx.font = 'bold 16px Arial';
    ctx.textAlign = 'center';
    ctx.fillText(timeStr, SCREEN_WIDTH / 2, hudY);

    // Team B label + HP bar
    const barBStart = SCREEN_WIDTH / 2 + timeGap;
    ctx.fillStyle = this._battleMode === '1v1' ? PLAYER2_COLOR : TEAM_B_COLOR;
    ctx.font = 'bold 10px Arial';
    ctx.textAlign = 'left';
    ctx.fillText(teamBLabel, barBStart + barWidth + 5, barY);

    // Team B HP bar background
    ctx.fillStyle = '#333333';
    ctx.fillRect(barBStart, barY, barWidth, barHeight);

    // Team B HP bar fill
    const hpRatioB = this._teamBBaseHp / maxBaseHp;
    ctx.fillStyle = hpRatioB > 0.3 ? teamBDisplayColor : '#FF4444';
    ctx.fillRect(barBStart, barY, barWidth * hpRatioB, barHeight);

    // Team B HP text
    ctx.fillStyle = '#FFFFFF';
    ctx.font = 'bold 9px Arial';
    ctx.textAlign = 'center';
    ctx.fillText(`${this._teamBBaseHp}`, barBStart + barWidth / 2, barY + barHeight / 2 + 1);

    // My team indicator
    if (this._battleMode === '1v1') {
      const mySlot = this._myTeam === 'A' ? 1 : 2;
      ctx.fillStyle = this._myTeam === 'A' ? PLAYER1_COLOR : PLAYER2_COLOR;
      ctx.font = '9px Arial';
      ctx.textAlign = 'center';
      ctx.fillText(t('pvp.playerLabel', { slot: mySlot }), SCREEN_WIDTH / 2, hudY + 20);
    } else {
      ctx.fillStyle = this._myTeam === 'A' ? TEAM_A_COLOR : TEAM_B_COLOR;
      ctx.font = '9px Arial';
      ctx.textAlign = 'center';
      ctx.fillText(t('team.myTeam', { team: this._myTeam }), SCREEN_WIDTH / 2, hudY + 20);
    }

    // Team kill/death totals
    const myTeamStats = this._getTeamStats(this._myTeam);
    const enemyTeam = this._myTeam === 'A' ? 'B' : 'A';
    const enemyTeamStats = this._getTeamStats(enemyTeam);

    ctx.fillStyle = '#AAAAAA';
    ctx.font = '10px Arial';
    ctx.textAlign = 'left';
    ctx.fillText(t('team.killDeath', { kills: myTeamStats.kills, deaths: myTeamStats.deaths }), 10, hudY);

    ctx.textAlign = 'right';
    ctx.fillText(t('team.killDeath', { kills: enemyTeamStats.kills, deaths: enemyTeamStats.deaths }), SCREEN_WIDTH - 10, hudY);

    // Latency
    if (this._networkManager) {
      ctx.fillStyle = '#666666';
      ctx.font = '9px Arial';
      ctx.textAlign = 'right';
      ctx.fillText(`${this._networkManager.latency || 0}ms`, SCREEN_WIDTH - 10, hudY + 14);
    }
  },

  _renderRespawnOverlay(ctx) {
    const remaining = Math.ceil(this._localPlayer.respawnTimer / 1000);
    ctx.fillStyle = 'rgba(0,0,0,0.3)';
    ctx.fillRect(SCREEN_WIDTH / 2 - 60, SCREEN_HEIGHT / 2 - 25, 120, 50);

    ctx.fillStyle = '#FFFFFF';
    ctx.font = 'bold 14px Arial';
    ctx.textAlign = 'center';
    ctx.textBaseline = 'middle';
    ctx.fillText(t('team.respawn', { seconds: remaining }), SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2);
  },

  _renderPauseOverlay(ctx) {
    ctx.fillStyle = 'rgba(0,0,0,0.6)';
    ctx.fillRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);

    ctx.fillStyle = '#FFFFFF';
    ctx.font = 'bold 28px Arial';
    ctx.textAlign = 'center';
    ctx.textBaseline = 'middle';
    ctx.fillText(t('common.paused'), SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 - 40);

    ctx.font = '16px Arial';
    ctx.fillText(t('common.tapContinue'), SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 + 10);
  },

  _renderGameOverOverlay(ctx) {
    ctx.fillStyle = 'rgba(0,0,0,0.5)';
    ctx.fillRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);

    let text, color;
    if (this._winner === this._myTeam) {
      text = t('team.victory');
      color = '#00FF00';
    } else {
      text = t('team.defeat');
      color = '#FF0000';
    }

    ctx.fillStyle = color;
    ctx.font = 'bold 36px Arial';
    ctx.textAlign = 'center';
    ctx.textBaseline = 'middle';
    ctx.fillText(text, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 - 10);

    // Base HP summary
    ctx.fillStyle = '#FFFFFF';
    ctx.font = '14px Arial';
    if (this._battleMode === '1v1') {
      ctx.fillText(
        t('pvp.baseHpSummary', { hp1: this._teamABaseHp, hp2: this._teamBBaseHp }),
        SCREEN_WIDTH / 2,
        SCREEN_HEIGHT / 2 + 25
      );
    } else {
      ctx.fillText(
        t('team.baseHpSummary', { hpA: this._teamABaseHp, hpB: this._teamBBaseHp }),
        SCREEN_WIDTH / 2,
        SCREEN_HEIGHT / 2 + 25
      );
    }
  },

  _renderDisconnectOverlay(ctx) {
    ctx.fillStyle = 'rgba(0,0,0,0.7)';
    ctx.fillRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);

    ctx.fillStyle = '#FF6347';
    ctx.font = 'bold 20px Arial';
    ctx.textAlign = 'center';
    ctx.textBaseline = 'middle';
    ctx.fillText(t('team.disconnectTitle'), SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2 - 30);

    const dots = '.'.repeat(Math.floor(this._reconnectTimer * 3) % 4);
    ctx.fillStyle = '#FFFFFF';
    ctx.font = '14px Arial';
    ctx.fillText(
      t('team.reconnecting', { dots, attempts: this._reconnectAttempts, max: this._maxReconnectAttempts }),
      SCREEN_WIDTH / 2,
      SCREEN_HEIGHT / 2 + 5
    );

    ctx.fillStyle = '#AAAAAA';
    ctx.font = '12px Arial';
    ctx.fillText(
      t('team.reconnectHint'),
      SCREEN_WIDTH / 2,
      SCREEN_HEIGHT / 2 + 30
    );
  },

  async _attemptReconnect() {
    this._reconnectAttempts++;
    console.log(`[TeamGameScene] Reconnect attempt ${this._reconnectAttempts}/${this._maxReconnectAttempts}`);

    if (this._reconnectAttempts > this._maxReconnectAttempts) {
      // Give up reconnecting — treat as defeat
      this._isDisconnected = false;
      this._winner = this._myTeam === 'A' ? 'B' : 'A';
      this._winReason = 'disconnected';
      this._gameOver = true;
      return;
    }

    const nm = this._networkManager;
    if (!nm) return;

    try {
      // Try to reconnect to server
      const { SERVER_URL } = require('../base/GameGlobal');
      const ok = await nm.connect(SERVER_URL);
      if (ok) {
        // Send reconnect message
        nm.send(NET_MSG.RECONNECT, {
          teamId: this._teamId,
          playerId: this._myPlayerId,
        });
      }
    } catch (e) {
      console.error('[TeamGameScene] Reconnect failed:', e);
    }
  },

  // ============================================================
  // Touch Handling
  // ============================================================
  handleTouch(eventType, e) {
    if (this._gameOver) return;

    if (this._paused) {
      if (eventType === 'touchstart') {
        this._paused = false;
      }
      return;
    }

    const touches = eventType === 'touchend' ? e.changedTouches : e.touches;
    for (let i = 0; i < touches.length; i++) {
      const touch = touches[i];
      if (this._joystick.handleTouch(eventType, touch)) continue;
      if (this._fireButton.handleTouch(eventType, touch)) continue;

      // Pause button area
      if (eventType === 'touchstart') {
        if (touch.clientX > SCREEN_WIDTH - 50 && touch.clientY < MAP_OFFSET_Y) {
          this._paused = true;
        }
      }
    }
  },
};

module.exports = TeamGameScene;