import 'dart:async';
import 'dart:developer';
import 'package:flutter/material.dart';
import 'package:sudoku_app/models/game_level.dart'; // 👈 [추가] 레벨 모델 임포트
import 'package:sudoku_app/models/sudoku_game_dto.dart';
import 'package:sudoku_app/models/sudoku_theme.dart';
import 'package:sudoku_app/models/unified_rank_dto.dart';
import 'package:sudoku_app/services/puzzle_service.dart';
import 'package:sudoku_app/services/identity_service.dart';
import 'package:sudoku_app/widgets/ad_banner_widget.dart';
import 'package:sudoku_app/widgets/number_pad.dart';
import 'package:sudoku_app/widgets/sudoku_board.dart';
import 'package:sudoku_app/models/game_rank_dto.dart';

// 랭킹 팝업의 2단계 UI 상태를 관리하기 위한 enum
enum _RankSubmissionStep { enterName, submitting, showList }

class GameScreen extends StatefulWidget {
  final SudokuGameDto gameData;
  final String themeName;
  final String userId;
  final String? userName;
  final int levelIndex; // 👈 HomeScreen에서 전달받은 현재 레벨

  const GameScreen({
    super.key,
    required this.gameData,
    required this.themeName,
    required this.userId,
    required this.userName,
    required this.levelIndex,
  });

  @override
  State<GameScreen> createState() => _GameScreenState();
}

class _GameScreenState extends State<GameScreen> {
  final PuzzleService _puzzleService = PuzzleService();
  final IdentityService _identityService = IdentityService();
  
  late final GameLevel currentLevel; // 👈 현재 레벨 정보
  late final int blockSize;
  late final int gridSize;
  late final SudokuTheme activeTheme; // 👈 이번 게임의 '동적' 테마

  // 모든 내부 로직은 'int'로 관리
  late List<int> puzzleCells;
  late List<int> solutionCells;
  late List<int> originalCells;

  int? selectedIndex;
  int score = 5;
  int secondsElapsed = 0;
  Timer? timer;
  int? selectedNumberPad;
  Set<int> incorrectCells = {};
  bool isValidating = false;

  _RankSubmissionStep _rankStep = _RankSubmissionStep.enterName;
  List<GameRankDto> _rankingList = [];
  String _submittedPlayerName = "";


  // "A" -> 10 (파싱용)
  int _charToInt(String char) {
    if (char == '0') return 0;
    if (char.codeUnitAt(0) >= '1'.codeUnitAt(0) && char.codeUnitAt(0) <= '9'.codeUnitAt(0)) {
      return int.parse(char);
    }
    if (char.codeUnitAt(0) >= 'A'.codeUnitAt(0) && char.codeUnitAt(0) <= 'Z'.codeUnitAt(0)) {
      return char.codeUnitAt(0) - 'A'.codeUnitAt(0) + 10;
    }
    return -1;
  }
  
  // 10 -> "A" (전송용)
  String _intToChar(int num) {
    if (num == 0) return '0';
    if (num >= 1 && num <= 9) return num.toString();
    if (num >= 10 && num <= 35) return String.fromCharCode('A'.codeUnitAt(0) + (num - 10));
    return '?';
  }

  @override
  void initState() {
    super.initState();
    // 1. HomeScreen에서 받은 levelIndex로 현재 레벨 정보 로드
    currentLevel = AppLevels.getLevel(widget.levelIndex);
    blockSize = currentLevel.blockSize;
    gridSize = blockSize * blockSize;
    
    // 2. 🔽 [수정] 테마 정책 적용
    String themeForThisGame = widget.themeName;
    
    // 🔽 [수정] 'isEasyMode' 변수를 'GameLevel'의 속성들로 조합
    bool isEasyMode = currentLevel.isSequentialNumbers || currentLevel.isSequentialLetters;

    if (currentLevel.isSequentialNumbers) {
      themeForThisGame = AppThemes.numbers; // 👈 숫자 테마 강제
    } else if (currentLevel.isSequentialLetters) {
      themeForThisGame = AppThemes.letters; // 👈 알파벳 테마 강제
    }

    // 3. '이번 게임'의 테마 객체 생성
    activeTheme = AppThemes.buildGameTheme(
      themeForThisGame, 
      gridSize,
      isEasyMode: isEasyMode, // 👈 [수정] 조합된 bool 값 전달
    );

    // 4. 서버 데이터(String)를 내부 로직(int)으로 변환
    puzzleCells = widget.gameData.question.split('').map(_charToInt).toList();
    solutionCells = widget.gameData.solution.split('').map(_charToInt).toList();
    originalCells = widget.gameData.question.split('').map(_charToInt).toList();
    
    startTimer();
  }

