const { Match, MatchGame, MatchPlayer, MatchRound, LadderUser, User, Store, sequelize } = require('../models');
const { MATCH_TYPES, MATCH_STATUS, CONFIRM_STATUS, RANKING_STAGE, MATCH_WEIGHTS, POWER_CALC } = require('../config/constants');
const { generateMatchCode, success, error, getPagination, pageResult } = require('../utils/helper');
const PowerCalculator = require('../services/powerCalculator');
const { sendChallengeNotification, sendScoreConfirmNotification, sendMatchNotification } = require('../websocket');
const { Op } = require('sequelize');

class MatchController {
  // 检查是否可以发起挑战
  async checkChallenge(req, res) {
    try {
      const { targetMemberCode } = req.params;
      const { store_id } = req.query;
      const user = req.user;

      // 获取自己的天梯用户
      const myLadderUser = await LadderUser.findOne({
        where: { user_id: user.id, store_id, status: 1 }
      });

      if (!myLadderUser) {
        return res.json(success({ canChallenge: false, reason: '您还不是该门店的天梯用户' }));
      }

      // 通过会员码获取对手
      const targetUser = await User.findOne({ where: { member_code: targetMemberCode } });
      if (!targetUser) {
        return res.json(success({ canChallenge: false, reason: '未找到该用户' }));
      }

      if (targetUser.id === user.id) {
        return res.json(success({ canChallenge: false, reason: '不能挑战自己' }));
      }

      // 获取对手的天梯用户
      const targetLadderUser = await LadderUser.findOne({
        where: { user_id: targetUser.id, store_id, status: 1 }
      });

      if (!targetLadderUser) {
        return res.json(success({ canChallenge: false, reason: '对方不是该门店的天梯用户' }));
      }

      // 检查30天内是否已经比赛过
      const recentMatch = await MatchGame.findOne({
        where: {
          [Op.or]: [
            { player1_id: myLadderUser.id, player2_id: targetLadderUser.id },
            { player1_id: targetLadderUser.id, player2_id: myLadderUser.id }
          ],
          confirm_status: CONFIRM_STATUS.CONFIRMED,
          created_at: { [Op.gte]: new Date(Date.now() - POWER_CALC.CHALLENGE_COOLDOWN * 24 * 60 * 60 * 1000) }
        },
        include: [{
          model: Match,
          as: 'match',
          where: { type: MATCH_TYPES.CHALLENGE }
        }]
      });

      if (recentMatch) {
        const days = PowerCalculator.getCooldownDays(recentMatch.created_at);
        return res.json(success({
          canChallenge: false,
          reason: `30天内已与对方比赛过，还需等待${days}天`
        }));
      }

      res.json(success({
        canChallenge: true,
        targetUser: {
          id: targetUser.id,
          nickname: targetUser.nickname,
          avatar: targetUser.avatar,
          ladderUser: {
            id: targetLadderUser.id,
            realName: targetLadderUser.real_name,
            level: targetLadderUser.level,
            powerScore: targetLadderUser.power_score
          }
        },
        myLadderUser: {
          id: myLadderUser.id,
          realName: myLadderUser.real_name,
          level: myLadderUser.level,
          powerScore: myLadderUser.power_score
        }
      }));
    } catch (err) {
      console.error('检查挑战失败:', err);
      res.status(500).json(error('检查失败'));
    }
  }

