import 'dart:async';
import 'dart:math' as math;

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

import '../game_cubit.dart';
import '../game_models.dart';
import 'card_codes.dart';
import 'card_component.dart';
import 'table_pieces.dart';

/// صحنه‌ی میز حکم با انیمیشن. شما همیشه پایین میز (rel=0) هستید.
/// کامپوننت‌های دست و trick ماندگارند و با افکت حرکت جابه‌جا می‌شوند.
///
/// این کلاس فقط «وضعیتِ سرور → چیدمانِ صحنه» را مدیریت می‌کند:
///  - [_layoutHand] / [_layoutTrick] کارت‌های دست و زمین (ماندگار، با انیمیشن).
///  - [_rebuildBacksAndInfo] عناصرِ بازساخته‌شونده (پشت‌کارت، شمارنده‌ها، برچسب‌ها).
///  - [_checkCut] + [update]/[render] افکتِ «بریدن با حکم» (تکان + رعد).
class HokmGame extends FlameGame {
  final GameCubit cubit;

  // وضعیت بازی و اشتراکِ stream.
  GameState? _s;
  StreamSubscription? _sub;

  // کامپوننت‌های ماندگار (با کدِ کارت کلید می‌خورند) و بازساخته‌شونده.
  final Map<String, CardComponent> _hand = {};
  final Map<String, CardComponent> _trick = {};
  final List<Component> _backs = [];
  final List<Component> _info = [];

  // ابعادِ کارت‌های روی میز (بر اساس عرض صفحه محاسبه می‌شود).
  double _cardW = 60;
  double _cardH = 87;

  // افکتِ تکانِ صفحه هنگام بریدن با حکم.
  double _shake = 0;
  double _t = 0;
  List<String> _prevTrick = const [];

  HokmGame(this.cubit);

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

  @override
  Future<void> onLoad() async {
    add(Felt());
    _sub = cubit.stream.listen((ui) {
      if (ui.state == null) return;
      _checkCut(ui.state!);
      _s = ui.state;
      _relayout();
    });
    if (cubit.state.state != null) {
      _prevTrick = cubit.state.state!.trick.map((t) => t.card).toList();
      _s = cubit.state.state;
      _relayout();
    }
  }

  @override
  void onGameResize(Vector2 size) {
    super.onGameResize(size);
    if (isLoaded) _relayout();
  }

  @override
  void onRemove() {
    _sub?.cancel();
    super.onRemove();
  }

  // ===== افکتِ بریدن با حکم (تکان + رعد) =====

  // اگر دقیقاً یک کارتِ تازه به زمین اضافه شده و آن کارت «بُرِش با حکم» باشد
  // (خالِ زمینه آتو نیست ولی کارتِ تازه آتوست)، همان لحظه تکان + رعد.
  void _checkCut(GameState s) {
    final now = s.trick.map((t) => t.card).toList();
    final addedOne = now.length == _prevTrick.length + 1 && _isPrefix(_prevTrick, now);
    if (addedOne &&
        s.trump != null &&
        s.leadSuit != null &&
        s.leadSuit != s.trump &&
        suitName(now.last) == s.trump) {
      _shake = 1.0;
      add(Lightning());
    }
    _prevTrick = now;
  }

  static bool _isPrefix(List<String> a, List<String> b) {
    for (var i = 0; i < a.length; i++) {
      if (a[i] != b[i]) return false;
    }
    return true;
  }

  @override
  void update(double dt) {
    super.update(dt);
    _t += dt;
    if (_shake > 0) _shake = math.max(0, _shake - dt * 2.2);
  }

  @override
  void render(Canvas canvas) {
    if (_shake <= 0) {
      super.render(canvas);
      return;
    }
    final dx = math.sin(_t * 55) * _shake * size.x * 0.018;
    final dy = math.cos(_t * 70) * _shake * size.y * 0.010;
    canvas.save();
    canvas.translate(dx, dy);
    super.render(canvas);
    canvas.restore();
  }

  // ===== چیدمان =====

  // جایگاهِ نسبیِ یک seat نسبت به شما: 0=پایین، 1=چپ، 2=بالا، 3=راست.
  int _rel(int seat) => (seat - _s!.yourSeat + 4) % 4;