  @override
  void dispose() {
    timer?.cancel();
    super.dispose();
  }

  void startTimer() {
    timer = Timer.periodic(const Duration(seconds: 1), (timer) {
      setState(() {
        secondsElapsed++;
      });
    });
  }

  void onCellTapped(int index) {
    if (originalCells[index] == 0) {
      
      if (incorrectCells.isNotEmpty && !incorrectCells.contains(index)) {
        ScaffoldMessenger.of(context).showSnackBar(
          const SnackBar(
            content: Text('틀린 값을 먼저 수정해주세요. (되돌리기 ↩)'),
            duration: Duration(seconds: 1),
          ),
        );
        return;
      }
      
      setState(() {
        selectedIndex = index;
        
        if (selectedNumberPad != null) {
          final int numberValue = selectedNumberPad!;
          puzzleCells[index] = numberValue;

          if (numberValue != solutionCells[index]) {
            if (!incorrectCells.contains(index)) {
              if (score > 0) {
                score--; 
              }
              incorrectCells.add(index);
            }
          } else {
            incorrectCells.remove(index);
          }
          
          _checkIfBoardIsFull();
        }
      });
    }
  }

  void _checkIfBoardIsFull() {
    if (!puzzleCells.contains(0) && !isValidating) {
      _validateGame();
    }
  }

  void onNumberTapped(int numberValue) {
    setState(() {
      if (selectedNumberPad == numberValue) {
        selectedNumberPad = null;
      } else {
        selectedNumberPad = numberValue;
      }
    });
  }

  void onUndoTapped() {
    if (incorrectCells.isNotEmpty) {
      int errorIndex = incorrectCells.first;
      setState(() {
        puzzleCells[errorIndex] = 0;
        incorrectCells.remove(errorIndex);
        selectedIndex = errorIndex;
      });
    } 
    else if (selectedIndex != null && originalCells[selectedIndex!] == 0) {
      setState(() {
        puzzleCells[selectedIndex!] = 0;
      });
    }
  }

  void onHintTapped() {
    ScaffoldMessenger.of(context).showSnackBar(
      const SnackBar(content: Text('힌트 기능은 준비 중입니다.')),
    );
  }

  void _onRestartGameTapped() {
    setState(() {
      puzzleCells = originalCells.toList();
      incorrectCells.clear();
      selectedIndex = null;
      selectedNumberPad = null;
      score = 5;
      
      timer?.cancel();
      secondsElapsed = 0;
      startTimer();
    });
  }

  void _onQuitGameTapped() {
    Navigator.of(context).pop();
  }