  // 发起挑战
  async createChallenge(req, res) {
    const t = await sequelize.transaction();
    try {
      const { store_id, target_member_code } = req.body;
      const user = req.user;

      // 获取双方天梯用户
      const myLadderUser = await LadderUser.findOne({
        where: { user_id: user.id, store_id, status: 1 }
      });

      const targetUser = await User.findOne({ where: { member_code: target_member_code } });
      const targetLadderUser = await LadderUser.findOne({
        where: { user_id: targetUser.id, store_id, status: 1 }
      });

      if (!myLadderUser || !targetLadderUser) {
        await t.rollback();
        return res.status(400).json(error('天梯用户信息无效', 400));
      }

      // 检查发起者是否有未结束的挑战赛
      const myOngoingMatch = await Match.findOne({
        where: {
          store_id,
          type: MATCH_TYPES.CHALLENGE,
          status: { [Op.in]: [MATCH_STATUS.PENDING, MATCH_STATUS.ONGOING] },
          [Op.or]: [
            { challenger_id: myLadderUser.id },
            { defender_id: myLadderUser.id }
          ]
        }
      });

      if (myOngoingMatch) {
        await t.rollback();
        return res.status(400).json(error('您有未结束的挑战赛，请先完成后再发起新的挑战', 400));
      }

      // 检查被挑战者是否有未结束的挑战赛
      const targetOngoingMatch = await Match.findOne({
        where: {
          store_id,
          type: MATCH_TYPES.CHALLENGE,
          status: { [Op.in]: [MATCH_STATUS.PENDING, MATCH_STATUS.ONGOING] },
          [Op.or]: [
            { challenger_id: targetLadderUser.id },
            { defender_id: targetLadderUser.id }
          ]
        }
      });

      if (targetOngoingMatch) {
        await t.rollback();
        return res.status(400).json(error('对方有未结束的挑战赛，请稍后再试', 400));
      }

      // 创建挑战赛
      const match = await Match.create({
        store_id,
        match_code: generateMatchCode(),
        type: MATCH_TYPES.CHALLENGE,
        name: `${myLadderUser.real_name} vs ${targetLadderUser.real_name}`,
        weight: MATCH_WEIGHTS.CHALLENGE,
        challenger_id: myLadderUser.id,
        defender_id: targetLadderUser.id,
        status: MATCH_STATUS.PENDING
      }, { transaction: t });

      // 创建对局
      await MatchGame.create({
        match_id: match.id,
        player1_id: myLadderUser.id,
        player2_id: targetLadderUser.id,
        status: 0
      }, { transaction: t });

      await t.commit();

      // 发送WebSocket通知给被挑战者
      sendChallengeNotification(targetUser.id, {
        matchId: match.id,
        matchCode: match.match_code,
        challenger: {
          id: myLadderUser.id,
          realName: myLadderUser.real_name,
          level: myLadderUser.level,
          powerScore: myLadderUser.power_score,
          nickname: user.nickname,
          avatar: user.avatar
        }
      });

      res.json(success({
        matchId: match.id,
        matchCode: match.match_code
      }, '挑战已发起'));
    } catch (err) {
      await t.rollback();
      console.error('发起挑战失败:', err);
      res.status(500).json(error('发起挑战失败'));
    }
  }

  // 响应挑战
  async respondChallenge(req, res) {
    const t = await sequelize.transaction();
    try {
      const { match_id, accept } = req.body;
      const user = req.user;

      const match = await Match.findByPk(match_id, {
        include: [{ model: MatchGame, as: 'games' }]
      });

      if (!match || match.status !== MATCH_STATUS.PENDING) {
        await t.rollback();
        return res.status(400).json(error('比赛不存在或状态无效', 400));
      }

      // 验证是否是被挑战者
      const defenderLadderUser = await LadderUser.findByPk(match.defender_id);
      if (defenderLadderUser.user_id !== user.id) {
        await t.rollback();
        return res.status(403).json(error('您不是被挑战者', 403));
      }

      // 如果接受挑战，检查是否有其他未结束的挑战赛
      if (accept) {
        const otherOngoingMatch = await Match.findOne({
          where: {
            store_id: match.store_id,
            type: MATCH_TYPES.CHALLENGE,
            status: { [Op.in]: [MATCH_STATUS.PENDING, MATCH_STATUS.ONGOING] },
            id: { [Op.ne]: match_id },
            [Op.or]: [
              { challenger_id: defenderLadderUser.id },
              { defender_id: defenderLadderUser.id }
            ]
          }
        });

        if (otherOngoingMatch) {
          await t.rollback();
          return res.status(400).json(error('您有未结束的挑战赛，请先完成后再接受新的挑战', 400));
        }
      }

      if (accept) {
        // 接受挑战
        await match.update({ status: MATCH_STATUS.ONGOING, start_time: new Date() }, { transaction: t });
        await MatchGame.update(
          { status: 1 },
          { where: { match_id: match.id }, transaction: t }
        );
      } else {
        // 拒绝挑战
        await match.update({ status: MATCH_STATUS.CANCELLED }, { transaction: t });
      }

      await t.commit();

      // 通知挑战者
      const challengerLadderUser = await LadderUser.findByPk(match.challenger_id);
      const challengerUser = await User.findByPk(challengerLadderUser.user_id);

      sendChallengeNotification(challengerUser.id, {
        type: accept ? 'challenge_accepted' : 'challenge_rejected',
        matchId: match.id
      });

      res.json(success(null, accept ? '已接受挑战' : '已拒绝挑战'));
    } catch (err) {
      await t.rollback();
      console.error('响应挑战失败:', err);
      res.status(500).json(error('操作失败'));
    }
  }