  void _relayout() {
    final s = _s;
    if (s == null) return;
    _cardW = size.x * 0.19;
    _cardH = _cardW * kCardRatio;

    _rebuildBacksAndInfo(s);
    _layoutTrick(s);
    _layoutHand(s);
  }

  // آیا این کارت در نوبتِ فعلی قابل بازی است (با رعایت follow-suit)؟
  bool _legal(String code) {
    final s = _s!;
    if (s.phase != 'playing' || s.trickDone || !s.isMyTurn) return false;
    final lead = s.leadSuit;
    if (lead == null || lead.isEmpty) return true;
    final hasLead = s.yourHand.any((c) => suitName(c) == lead);
    return !hasLead || suitName(code) == lead;
  }

  // حرکتِ نرمِ یک کارت به مقصد، بدون انباشته‌شدنِ افکت‌ها.
  void _moveTo(CardComponent c, Vector2 target, {double dur = 0.38}) {
    c.children.whereType<MoveToEffect>().toList().forEach((e) => e.removeFromParent());
    if ((c.position - target).length < 0.5) {
      c.position = target;
      return;
    }
    c.add(MoveToEffect(target, EffectController(duration: dur, curve: Curves.easeOutCubic)));
  }

  // ناحیه‌ی وسط میز که رهاکردنِ کارت در آن یعنی بازی (بالاتر از دستِ شما).
  Rect _dropZone() =>
      Rect.fromLTRB(size.x * 0.15, size.y * 0.22, size.x * 0.85, size.y * 0.66);

  void _layoutHand(GameState s) {
    // مرتب‌سازی بر اساس خال و رتبه تا انتخاب برای بازیکن راحت‌تر باشد.
    final codes = List<String>.from(s.yourHand)..sort(compareCards);
    final n = codes.length;

    // کارت‌هایی که دیگر در دست نیستند و به trick هم نرفته‌اند ⇒ حذف.
    for (final code in _hand.keys.toList()) {
      if (!codes.contains(code)) {
        final c = _hand.remove(code)!;
        if (!_trick.containsKey(code)) c.removeFromParent();
      }
    }

    // کارت‌های دستِ خودتان بزرگ‌تر از کارت‌های روی میز.
    final hw = size.x * 0.225, hh = hw * kCardRatio;
    final handW = size.x * 0.80;
    final step = n > 1 ? (handW - hw) / (n - 1) : 0.0;
    final startX = size.x / 2 - (step * (n - 1)) / 2;
    final y = size.y * 0.85;

    for (var i = 0; i < n; i++) {
      final code = codes[i];
      final target = Vector2(startX + i * step, y);
      final legal = _legal(code);
      var c = _hand[code];
      if (c == null) {
        // کارت جدید ⇒ از مرکز میز پخش می‌شود.
        c = CardComponent(code: code, faceUp: true, size: Vector2(hw, hh), position: size / 2);
        _hand[code] = c;
        add(c);
      } else {
        c.size = Vector2(hw, hh);
      }
      c.onPlay = legal ? () => cubit.playCard(code) : null;
      c.dimmed = s.phase == 'playing' && s.isMyTurn && !legal;
      c.home = target;
      c.dropZone = _dropZone();
      c.restPriority = 10 + i;
      c.priority = 10 + i;
      _moveTo(c, target);
    }
  }

  void _layoutTrick(GameState s) {
    final present = s.trick.map((t) => t.card).toSet();

    // کارت‌های trick که دیگر نیستند (دست جمع شد) ⇒ به سمت برنده برو و حذف شو.
    for (final code in _trick.keys.toList()) {
      if (present.contains(code)) continue;
      final c = _trick.remove(code)!;
      c.children.whereType<MoveToEffect>().toList().forEach((e) => e.removeFromParent());
      c.add(SequenceEffect([
        MoveToEffect(_seatOrigin(_rel(s.turn)),
            EffectController(duration: 0.25, curve: Curves.easeIn)),
        RemoveEffect(),
      ]));
    }

    for (final tc in s.trick) {
      final slot = size / 2 + _trickOffset(_rel(tc.seat));
      var c = _trick[tc.card];
      if (c == null) {
        // اگر خودِ شما بازی کردید، همان کارتِ دست را منتقل کن (پرواز به وسط).
        c = _hand.remove(tc.card);
        if (c != null) {
          c.onPlay = null;
          c.dimmed = false;
          c.home = null;
        } else {
          c = CardComponent(
            code: tc.card,
            faceUp: true,
            size: Vector2(_cardW, _cardH),
            position: _seatOrigin(_rel(tc.seat)),
          );
          add(c);
        }
        _trick[tc.card] = c;
      }
      c.size = Vector2(_cardW, _cardH);
      c.priority = 5;
      _moveTo(c, slot);
    }
  }