  // 정답 확인 API 호출
  Future<void> _validateGame() async {
    if (isValidating) return;
    setState(() { isValidating = true; });
    
    timer?.cancel();
    String currentAnswer = puzzleCells.map(_intToChar).join('');
    
    try {
      final bool result = await _puzzleService.validateSolution(
        widget.gameData.puzzleId, 
        currentAnswer,
      );

      if (result) {
        if(mounted) _showRankingDialog();
      } else {
        if(mounted) {
          ScaffoldMessenger.of(context).showSnackBar(
            const SnackBar(content: Text('🤔 틀린 부분이 있습니다.')),
          );
        }
        startTimer();
      }
    } catch (e) {
      if(mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text('오류: $e')),
        );
      }
      startTimer();
    } finally {
      if(mounted) {
        setState(() { isValidating = false; });
      }
    }
  }

  // 랭킹 등록 팝업 (2단계 UI + 레벨 잠금 해제)
  void _showRankingDialog() {
    final nameController = TextEditingController(text: widget.userName);
    bool isSubmitting = false;
    String? dialogErrorMessage;
    
    _rankStep = _RankSubmissionStep.enterName;
    _rankingList = [];
    _submittedPlayerName = "";
    
    final String contextId = currentLevel.contextId;

    showDialog(
      context: context,
      barrierDismissible: false,
      builder: (ctx) {
        return StatefulBuilder(
          builder: (context, setDialogState) {
            
            Widget closeButton = TextButton(
              onPressed: () {
                Navigator.of(ctx).pop();
                Navigator.of(context).pop();
              },
              child: const Text('닫기'),
            );
            
            Widget rankListWidget = Expanded(
              child: _rankingList.isEmpty
                  ? const Center(child: Text("현재 랭킹이 없습니다."))
                  : ListView.builder(
                      itemCount: _rankingList.length,
                      shrinkWrap: true,
                      itemBuilder: (context, index) {
                        final rank = _rankingList[index];
                        final bool isMe = rank.playerName == _submittedPlayerName;
                        int displayScore = 5 - (rank.secondaryScore ?? 5);
                        
                        final min = (rank.primaryScore ~/ 60).toString().padLeft(2, '0');
                        final sec = (rank.primaryScore % 60).toString().padLeft(2, '0');
                        final time = '$min:$sec';
                        
                        return ListTile(
                          selected: isMe,
                          selectedTileColor: Colors.blue.shade100,
                          leading: Text('${index + 1}.', style: const TextStyle(fontWeight: FontWeight.bold)),
                          title: Text(rank.playerName, style: TextStyle(fontWeight: isMe ? FontWeight.bold : FontWeight.normal)),
                          trailing: Text('$time (Score: $displayScore)', style: const TextStyle(fontWeight: FontWeight.bold, color: Colors.black87)),
                        );
                      },
                    ),
            );

            Widget nameEntryWidget = Column(
              mainAxisSize: MainAxisSize.min,
              children: [
                Text('완료 시간: $secondsElapsed 초 / 남은 점수: $score 점'),
                const SizedBox(height: 20),
                TextField(
                  controller: nameController,
                  readOnly: false,
                  decoration: InputDecoration(
                    labelText: '이름 (10자 이내)',
                    border: const OutlineInputBorder(),
                    errorText: dialogErrorMessage,
                  ),
                  maxLength: 10,
                ),
              ],
            );
            
            Widget submitButton = ElevatedButton(
              onPressed: () async {
                final playerName = nameController.text.trim();
                if (playerName.isEmpty) {
                  setDialogState(() {
                    dialogErrorMessage = "이름을 입력해주세요.";
                  });
                  return;
                }
                
                setDialogState(() {
                  _rankStep = _RankSubmissionStep.submitting;
                  _submittedPlayerName = playerName;
                  dialogErrorMessage = null;
                });

                final rankDto = UnifiedRankDto(
                  userId: widget.userId,
                  gameType: 'SUDOKU',
                  contextId: contextId,
                  playerName: playerName,
                  primaryScore: secondsElapsed,
                  secondaryScore: (5 - score),
                );

                try {
                  await _puzzleService.submitRank(rankDto);
                  await _identityService.saveUserName(playerName);

                  final int currentMaxLevel = await _identityService.getMaxUnlockedLevel();
                  if (currentMaxLevel < 99) {
                    if (widget.levelIndex >= currentMaxLevel) {
                      int nextLevel = widget.levelIndex + 1;
                      if (nextLevel > AppLevels.allLevels.length) {
                        await _identityService.saveMaxUnlockedLevel(99);
                      } else {
                        await _identityService.saveMaxUnlockedLevel(nextLevel);
                      }
                    }
                  }
                  
                  final ranks = await _puzzleService.fetchRanks('SUDOKU', contextId);
                  
                  setDialogState(() {
                    _rankingList = ranks;
                    _rankStep = _RankSubmissionStep.showList;
                  });

                } catch (e) {
                  log("!!! 랭킹 등록 실패 !!!", error: e);
                  setDialogState(() {
                    _rankStep = _RankSubmissionStep.enterName;
                    dialogErrorMessage = e.toString().replaceFirst("Exception: ", "");
                  });
                }
              },
              child: const Text('랭킹 등록'),
            );
            
            Widget dialogContent;
            if (_rankStep == _RankSubmissionStep.showList) {
              dialogContent = rankListWidget;
            } else {
              dialogContent = nameEntryWidget;
            }
            
            List<Widget> dialogActions;
            if (_rankStep == _RankSubmissionStep.enterName) {
              dialogActions = [
                TextButton(
                  onPressed: () {
                    Navigator.of(ctx).pop();
                    Navigator.of(context).pop();
                  },
                  child: const Text('닫기'),
                ),
                submitButton
              ];
            } else if (_rankStep == _RankSubmissionStep.submitting) {
              dialogActions = [const CircularProgressIndicator()];
            } else { 
              dialogActions = [closeButton];
            }

            return AlertDialog(
              title: Text(_rankStep == _RankSubmissionStep.showList
                  ? '🏆 상위 10개 랭킹 ($contextId)'
                  : '🎉 성공! 기록을 남겨주세요.'),
              content: SizedBox(
                width: 400,
                height: _rankStep == _RankSubmissionStep.showList ? 400 : null,
                child: dialogContent,
              ),
              actions: dialogActions,
            );
          },
        );
      },
    );
  }
  
  // 랭킹 ID 생성을 위해, 원본 문제의 빈칸 비율로 레벨(1~5)을 역산
  int _difficultyLevel(String question) {
    int holes = question.split('').where((c) => c == '0').length;
    double holeRatio = holes / (gridSize * gridSize);
    if (holeRatio <= 0.51) return 1;
    if (holeRatio <= 0.58) return 2;
    if (holeRatio <= 0.63) return 3;
    if (holeRatio <= 0.68) return 4;
    return 5;
  }

  @override
  Widget build(BuildContext context) {
    String formattedTime =
        '${(secondsElapsed ~/ 60).toString().padLeft(2, '0')}:${(secondsElapsed % 60).toString().padLeft(2, '0')}';

    final Map<int, int> numberCounts = {};
    for (int i = 1; i <= gridSize; i++) { numberCounts[i] = 0; }
    for (int cellValue in puzzleCells) {
      if (cellValue > 0) {
        numberCounts[cellValue] = (numberCounts[cellValue] ?? 0) + 1;
      }
    }

    return Scaffold(
      body: SafeArea(
        child: Column(
          children: [
            Expanded(
              child: LayoutBuilder(
                builder: (context, constraints) {
                  bool isLandscape = constraints.maxWidth > constraints.maxHeight;
                  if (isLandscape) {
                    return _buildLandscapeLayout(context, numberCounts, constraints, formattedTime);
                  } else {
                    return _buildPortraitLayout(context, numberCounts, constraints, formattedTime);
                  }
                },
              ),
            ),
            const AdBannerWidget(),
          ],
        ),
      ),
    );
  }

  Widget _buildPortraitLayout(BuildContext context, Map<int, int> numberCounts, BoxConstraints constraints, String formattedTime) {
    final double boardWidth = (constraints.maxWidth > 600) ? 600 : constraints.maxWidth;
    
    return Center(
      child: ConstrainedBox(
        constraints: BoxConstraints(maxWidth: boardWidth),
        child: Column(
          children: [
            Padding(
              padding: const EdgeInsets.fromLTRB(16.0, 16.0, 16.0, 0),
              child: _buildGameInfoWidget(formattedTime),
            ),
            Expanded(
              child: Center(
                child: SingleChildScrollView(
                  child: Padding(
                    padding: const EdgeInsets.all(16.0),
                    child: Column(
                      mainAxisAlignment: MainAxisAlignment.center,
                      children: [
                        _buildSudokuBoardWidget(),
                        const SizedBox(height: 15),
                        _buildNumberPadWidget(context, numberCounts, isLandscape: false, boardWidth: boardWidth), 
                      ],
                    ),
                  ),
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }

  Widget _buildLandscapeLayout(BuildContext context, Map<int, int> numberCounts, BoxConstraints constraints, String formattedTime) {
    
    const double infoBarHeight = 60.0;
    double boardWidth = constraints.maxHeight - infoBarHeight - 32.0; 
    
    const double numberPadScaleRatio = 0.6;
    double padWidth = boardWidth * numberPadScaleRatio;

    if (padWidth < 200) padWidth = 200;
    if (padWidth > 350) padWidth = 350;

    double totalWidth = boardWidth + (padWidth + 100) + 16.0; 
    if (totalWidth > (constraints.maxWidth - 32.0)) {
      double scale = (constraints.maxWidth - 32.0) / totalWidth;
      boardWidth *= scale;
      padWidth *= scale;
    }

    return Padding(
      padding: const EdgeInsets.all(16.0),
      child: Column(
        children: [
          _buildGameInfoWidget(formattedTime),
          Expanded(
            child: Row(
              crossAxisAlignment: CrossAxisAlignment.center,
              mainAxisAlignment: MainAxisAlignment.center,
              children: [
                SizedBox(
                  width: boardWidth,
                  child: _buildSudokuBoardWidget(),
                ),
                const SizedBox(width: 16),
                SizedBox(
                  width: padWidth + 100,
                  child: SingleChildScrollView(
                    child: Column(
                      children: [
                        _buildNumberPadWidget(context, numberCounts, isLandscape: true, boardWidth: boardWidth),
                      ],
                    ),
                  ),
                ),
              ],
            ),
          ),
        ],
      ),
    );
  }

  Widget _buildGameInfoWidget(String formattedTime) {
    return Row(
      mainAxisAlignment: MainAxisAlignment.spaceBetween,
      crossAxisAlignment: CrossAxisAlignment.center,
      children: [
        Text('SCORE: $score', style: const TextStyle(fontSize: 20, fontWeight: FontWeight.bold)),
        Text(formattedTime, style: const TextStyle(fontSize: 20, fontWeight: FontWeight.bold)),
        Row(
          mainAxisSize: MainAxisSize.min,
          children: [
            IconButton(
              onPressed: onHintTapped,
              icon: const Icon(Icons.lightbulb_outline, color: Colors.orange),
              iconSize: 30,
            ),
            IconButton(
              onPressed: onUndoTapped,
              icon: const Icon(Icons.undo, color: Colors.red),
              iconSize: 30,
            ),
          ],
        )
      ],
    );
  }

  Widget _buildSudokuBoardWidget() {
    return SudokuBoard(
      blockSize: blockSize,
      theme: activeTheme,
      cells: puzzleCells,
      originalCells: originalCells,
      selectedIndex: selectedIndex,
      selectedNumberPad: selectedNumberPad,
      incorrectCells: incorrectCells,
      onCellTapped: onCellTapped,
    );
  }

  Widget _buildNumberPadWidget(BuildContext context, Map<int, int> numberCounts, {required bool isLandscape, required double boardWidth}) {
    const double numberPadScaleRatio = 0.6;
    double? padMaxWidth;
    
    if (!isLandscape) {
        padMaxWidth = boardWidth * numberPadScaleRatio;
    } else {
        padMaxWidth = null; 
    }

    Widget numberPadGrid = ConstrainedBox(
      constraints: BoxConstraints(maxWidth: padMaxWidth ?? double.infinity),
      child: NumberPad(
        blockSize: blockSize,
        theme: activeTheme,
        numberCounts: numberCounts,
        selectedNumber: selectedNumberPad, 
        onNumberTapped: onNumberTapped,
        isLandscape: isLandscape,
      ),
    );

    Widget quitButton = IconButton(
      icon: Icon(Icons.close, color: Colors.red.shade700, size: 30),
      onPressed: _onQuitGameTapped,
      tooltip: "게임 종료",
    );

    Widget restartButton = IconButton(
      icon: Icon(Icons.refresh, color: Colors.blue.shade700, size: 30),
      onPressed: _onRestartGameTapped,
      tooltip: "다시하기",
    );

    if (isLandscape) {
      return Column(
        mainAxisSize: MainAxisSize.min,
        children: [
          numberPadGrid,
          const SizedBox(height: 10),
          Row(
            mainAxisAlignment: MainAxisAlignment.spaceEvenly,
            children: [quitButton, restartButton],
          )
        ],
      );
    } else {
      return Row(
        mainAxisAlignment: MainAxisAlignment.center,
        crossAxisAlignment: CrossAxisAlignment.center,
        children: [
          quitButton,
          Expanded(child: numberPadGrid),
          restartButton,
        ],
      );
    }
  }
}