  // 提交比分
  async submitScore(req, res) {
    const t = await sequelize.transaction();
    try {
      const { match_id, my_score, opponent_score } = req.body;
      const user = req.user;

      const match = await Match.findByPk(match_id, {
        include: [{ model: MatchGame, as: 'games' }]
      });

      if (!match || match.status !== MATCH_STATUS.ONGOING) {
        await t.rollback();
        return res.status(400).json(error('比赛不存在或状态无效', 400));
      }

      const game = match.games[0];

      // 获取提交者的天梯用户
      const myLadderUser = await LadderUser.findOne({
        where: { user_id: user.id, store_id: match.store_id, status: 1 }
      });

      if (!myLadderUser) {
        await t.rollback();
        return res.status(403).json(error('您不是参赛者', 403));
      }

      // 确定比分
      let player1Score, player2Score, winnerId, loserId;
      if (myLadderUser.id === game.player1_id) {
        player1Score = my_score;
        player2Score = opponent_score;
      } else if (myLadderUser.id === game.player2_id) {
        player1Score = opponent_score;
        player2Score = my_score;
      } else {
        await t.rollback();
        return res.status(403).json(error('您不是参赛者', 403));
      }

      // 确定胜败（比分高者胜）
      if (player1Score > player2Score) {
        winnerId = game.player1_id;
        loserId = game.player2_id;
      } else {
        winnerId = game.player2_id;
        loserId = game.player1_id;
      }

      // 只有胜者可以提交比分
      if (myLadderUser.id !== winnerId) {
        await t.rollback();
        return res.status(400).json(error('败方不能提交比分，请等待胜方提交', 400));
      }

      await game.update({
        player1_score: player1Score,
        player2_score: player2Score,
        winner_id: winnerId,
        loser_id: loserId,
        submit_by: myLadderUser.id,
        confirm_status: CONFIRM_STATUS.PENDING,
        status: 2
      }, { transaction: t });

      await t.commit();

      // 通知败方确认
      const loserLadderUser = await LadderUser.findByPk(loserId);
      const loserUser = await User.findByPk(loserLadderUser.user_id);

      sendScoreConfirmNotification(loserUser.id, {
        matchId: match.id,
        gameId: game.id,
        player1Score,
        player2Score,
        submitter: {
          realName: myLadderUser.real_name
        }
      });

      res.json(success(null, '比分已提交，等待对方确认'));
    } catch (err) {
      await t.rollback();
      console.error('提交比分失败:', err);
      res.status(500).json(error('提交失败'));
    }
  }

  // 确认比分
  async confirmScore(req, res) {
    const t = await sequelize.transaction();
    try {
      const { game_id, confirm } = req.body;
      const user = req.user;

      const game = await MatchGame.findByPk(game_id, {
        include: [{ model: Match, as: 'match' }]
      });

      if (!game || game.confirm_status !== CONFIRM_STATUS.PENDING) {
        await t.rollback();
        return res.status(400).json(error('比赛不存在或状态无效', 400));
      }

      // 获取确认者的天梯用户
      const myLadderUser = await LadderUser.findOne({
        where: { user_id: user.id, store_id: game.match.store_id, status: 1 }
      });

      // 败方确认
      if (myLadderUser.id !== game.loser_id) {
        await t.rollback();
        return res.status(403).json(error('只有败方可以确认比分', 403));
      }

      if (!confirm) {
        // 有争议，重置比分
        await game.update({
          player1_score: null,
          player2_score: null,
          winner_id: null,
          loser_id: null,
          submit_by: null,
          confirm_status: CONFIRM_STATUS.DISPUTED,
          status: 1
        }, { transaction: t });

        await t.commit();
        return res.json(success(null, '已标记为有争议，请重新比赛'));
      }

      // 确认比分，计算战力值变动
      const winner = await LadderUser.findByPk(game.winner_id);
      const loser = await LadderUser.findByPk(game.loser_id);

      const { winnerChange, loserChange } = PowerCalculator.calculate(
        { powerScore: winner.power_score, level: winner.level, protectedMatches: winner.protected_matches },
        { powerScore: loser.power_score, level: loser.level, protectedMatches: loser.protected_matches },
        parseFloat(game.match.weight)
      );

      // 更新游戏记录
      await game.update({
        confirm_status: CONFIRM_STATUS.CONFIRMED,
        confirmed_by: myLadderUser.id,
        confirmed_at: new Date(),
        winner_power_change: winnerChange,
        loser_power_change: loserChange
      }, { transaction: t });

      // 更新胜者战力值和统计
      await winner.update({
        power_score: winner.power_score + winnerChange,
        match_count: winner.match_count + 1,
        monthly_match_count: winner.monthly_match_count + 1,
        win_count: winner.win_count + 1,
        last_match_time: new Date()
      }, { transaction: t });

      // 更新败者战力值和统计
      const newLoserProtected = loser.level <= 2 && loser.protected_matches < POWER_CALC.NEWBIE_PROTECTION
        ? loser.protected_matches + 1
        : loser.protected_matches;

      await loser.update({
        power_score: Math.max(0, loser.power_score + loserChange),
        match_count: loser.match_count + 1,
        monthly_match_count: loser.monthly_match_count + 1,
        protected_matches: newLoserProtected,
        last_match_time: new Date()
      }, { transaction: t });

      // 更新比赛状态
      await game.match.update({
        status: MATCH_STATUS.FINISHED,
        end_time: new Date()
      }, { transaction: t });

      await t.commit();

      res.json(success({
        winnerChange,
        loserChange,
        winnerNewScore: winner.power_score + winnerChange,
        loserNewScore: Math.max(0, loser.power_score + loserChange)
      }, '比分已确认'));
    } catch (err) {
      await t.rollback();
      console.error('确认比分失败:', err);
      res.status(500).json(error('确认失败'));
    }
  }

