import 'dart:math' as math;

import 'package:flame/components.dart';
import 'package:flame/game.dart';
import 'package:flutter/material.dart';

import '../audio/audio_manager.dart';
import '../game/game_controller.dart';
import '../game/levels.dart';
import '../game/music.dart';
import '../game/types.dart';
import 'memory_card_component.dart';

class MemoryMatchFlameGame extends FlameGame {
  MemoryMatchFlameGame({
    required this.level,
    required this.onStateChanged,
    required this.onResult,
  });

  LevelConfig level;
  final VoidCallback onStateChanged;
  final void Function(GameStatus status, int score) onResult;

  late GameController controller;

  bool _ready = false;
  bool get isReady => _ready;

  final Map<String, MemoryCardComponent> _cardViews = {};
  double _countdownAccumulator = 0;

  late final SpriteComponent _background;
  late final PositionComponent _boardRoot;

  bool pausedByUser = false;
  bool showResult = false;
  bool mutedMusic = false;
  bool mutedSfx = false;
  int timeLeft = 0;
  int bestScore = 0;
  String resultStatus = 'lost';
  int finalScore = 0;
  bool _boardEntryAnimating = false;
  int _boardEntryToken = 0;
  final math.Random _entryRandom = math.Random();

  int _lastMismatchToken = 0;
  int _lastStreak = 0;
  GameStatus _lastStatus = GameStatus.playing;

  String get timeText {
    final m = (timeLeft ~/ 60).toString().padLeft(2, '0');
    final s = (timeLeft % 60).toString().padLeft(2, '0');
    return '$m:$s';
  }

  @override
  Color backgroundColor() => const Color(0x00000000);

  @override
  Future<void> onLoad() async {
    await super.onLoad();

    _background = SpriteComponent(
      sprite: await loadSprite('a5c6f3813d0d23b4042dd130542753cc.png'),
      size: size,
      position: Vector2.zero(),
      priority: -100,
    );
    add(_background);

    _boardRoot = PositionComponent(anchor: Anchor.topLeft);
    add(_boardRoot);

    controller = GameController(level: level, allFaceIds: allFaceIds)
      ..addListener(_onGameChanged);

    timeLeft = level.timeSec ?? 120;
    _lastStatus = controller.status;
    _lastMismatchToken = controller.mismatch.token;
    _lastStreak = controller.streak;

    _ready = true;

    await AudioManager.instance.playBgm();

    _syncBoard(rebuildAll: true, animateEntry: true);
    _startTicker();
  }

  @override
  void onGameResize(Vector2 canvasSize) {
    super.onGameResize(canvasSize);

    if (!isLoaded) return;

    _background.size = canvasSize;
    _layoutBoard();
  }

  @override
  void update(double dt) {
    super.update(dt);

    if (!_ready) return;
    if (showResult || pausedByUser || controller.status != GameStatus.playing) {
      return;
    }
    if (timeLeft <= 0) return;

    _countdownAccumulator += dt;

    while (_countdownAccumulator >= 1.0) {
      _countdownAccumulator -= 1.0;

      if (showResult ||
          pausedByUser ||
          controller.status != GameStatus.playing) {
        return;
      }
      if (timeLeft <= 0) return;

      timeLeft -= 1;
      onStateChanged();

      if (timeLeft == 0 &&
          !showResult &&
          controller.status == GameStatus.playing) {
        _finishAsLose();
        return;
      }
    }
  }

  void _startTicker() {
    _countdownAccumulator = 0;
  }

  Future<void> onCardTapped(String cardId) async {
    if (!_ready) return;
    if (showResult ||
        pausedByUser ||
        _boardEntryAnimating ||
        controller.status != GameStatus.playing) {
      return;
    }

    await AudioManager.instance.playSfx(SfxKey.click);
    controller.flip(cardId);
  }

  Future<void> _onGameChanged() async {
    if (!_ready) return;

    if (controller.mismatch.token > _lastMismatchToken) {
      _lastMismatchToken = controller.mismatch.token;
      await AudioManager.instance.playSfx(SfxKey.mismatch);
    }

    if (controller.streak > _lastStreak) {
      _lastStreak = controller.streak;
      await AudioManager.instance.playSfx(SfxKey.match);
    }
    if (controller.streak == 0) {
      _lastStreak = 0;
    }

    if (controller.status != _lastStatus) {
      _lastStatus = controller.status;
      if (controller.status == GameStatus.won) {
        await AudioManager.instance.playSfx(SfxKey.win);
      } else if (controller.status == GameStatus.lost) {
        await AudioManager.instance.playSfx(SfxKey.lose);
      }
    }

    if (!showResult &&
        !pausedByUser &&
        controller.status == GameStatus.playing &&
        level.maxMistakes != null &&
        controller.mistakes >= level.maxMistakes!) {
      _finishAsLose();
    }

    if (!showResult && controller.status == GameStatus.won) {
      final score = controller.score + timeLeft * 10;
      resultStatus = 'won';
      finalScore = score;
      bestScore = math.max(bestScore, score);
      showResult = true;
      paused = true;
      onResult(GameStatus.won, score);
    }

    _syncBoard();
    onStateChanged();
  }