  // مبدأِ نشستنِ هر جایگاه (برای پرتاب/جمعِ کارت‌ها).
  Vector2 _seatOrigin(int rel) {
    final c = size / 2;
    switch (rel) {
      case 1:
        return Vector2(size.x * 0.10, c.y);
      case 2:
        return Vector2(c.x, size.y * 0.14);
      case 3:
        return Vector2(size.x * 0.90, c.y);
      default:
        return Vector2(c.x, size.y * 0.82);
    }
  }

  // جابه‌جاییِ کارتِ هر جایگاه از مرکز، در ناحیه‌ی trick.
  Vector2 _trickOffset(int rel) {
    final d = _cardW * 0.62;
    switch (rel) {
      case 1:
        return Vector2(-d, 0);
      case 2:
        return Vector2(0, -d);
      case 3:
        return Vector2(d, 0);
      default:
        return Vector2(0, d);
    }
  }

  // ===== عناصرِ بازساخته‌شونده در هر به‌روزرسانی =====

  void _rebuildBacksAndInfo(GameState s) {
    for (final c in _backs) {
      c.removeFromParent();
    }
    for (final c in _info) {
      c.removeFromParent();
    }
    _backs.clear();
    _info.clear();

    for (var seat = 0; seat < 4; seat++) {
      if (seat == s.yourSeat) continue;
      final count = seat < s.handCounts.length ? s.handCounts[seat] : 0;
      _addBacks(_rel(seat), count);
    }
    _addTricksWon(s);
    _addScorePucks(s);
    _addInfo(s);
  }

  // شمارنده ۱: دست‌های برده‌ی این هَند (tricks_won) — دسته‌کارتِ پشت‌رو + عدد.
  // رسیدن به ۷ یعنی پایان هَند (سرور صفر می‌کند).
  void _addTricksWon(GameState s) {
    for (var team = 0; team < 2; team++) {
      final won = team < s.tricksWon.length ? s.tricksWon[team] : 0;
      if (won <= 0) continue;
      final mine = team == s.yourSeat % 2;
      final w = _cardW * 0.40, h = w * kCardRatio;
      // تیم شما جلوی شما (پایین)، تیم حریف جلوی حریفِ سمت راست.
      final base = mine
          ? Vector2(size.x * 0.28, size.y * 0.72)
          : Vector2(size.x * 0.82, size.y * 0.24);
      final step = Vector2(w * 0.40, 0);
      final n = won.clamp(1, 7);
      final start = base - step * ((n - 1) / 2);
      for (var i = 0; i < n; i++) {
        _addBack(start + step * i.toDouble(), Vector2(w, h), priority: 2);
      }
      _addLabel('$won', base - Vector2(0, h * 0.7), _cardW * 0.34, bold: true);
    }
  }

  // شمارنده ۲: امتیاز بازی (scores = هندهای برده) — دیسکِ هر تیم، ۰ تا ۷.
  // یکی جلوی شما (پایین)، دیگری جلوی حریف (راست) — نه جلوی یارِ بالا.
  void _addScorePucks(GameState s) {
    final radius = size.x * 0.05;
    for (var team = 0; team < 2; team++) {
      final score = team < s.scores.length ? s.scores[team] : 0;
      final mine = team == s.yourSeat % 2;
      final pos = mine
          ? Vector2(size.x * 0.50, size.y * 0.74)
          : Vector2(size.x * 0.84, size.y * 0.44);
      final puck = ScorePuck(score, radius: radius, position: pos)..priority = 22;
      _info.add(puck);
      add(puck);
    }
  }