  // 加入排位赛
  async joinRankingMatch(req, res) {
    const t = await sequelize.transaction();
    try {
      const { match_code } = req.body;
      const user = req.user;

      const match = await Match.findOne({
        where: { match_code, type: MATCH_TYPES.RANKING }
      });

      if (!match) {
        await t.rollback();
        return res.status(404).json(error('比赛不存在', 404));
      }

      if (match.stage !== RANKING_STAGE.SIGNUP) {
        await t.rollback();
        return res.status(400).json(error('比赛已开始，无法加入', 400));
      }

      // 获取天梯用户
      const ladderUser = await LadderUser.findOne({
        where: { user_id: user.id, store_id: match.store_id, status: 1 }
      });

      if (!ladderUser) {
        await t.rollback();
        return res.status(400).json(error('您不是该门店的天梯用户', 400));
      }

      // 检查是否已加入
      const existing = await MatchPlayer.findOne({
        where: { match_id: match.id, ladder_user_id: ladderUser.id }
      });

      if (existing) {
        await t.rollback();
        return res.status(400).json(error('您已加入该比赛', 400));
      }

      // 加入比赛
      await MatchPlayer.create({
        match_id: match.id,
        ladder_user_id: ladderUser.id,
        initial_power: ladderUser.power_score,
        player_status: 'waiting'
      }, { transaction: t });

      await t.commit();

      res.json(success({
        matchId: match.id,
        matchName: match.name
      }, '加入成功'));
    } catch (err) {
      await t.rollback();
      console.error('加入排位赛失败:', err);
      res.status(500).json(error('加入失败'));
    }
  }

  // 获取排位赛详情
  async getRankingDetail(req, res) {
    try {
      const { matchCode } = req.params;

      const match = await Match.findOne({
        where: { match_code: matchCode },
        include: [
          {
            model: MatchPlayer,
            as: 'players',
            include: [{ model: LadderUser, as: 'ladderUser', include: [{ model: User, as: 'user' }] }]
          },
          { model: MatchRound, as: 'rounds', include: [{ model: MatchGame, as: 'games' }] },
          { model: Store, as: 'store' }
        ]
      });

      if (!match) {
        return res.status(404).json(error('比赛不存在', 404));
      }

      const stageNames = ['报名中', '循环赛', '淘汰赛', '已结束'];
      const statusNames = ['待开始', '进行中', '已结束', '已取消'];

      res.json(success({
        id: match.id,
        matchCode: match.match_code,
        name: match.name,
        status: match.status,
        statusName: statusNames[match.status] || '未知',
        stage: match.stage,
        stageName: stageNames[match.stage] || '未知',
        weight: match.weight,
        storeName: match.store?.name,
        startTime: match.start_time,
        players: match.players.map(p => ({
          id: p.id,
          ladderUserId: p.ladder_user_id,
          realName: p.ladderUser?.real_name,
          nickname: p.ladderUser?.user?.nickname,
          avatar: p.ladderUser?.user?.avatar,
          level: p.ladderUser?.level,
          initialPower: p.initial_power,
          winCount: p.win_count,
          loseCount: p.lose_count,
          rank: p.rank,
          status: p.player_status
        })),
        rounds: match.rounds.map(r => ({
          id: r.id,
          roundNumber: r.round_number,
          roundType: r.round_type,
          roundName: r.round_name,
          status: r.status,
          games: r.games.map(g => ({
            id: g.id,
            player1Id: g.player1_id,
            player2Id: g.player2_id,
            player1Score: g.player1_score,
            player2Score: g.player2_score,
            winnerId: g.winner_id,
            confirmStatus: g.confirm_status,
            status: g.status
          }))
        }))
      }));
    } catch (err) {
      console.error('获取排位赛详情失败:', err);
      res.status(500).json(error('获取失败'));
    }
  }