  void _finishAsLose() {
    resultStatus = 'lost';
    finalScore = controller.score;
    bestScore = math.max(bestScore, controller.score);
    showResult = true;
    paused = true;
    onResult(GameStatus.lost, finalScore);
  }

  void _syncBoard({bool rebuildAll = false, bool animateEntry = false}) {
    if (!_ready) return;

    if (rebuildAll && animateEntry) {
      _boardEntryAnimating = true;
    }

    final disablePlay =
        showResult ||
        controller.status != GameStatus.playing ||
        pausedByUser ||
        _boardEntryAnimating;

    if (rebuildAll) {
      _boardRoot.removeAll(_boardRoot.children.toList());
      _cardViews.clear();

      for (final card in controller.cards) {
        final component = MemoryCardComponent(
          model: card,
          frontAsset: 'faces/b1c14934b04bf12e674abfffcb87cf6e.png',
          backAsset: faceMap[card.faceId]!,
          disabled: disablePlay || card.isMatched,
        );
        _cardViews[card.id] = component;
        _boardRoot.add(component);
      }

      _layoutBoard(animateEntry: animateEntry);
      return;
    }

    for (final card in controller.cards) {
      _cardViews[card.id]?.updateFromModel(
        card,
        disablePlay: disablePlay,
        shouldShake: controller.mismatch.ids.contains(card.id),
        shakeToken: controller.mismatch.token,
      );
    }
  }

  void _layoutBoard({bool animateEntry = false}) {
    if (_cardViews.isEmpty || size.x <= 0 || size.y <= 0) return;

    final topReserve = size.y * 0.30;
    final bottomReserve = size.y * 0.18;
    final horizontalPadding = 18.0;

    final rows = level.rowPattern.length;
    final widest = level.rowPattern.reduce((a, b) => a > b ? a : b);

    final isTabletWide = size.x >= 768;
    final gap = isTabletWide ? 10.0 : 12.0;

    final usableWidth = size.x - horizontalPadding * 2;
    final usableHeight = size.y - topReserve - bottomReserve;

    final cellByWidth = (usableWidth - gap * (widest - 1)) / widest;
    final cellByHeight = (usableHeight - gap * (rows - 1)) / rows;

    final cell = math
        .min(cellByWidth, cellByHeight)
        .clamp(38.0, isTabletWide ? 120.0 : 110.0);

    final gridWidth = widest * cell + (widest - 1) * gap;
    final gridHeight = rows * cell + (rows - 1) * gap;

    final boardLeft = (size.x - gridWidth) / 2;
    final boardTop = topReserve + (usableHeight - gridHeight) / 2;

    _boardRoot.position = Vector2(boardLeft, boardTop);
    _boardRoot.size = Vector2(gridWidth, gridHeight);

    int cardIndex = 0;
    final cardLayouts = <({
      MemoryCardComponent view,
      Vector2 target,
      Vector2 start,
      int row,
      int indexInRow,
    })>[];

    for (int row = 0; row < rows; row++) {
      final count = level.rowPattern[row];
      final rowWidth = count * cell + (count - 1) * gap;

      final startX = (gridWidth - rowWidth) / 2;
      final y = row * (cell + gap);

      for (int i = 0; i < count; i++) {
        final card = controller.cards[cardIndex++];
        final view = _cardViews[card.id]!;
        final target = Vector2(startX + i * (cell + gap), y);

        view.updateCardSize(Vector2.all(cell));
        cardLayouts.add((
          view: view,
          target: target,
          start: _randomEntryStartPosition(target, gridWidth, gridHeight, cell),
          row: row,
          indexInRow: i,
        ));
      }
    }

    if (animateEntry) {
      _playBoardEntryAnimation(cardLayouts);
      return;
    }

    for (final layout in cardLayouts) {
      layout.view.position = layout.target;
      layout.view.resetEntranceVisual();
    }
  }