  // پشت‌کارت‌های یک حریف به‌صورت بادبزنی.
  void _addBacks(int rel, int count) {
    if (count <= 0) return;
    final n = count.clamp(1, 13);
    final w = _cardW * 0.7, h = _cardH * 0.7;
    final c = size / 2;
    Vector2 base, stepV;
    switch (rel) {
      case 2:
        base = Vector2(c.x, size.y * 0.12);
        stepV = Vector2(size.x * 0.45 / 13, 0);
        break;
      case 1:
        base = Vector2(size.x * 0.07, c.y);
        stepV = Vector2(0, size.y * 0.4 / 13);
        break;
      default:
        base = Vector2(size.x * 0.93, c.y);
        stepV = Vector2(0, size.y * 0.4 / 13);
    }
    final start = base - stepV * ((n - 1) / 2);
    for (var i = 0; i < n; i++) {
      _addBack(start + stepV * i.toDouble(), Vector2(w, h), priority: 1);
    }
  }

  void _addInfo(GameState s) {
    if (s.trump != null) {
      final (sym, col) = _trumpGlyph(s.trump!);
      _addLabel('حکم: $sym', Vector2(size.x * 0.04, size.y * 0.04), size.x * 0.05,
          color: col, anchor: Anchor.topLeft, bold: true);
    }
    final a = s.scores.isNotEmpty ? s.scores[0] : 0;
    final b = s.scores.length > 1 ? s.scores[1] : 0;
    _addLabel('$a - $b', Vector2(size.x / 2, size.y * 0.04), size.x * 0.05,
        anchor: Anchor.topCenter);

    for (final p in s.players) {
      final pos = _seatLabelPos(_rel(p.seat));
      final isTurn = s.turn == p.seat;
      _addLabel(
        '${p.name}${p.bot ? ' (ربات)' : ''}${p.connected ? '' : ' …'}',
        pos,
        size.x * 0.035,
        color: isTurn ? const Color(0xFFE9B949) : Colors.white70,
        bold: isTurn,
      );
      if (isTurn) {
        final dot = CircleComponent(
          radius: size.x * 0.012,
          anchor: Anchor.center,
          position: pos - Vector2(0, size.y * 0.03),
          paint: Paint()..color = const Color(0xFFE9B949),
        )..priority = 20;
        _info.add(dot);
        add(dot);
      }
    }
  }

  // ===== کمکی‌های ساختِ عنصر (ثبت در فهرستِ بازساخته‌شونده) =====

  void _addBack(Vector2 pos, Vector2 sz, {required int priority}) {
    final c = CardComponent(code: '', faceUp: false, size: sz, position: pos, priority: priority);
    _backs.add(c);
    add(c);
  }

  void _addLabel(String text, Vector2 pos, double fontSize,
      {Color color = const Color(0xFFE9B949),
      Anchor anchor = Anchor.center,
      bool bold = false}) {
    final t = TextComponent(
      text: text,
      anchor: anchor,
      position: pos,
      priority: 21,
      textRenderer: TextPaint(
        style: TextStyle(
          fontFamily: 'Dana',
          color: color,
          fontSize: fontSize,
          fontWeight: bold ? FontWeight.bold : FontWeight.normal,
          shadows: const [Shadow(color: Colors.black, blurRadius: 4)],
        ),
      ),
    );
    _info.add(t);
    add(t);
  }

  Vector2 _seatLabelPos(int rel) {
    switch (rel) {
      case 1:
        return Vector2(size.x * 0.07, size.y * 0.30);
      case 2:
        return Vector2(size.x / 2, size.y * 0.07);
      case 3:
        return Vector2(size.x * 0.93, size.y * 0.30);
      default:
        return Vector2(size.x / 2, size.y * 0.975);
    }
  }

  (String, Color) _trumpGlyph(String suit) {
    switch (suit) {
      case 'hearts':
        return ('♥', const Color(0xFFD32F2F));
      case 'diamonds':
        return ('♦', const Color(0xFFD32F2F));
      case 'clubs':
        return ('♣', Colors.white);
      default:
        return ('♠', Colors.white);
    }
  }
}