  // 获取我的当前对局
  async getMyCurrentGame(req, res) {
    try {
      const { matchCode } = req.params;
      const user = req.user;

      const match = await Match.findOne({ where: { match_code: matchCode } });
      if (!match) {
        return res.status(404).json(error('比赛不存在', 404));
      }

      const ladderUser = await LadderUser.findOne({
        where: { user_id: user.id, store_id: match.store_id, status: 1 }
      });

      if (!ladderUser) {
        return res.status(400).json(error('您不是参赛者', 400));
      }

      const player = await MatchPlayer.findOne({
        where: { match_id: match.id, ladder_user_id: ladderUser.id }
      });

      if (!player) {
        return res.status(400).json(error('您不是参赛者', 400));
      }

      // 查找当前进行中的对局
      const currentGame = await MatchGame.findOne({
        where: {
          match_id: match.id,
          [Op.or]: [
            { player1_id: ladderUser.id },
            { player2_id: ladderUser.id }
          ],
          status: { [Op.lt]: 2 }  // 未结束
        },
        include: [{ model: MatchRound, as: 'round' }]
      });

      if (!currentGame) {
        return res.json(success({
          status: player.player_status,
          currentGame: null
        }));
      }

      // 获取对手信息
      const opponentId = currentGame.player1_id === ladderUser.id
        ? currentGame.player2_id
        : currentGame.player1_id;
      const opponent = await LadderUser.findByPk(opponentId, {
        include: [{ model: User, as: 'user' }]
      });

      res.json(success({
        status: player.player_status,
        currentGame: {
          id: currentGame.id,
          roundName: currentGame.round?.round_name,
          opponent: {
            id: opponent.id,
            realName: opponent.real_name,
            nickname: opponent.user?.nickname,
            avatar: opponent.user?.avatar,
            level: opponent.level,
            powerScore: opponent.power_score
          },
          myScore: currentGame.player1_id === ladderUser.id
            ? currentGame.player1_score
            : currentGame.player2_score,
          opponentScore: currentGame.player1_id === ladderUser.id
            ? currentGame.player2_score
            : currentGame.player1_score,
          confirmStatus: currentGame.confirm_status,
          gameStatus: currentGame.status
        }
      }));
    } catch (err) {
      console.error('获取当前对局失败:', err);
      res.status(500).json(error('获取失败'));
    }
  }

  // 提交排位赛比分
  async submitRankingScore(req, res) {
    // 逻辑与挑战赛类似，但需要处理排位赛的轮次逻辑
    return this.submitScore(req, res);
  }

  // 确认排位赛比分
  async confirmRankingScore(req, res) {
    return this.confirmScore(req, res);
  }

  // 获取我的比赛记录
  async getMyMatches(req, res) {
    try {
      const { store_id, page = 1, pageSize = 20 } = req.query;
      const { limit, offset } = getPagination(page, pageSize);
      const user = req.user;

      const ladderUser = await LadderUser.findOne({
        where: { user_id: user.id, store_id, status: 1 }
      });

      if (!ladderUser) {
        return res.json(pageResult([], 0, page, pageSize));
      }

      const { rows, count } = await MatchGame.findAndCountAll({
        where: {
          [Op.or]: [
            { player1_id: ladderUser.id },
            { player2_id: ladderUser.id }
          ],
          confirm_status: CONFIRM_STATUS.CONFIRMED
        },
        include: [
          { model: Match, as: 'match', attributes: ['id', 'name', 'type', 'weight'] }
        ],
        order: [['confirmed_at', 'DESC']],
        limit,
        offset
      });

      const list = await Promise.all(rows.map(async game => {
        const isPlayer1 = game.player1_id === ladderUser.id;
        const opponentId = isPlayer1 ? game.player2_id : game.player1_id;
        const opponent = await LadderUser.findByPk(opponentId);

        return {
          id: game.id,
          matchId: game.match_id,
          matchName: game.match?.name,
          matchType: game.match?.type,
          opponentName: opponent?.real_name,
          myScore: isPlayer1 ? game.player1_score : game.player2_score,
          opponentScore: isPlayer1 ? game.player2_score : game.player1_score,
          isWin: game.winner_id === ladderUser.id,
          powerChange: game.winner_id === ladderUser.id
            ? game.winner_power_change
            : game.loser_power_change,
          confirmedAt: game.confirmed_at
        };
      }));

      res.json(pageResult(list, count, page, pageSize));
    } catch (err) {
      console.error('获取比赛记录失败:', err);
      res.status(500).json(error('获取失败'));
    }
  }