  void _playBoardEntryAnimation(
    List<
      ({
        MemoryCardComponent view,
        Vector2 target,
        Vector2 start,
        int row,
        int indexInRow,
      })
    > cardLayouts,
  ) {
    _boardEntryToken += 1;
    final token = _boardEntryToken;

    const rowDelayStep = 0.12;
    const itemDelayStep = 0.035;
    const duration = 0.42;

    for (final layout in cardLayouts) {
      layout.view.playEntranceEffect(
        startPosition: layout.start,
        targetPosition: layout.target,
        delay: layout.row * rowDelayStep + layout.indexInRow * itemDelayStep,
      );
    }

    onStateChanged();

    final totalSeconds =
        (level.rowPattern.length - 1) * rowDelayStep +
        (widestRowCount() - 1) * itemDelayStep +
        duration +
        0.04;
    Future.delayed(
      Duration(milliseconds: (totalSeconds * 1000).round()),
      () {
        if (!_ready || token != _boardEntryToken) return;
        _boardEntryAnimating = false;
        _syncBoard();
        onStateChanged();
      }
    );
  }

  int widestRowCount() {
    return level.rowPattern.reduce((a, b) => a > b ? a : b);
  }

  Vector2 _randomEntryStartPosition(
    Vector2 target,
    double gridWidth,
    double gridHeight,
    double cell,
  ) {
    final side = _entryRandom.nextInt(4);
    final extraX = cell * (1.2 + _entryRandom.nextDouble() * 1.8);
    final extraY = cell * (1.0 + _entryRandom.nextDouble() * 2.2);

    switch (side) {
      case 0:
        return Vector2(
          -extraX,
          target.y - extraY - _entryRandom.nextDouble() * cell,
        );
      case 1:
        return Vector2(
          gridWidth + extraX,
          target.y - extraY - _entryRandom.nextDouble() * cell,
        );
      case 2:
        return Vector2(
          target.x + (_entryRandom.nextDouble() - 0.5) * cell * 1.8,
          -extraY,
        );
      default:
        return Vector2(
          target.x + (_entryRandom.nextDouble() - 0.5) * cell * 1.6,
          gridHeight + extraY,
        );
    }
  }

  Future<void> restartSameLevel() async {
    if (!_ready) return;

    showResult = false;
    paused = false;
    pausedByUser = false;
    timeLeft = level.timeSec ?? 120;
    _countdownAccumulator = 0;

    controller.reset();
    _lastStatus = controller.status;
    _lastMismatchToken = controller.mismatch.token;
    _lastStreak = controller.streak;

    _syncBoard(rebuildAll: true, animateEntry: true);
    _startTicker();
    onStateChanged();
  }

  Future<void> nextLevel(LevelConfig next) async {
    if (!_ready) return;

    level = next;
    showResult = false;
    paused = false;
    pausedByUser = false;
    _countdownAccumulator = 0;

    controller.removeListener(_onGameChanged);
    controller.dispose();

    controller = GameController(level: level, allFaceIds: allFaceIds)
      ..addListener(_onGameChanged);

    timeLeft = level.timeSec ?? 120;
    _lastStatus = controller.status;
    _lastMismatchToken = controller.mismatch.token;
    _lastStreak = controller.streak;

    _syncBoard(rebuildAll: true, animateEntry: true);
    _startTicker();
    onStateChanged();
  }

  Future<int> reviveWithReward() async {
    if (!_ready) return 0;

    final sec = controller.reviveWithReward(
      baseSeconds: 30,
      penaltyPerMove: 10,
      rollbackMistakes: controller.mistakes,
    );

    if (sec > 0) {
      timeLeft += sec;
      _countdownAccumulator = 0;
      showResult = false;
      paused = false;
      resultStatus = 'lost';
      finalScore = 0;
      _syncBoard();
      onStateChanged();
    }

    return sec;
  }

  Future<void> togglePause() async {
    if (!_ready) return;
    pausedByUser = !pausedByUser;
    paused = pausedByUser;
    onStateChanged();
  }

  Future<void> toggleMusic() async {
    mutedMusic = !mutedMusic;
    await AudioManager.instance.setBgmMuted(mutedMusic);
    onStateChanged();
  }

  void toggleSfx() {
    mutedSfx = !mutedSfx;
    AudioManager.instance.setSfxMuted(mutedSfx);
    onStateChanged();
  }

  @override
  void onRemove() {
    if (_ready) {
      controller.removeListener(_onGameChanged);
      controller.dispose();
    }
    super.onRemove();
  }
}