  // 获取正在进行中的比赛
  async getOngoingMatches(req, res) {
    try {
      const { store_id } = req.query;
      const user = req.user;

      const ladderUser = await LadderUser.findOne({
        where: { user_id: user.id, store_id, status: 1 }
      });

      if (!ladderUser) {
        return res.json(success([]));
      }

      // 先获取用户参与的排位赛比赛ID
      const myMatchPlayers = await MatchPlayer.findAll({
        where: { ladder_user_id: ladderUser.id },
        attributes: ['match_id']
      });
      const rankingMatchIds = myMatchPlayers.map(mp => mp.match_id);

      // 查找用户参与的正在进行中的比赛
      const whereCondition = {
        store_id,
        status: { [Op.in]: [MATCH_STATUS.PENDING, MATCH_STATUS.ONGOING] },
        [Op.or]: [
          // 挑战赛：作为挑战者或被挑战者
          { challenger_id: ladderUser.id },
          { defender_id: ladderUser.id }
        ]
      };

      // 如果有排位赛参与记录，添加到查询条件
      if (rankingMatchIds.length > 0) {
        whereCondition[Op.or].push({ id: { [Op.in]: rankingMatchIds } });
      }

      const ongoingMatches = await Match.findAll({
        where: whereCondition,
        include: [
          { model: Store, as: 'store', attributes: ['id', 'name'] }
        ],
        order: [['created_at', 'DESC']]
      });

      const list = await Promise.all(ongoingMatches.map(async match => {
        let opponent = null;
        let myStatus = 'waiting';
        let currentGame = null;

        if (match.type === MATCH_TYPES.CHALLENGE) {
          // 挑战赛：获取对手信息
          const opponentId = match.challenger_id === ladderUser.id
            ? match.defender_id
            : match.challenger_id;
          const opponentLadder = await LadderUser.findByPk(opponentId, {
            include: [{ model: User, as: 'user', attributes: ['nickname', 'avatar'] }]
          });
          if (opponentLadder) {
            opponent = {
              id: opponentLadder.id,
              realName: opponentLadder.real_name,
              nickname: opponentLadder.user?.nickname,
              avatar: opponentLadder.user?.avatar,
              level: opponentLadder.level,
              powerScore: opponentLadder.power_score
            };
          }
          myStatus = match.status === MATCH_STATUS.PENDING ? 'waiting' : 'playing';
        } else {
          // 排位赛：获取参赛者状态和当前对局
          const player = await MatchPlayer.findOne({
            where: { match_id: match.id, ladder_user_id: ladderUser.id }
          });
          if (player) {
            myStatus = player.player_status;
            
            // 获取当前对局
            const game = await MatchGame.findOne({
              where: {
                match_id: match.id,
                [Op.or]: [
                  { player1_id: ladderUser.id },
                  { player2_id: ladderUser.id }
                ],
                status: { [Op.lt]: 2 }
              }
            });
            
            if (game) {
              const opponentId = game.player1_id === ladderUser.id
                ? game.player2_id
                : game.player1_id;
              const opponentLadder = await LadderUser.findByPk(opponentId, {
                include: [{ model: User, as: 'user', attributes: ['nickname', 'avatar'] }]
              });
              if (opponentLadder) {
                opponent = {
                  id: opponentLadder.id,
                  realName: opponentLadder.real_name,
                  nickname: opponentLadder.user?.nickname,
                  avatar: opponentLadder.user?.avatar,
                  level: opponentLadder.level,
                  powerScore: opponentLadder.power_score
                };
              }
              currentGame = {
                id: game.id,
                myScore: game.player1_id === ladderUser.id ? game.player1_score : game.player2_score,
                opponentScore: game.player1_id === ladderUser.id ? game.player2_score : game.player1_score,
                confirmStatus: game.confirm_status,
                gameStatus: game.status
              };
            }
          }
        }

        // 获取排位赛参赛人数
        let playerCount = 0;
        if (match.type === MATCH_TYPES.RANKING) {
          playerCount = await MatchPlayer.count({ where: { match_id: match.id } });
        }

        return {
          id: match.id,
          matchCode: match.match_code,
          type: match.type,
          typeName: match.type === MATCH_TYPES.CHALLENGE ? '挑战赛' : '排位赛',
          name: match.name,
          weight: match.weight,
          status: match.status,
          statusName: match.status === MATCH_STATUS.PENDING ? '待开始' : '进行中',
          stage: match.stage,
          stageName: match.type === MATCH_TYPES.RANKING ? 
            ['报名中', '循环赛', '淘汰赛', '已结束'][match.stage] : null,
          myStatus,
          opponent,
          currentGame,
          playerCount,
          startTime: match.start_time,
          createdAt: match.created_at
        };
      }));

      res.json(success(list));
    } catch (err) {
      console.error('获取进行中比赛失败:', err);
      res.status(500).json(error('获取失败'));
    }
  }

  // 获取待确认的比赛
  async getPendingConfirm(req, res) {
    try {
      const { store_id } = req.query;
      const user = req.user;

      const ladderUser = await LadderUser.findOne({
        where: { user_id: user.id, store_id, status: 1 }
      });

      if (!ladderUser) {
        return res.json(success([]));
      }

      // 查找需要我确认的比赛（我是败方）
      const pendingGames = await MatchGame.findAll({
        where: {
          loser_id: ladderUser.id,
          confirm_status: CONFIRM_STATUS.PENDING
        },
        include: [
          { model: Match, as: 'match' }
        ],
        order: [['created_at', 'DESC']]
      });

      const list = await Promise.all(pendingGames.map(async game => {
        const winner = await LadderUser.findByPk(game.winner_id);
        return {
          id: game.id,
          matchId: game.match_id,
          matchName: game.match?.name,
          matchType: game.match?.type,
          opponentName: winner?.real_name,
          myScore: game.player1_id === ladderUser.id ? game.player1_score : game.player2_score,
          opponentScore: game.player1_id === ladderUser.id ? game.player2_score : game.player1_score,
          createdAt: game.created_at
        };
      }));

      res.json(success(list));
    } catch (err) {
      console.error('获取待确认比赛失败:', err);
      res.status(500).json(error('获取失败'));
    }
  }

  // 获取比赛详情
  async getMatchDetail(req, res) {
    try {
      const { id } = req.params;
      const user = req.user;

      const match = await Match.findByPk(id, {
        include: [
          { model: MatchGame, as: 'games' },
          { model: Store, as: 'store' }
        ]
      });

      if (!match) {
        return res.status(404).json(error('比赛不存在', 404));
      }

      // 获取当前用户的天梯用户信息
      const myLadderUser = await LadderUser.findOne({
        where: { user_id: user.id, store_id: match.store_id, status: 1 },
        include: [{ model: User, as: 'user', attributes: ['nickname', 'avatar'] }]
      });

      // 调试日志
      console.log('获取比赛详情 - 用户信息:', {
        userId: user.id,
        storeId: match.store_id,
        myLadderUserId: myLadderUser?.id,
        matchChallengerId: match.challenger_id,
        matchDefenderId: match.defender_id,
        matchStatus: match.status
      });

      let challengerInfo = null;
      let defenderInfo = null;
      let myRole = null; // 'challenger' | 'defender' | null
      let canAccept = false;
      let canReject = false;
      let canSubmitScore = false;
      let canConfirmScore = false;

      if (match.type === MATCH_TYPES.CHALLENGE) {
        // 挑战赛：获取挑战者和被挑战者信息
        const challengerLadder = await LadderUser.findByPk(match.challenger_id, {
          include: [{ model: User, as: 'user', attributes: ['nickname', 'avatar'] }]
        });
        const defenderLadder = await LadderUser.findByPk(match.defender_id, {
          include: [{ model: User, as: 'user', attributes: ['nickname', 'avatar'] }]
        });

        if (challengerLadder) {
          challengerInfo = {
            id: challengerLadder.id,
            realName: challengerLadder.real_name,
            nickname: challengerLadder.user?.nickname,
            avatar: challengerLadder.user?.avatar,
            level: challengerLadder.level,
            powerScore: challengerLadder.power_score,
            userId: challengerLadder.user_id, // 添加 user_id，用于前端判断
            phone: challengerLadder.phone // 添加手机号，用于前端判断
          };
        }

        if (defenderLadder) {
          defenderInfo = {
            id: defenderLadder.id,
            realName: defenderLadder.real_name,
            nickname: defenderLadder.user?.nickname,
            avatar: defenderLadder.user?.avatar,
            level: defenderLadder.level,
            powerScore: defenderLadder.power_score,
            userId: defenderLadder.user_id, // 添加 user_id，用于前端判断
            phone: defenderLadder.phone // 添加手机号，用于前端判断
          };
        }

        // 确定当前用户角色
        // 方法1：通过 myLadderUser.id 比较（如果用户是该门店的天梯用户）
        if (myLadderUser) {
          // 使用 == 比较，因为可能是数字或字符串
          if (myLadderUser.id == match.challenger_id) {
            myRole = 'challenger';
            console.log('用户是挑战者（通过myLadderUser）:', { myLadderUserId: myLadderUser.id, challengerId: match.challenger_id });
          } else if (myLadderUser.id == match.defender_id) {
            myRole = 'defender';
            console.log('用户是被挑战者（通过myLadderUser）:', { myLadderUserId: myLadderUser.id, defenderId: match.defender_id });
          } else {
            console.log('用户角色不匹配（通过myLadderUser）:', {
              myLadderUserId: myLadderUser.id,
              challengerId: match.challenger_id,
              defenderId: match.defender_id
            });
          }
        }
        
        // 方法2：如果 myLadderUser 为 null，通过挑战者和被挑战者的 user_id 来判断
        if (!myRole && challengerLadder && defenderLadder) {
          // 检查挑战者的 user_id
          if (challengerLadder.user_id && challengerLadder.user_id == user.id) {
            myRole = 'challenger';
            console.log('用户是挑战者（通过user_id）:', { 
              userId: user.id, 
              challengerUserId: challengerLadder.user_id,
              challengerLadderId: challengerLadder.id,
              matchChallengerId: match.challenger_id
            });
          } 
          // 检查被挑战者的 user_id
          else if (defenderLadder.user_id && defenderLadder.user_id == user.id) {
            myRole = 'defender';
            console.log('用户是被挑战者（通过user_id）:', { 
              userId: user.id, 
              defenderUserId: defenderLadder.user_id,
              defenderLadderId: defenderLadder.id,
              matchDefenderId: match.defender_id
            });
          } else {
            console.log('用户角色不匹配（通过user_id）:', {
              userId: user.id,
              challengerUserId: challengerLadder.user_id,
              challengerLadderId: challengerLadder.id,
              defenderUserId: defenderLadder.user_id,
              defenderLadderId: defenderLadder.id,
              matchChallengerId: match.challenger_id,
              matchDefenderId: match.defender_id
            });
          }
        }
        
        // 方法3：如果前两种方法都失败，尝试通过手机号匹配（如果天梯用户有手机号且用户有手机号）
        if (!myRole && challengerLadder && defenderLadder && user.phone) {
          if (challengerLadder.phone && challengerLadder.phone === user.phone) {
            myRole = 'challenger';
            console.log('用户是挑战者（通过手机号）:', { userPhone: user.phone, challengerPhone: challengerLadder.phone });
          } else if (defenderLadder.phone && defenderLadder.phone === user.phone) {
            myRole = 'defender';
            console.log('用户是被挑战者（通过手机号）:', { userPhone: user.phone, defenderPhone: defenderLadder.phone });
          }
        }
        
        if (!myRole) {
          console.log('无法确定用户角色:', {
            userId: user.id,
            userPhone: user.phone,
            storeId: match.store_id,
            hasMyLadderUser: !!myLadderUser,
            myLadderUserId: myLadderUser?.id,
            challengerLadderId: challengerLadder?.id,
            challengerUserId: challengerLadder?.user_id,
            challengerPhone: challengerLadder?.phone,
            defenderLadderId: defenderLadder?.id,
            defenderUserId: defenderLadder?.user_id,
            defenderPhone: defenderLadder?.phone,
            matchChallengerId: match.challenger_id,
            matchDefenderId: match.defender_id
          });
        }

        // 判断操作权限
        // 待接受状态且是被挑战者，可以接受或拒绝
        if (match.status === MATCH_STATUS.PENDING) {
          if (myRole === 'defender') {
            canAccept = true;
            canReject = true;
            console.log('设置接受/拒绝权限为true:', { myRole, status: match.status, canAccept, canReject });
          } else {
            console.log('不能接受/拒绝:', { myRole, status: match.status, isDefender: myRole === 'defender' });
          }
        } else {
          console.log('比赛状态不是待接受:', { status: match.status, myRole });
        }

        if (match.status === MATCH_STATUS.ONGOING && myLadderUser) {
          const game = match.games?.[0];
          if (game) {
            // 检查是否可以提交比分（必须是胜者且未提交）
            if (game.status === 1 && !game.submit_by) {
              // 比赛进行中，还未提交比分，双方都可以填写
              canSubmitScore = true;
            } else if (game.status === 2 && game.submit_by && game.submit_by !== myLadderUser.id) {
              // 对方已提交比分，等待我确认
              if (game.confirm_status === CONFIRM_STATUS.PENDING) {
                canConfirmScore = true;
              }
            }
          }
        }
      }

      const result = {
        id: match.id,
        matchCode: match.match_code,
        type: match.type,
        name: match.name,
        weight: match.weight,
        status: match.status,
        stage: match.stage,
        storeName: match.store?.name,
        startTime: match.start_time,
        endTime: match.end_time,
        challenger: challengerInfo,
        defender: defenderInfo,
        myRole: myRole || null,
        canAccept: Boolean(canAccept),
        canReject: Boolean(canReject),
        canSubmitScore: Boolean(canSubmitScore),
        canConfirmScore: Boolean(canConfirmScore),
        games: match.games?.map(game => ({
          id: game.id,
          player1Id: game.player1_id,
          player2Id: game.player2_id,
          player1Score: game.player1_score,
          player2Score: game.player2_score,
          winnerId: game.winner_id,
          loserId: game.loser_id,
          submitBy: game.submit_by,
          confirmStatus: game.confirm_status,
          status: game.status
        })) || []
      };

      // 调试日志
      console.log('比赛详情返回数据:', {
        matchId: match.id,
        matchStatus: match.status,
        storeId: match.store_id,
        userId: user.id,
        myLadderUserId: myLadderUser?.id,
        myLadderUserType: typeof myLadderUser?.id,
        challengerId: match.challenger_id,
        challengerIdType: typeof match.challenger_id,
        defenderId: match.defender_id,
        defenderIdType: typeof match.defender_id,
        myRole,
        canAccept: result.canAccept,
        canReject: result.canReject,
        hasMyLadderUser: !!myLadderUser,
        challengerMatch: myLadderUser ? (myLadderUser.id == match.challenger_id) : false,
        defenderMatch: myLadderUser ? (myLadderUser.id == match.defender_id) : false
      });

      // 确保返回所有必要的字段
      res.json(success(result));
    } catch (err) {
      console.error('获取比赛详情失败:', err);
      res.status(500).json(error('获取失败'));
    }
  }
}

module.exports = new MatchController();