import asyncio
import logging
import random
import uuid
from dataclasses import dataclass
from datetime import datetime

from fastapi import WebSocket
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session

from game.rules import (
  GameState, CardInstance, PlayerState, action_play_card, action_sacrifice,
  action_end_turn, create_game, CombatEvent, GameResult, BOARD_SIZE
)
from core.models import Card as CardModel, Deck as DeckModel, DeckCard as DeckCardModel, User as UserModel
from game.card import compute_deck_type
from ai.engine import AI_USER_ID, run_ai_turn, get_random_personality, choose_cards

logger = logging.getLogger("app")

## Storage

active_games: dict[str, GameState] = {}
active_deck_ids: dict[str, str|None] = {}  # user_id -> deck_id
connections: dict[str, dict[str, WebSocket]] = {}  # game_id -> {user_id -> websocket}

@dataclass
class QueueEntry:
  user_id: str
  deck_id: str
  websocket: WebSocket

queue: list[QueueEntry] = []
queue_lock = asyncio.Lock()

## Game Result

def record_game_result(state: GameState, db: Session):
  if state.result is None or state.result.winner_id is None:
    return

  winner_id_str = state.result.winner_id
  loser_id_str = state.opponent_id(winner_id_str)

  # Skip database updates for AI battles
  if AI_USER_ID not in [winner_id_str, loser_id_str]:
    winner = db.query(UserModel).filter(UserModel.id == uuid.UUID(winner_id_str)).first()
    if winner:
      winner.wins += 1

    loser = db.query(UserModel).filter(UserModel.id == uuid.UUID(loser_id_str)).first()
    if loser:
      loser.losses += 1

  winner_deck_id = active_deck_ids.get(winner_id_str)
  loser_deck_id = active_deck_ids.get(loser_id_str)

  if AI_USER_ID not in [winner_id_str, loser_id_str]:
    if winner_deck_id:
      deck = db.query(DeckModel).filter(DeckModel.id == uuid.UUID(winner_deck_id)).first()
      if deck:
        deck.times_played += 1
        deck.wins += 1
    else:
      logger.warning(f"record_game_result: no deck_id found for winner {winner_id_str}")

    if loser_deck_id:
      deck = db.query(DeckModel).filter(DeckModel.id == uuid.UUID(loser_deck_id)).first()
      if deck:
        deck.times_played += 1
        deck.losses += 1
    else:
      logger.warning(f"record_game_result: no deck_id found for loser {loser_id_str}")

  db.commit()

## Serialization

def serialize_card(card: CardInstance|None) -> dict | None:
  if card is None:
    return None
  return {
    "instance_id": card.instance_id,
    "card_id": card.card_id,
    "name": card.name,
    "attack": card.attack,
    "defense": card.defense,
    "max_defense": card.max_defense,
    "cost": card.cost,
    "card_type": card.card_type,
    "card_rarity": card.card_rarity,
    "image_link": card.image_link,
    "text": card.text,
    "is_favorite": card.is_favorite,
    "willing_to_trade": card.willing_to_trade,
  }

def serialize_player(player: PlayerState, hide_hand=False) -> dict:
  return {
    "user_id": player.user_id,
    "username": player.username,
    "deck_type": player.deck_type,
    "life": player.life,
    "energy": player.energy,
    "energy_cap": player.energy_cap,
    "board": [serialize_card(c) for c in player.board],
    "hand": [serialize_card(c) for c in player.hand] if not hide_hand else [],
    "hand_size": len(player.hand),
    "deck_size": len(player.deck),
  }

def serialize_event(event: CombatEvent) -> dict:
  return {
    "attacker_slot": event.attacker_slot,
    "attacker_name": event.attacker_name,
    "defender_slot": event.defender_slot,
    "defender_name": event.defender_name,
    "damage": event.damage,
    "defender_destroyed": event.defender_destroyed,
    "life_damage": event.life_damage,
  }

def serialize_state(state: GameState, perspective_user_id: str) -> dict:
  opponent_id = state.opponent_id(perspective_user_id)
  return {
    "game_id": state.game_id,
    "phase": state.phase,
    "turn": state.turn,
    "active_player_id": state.active_player_id,
    "player_order": state.player_order,
    "you": serialize_player(state.players[perspective_user_id]),
    "opponent": serialize_player(state.players[opponent_id], hide_hand=True),
    "last_combat_events": [serialize_event(e) for e in state.last_combat_events],
    "result": {
      "winner_id": state.result.winner_id,
      "reason": state.result.reason,
    } if state.result else None,
    "turn_started_at": state.turn_started_at.isoformat() if state.turn_started_at else None,
  }


## Broadcasting

async def broadcast_state(game_id: str):
  state = active_games.get(game_id)
  if not state:
    return
  game_connections = connections.get(game_id, {})
  for user_id, ws in game_connections.items():
    try:
      await ws.send_json({
        "type": "state",
        "state": serialize_state(state, user_id),
      })
    except Exception as e:
      logger.debug(f"WebSocket send failed (stale connection): {e}")

  if state.active_player_id == AI_USER_ID and not state.result:
    asyncio.create_task(run_ai_turn(game_id))

async def send_error(ws: WebSocket, message: str):
  await ws.send_json({"type": "error", "message": message})


## Matchmaking

def load_deck_cards(deck_id: str, user_id: str, db: Session) -> list | None:
  deck = db.query(DeckModel).filter(
    DeckModel.id == uuid.UUID(deck_id),
    DeckModel.user_id == uuid.UUID(user_id)
  ).first()
  if not deck:
    return None
  deck_card_ids = [
    dc.card_id for dc in db.query(DeckCardModel).filter(DeckCardModel.deck_id == deck.id).all()
  ]
  cards = db.query(CardModel).filter(CardModel.id.in_(deck_card_ids)).all()
  return cards

async def try_match(db: Session):
  async with queue_lock:
    if len(queue) < 2:
      return

    p1_entry = queue.pop(0)
    p2_entry = queue.pop(0)

  p1_user = db.query(UserModel).filter(UserModel.id == uuid.UUID(p1_entry.user_id)).first()
  p2_user = db.query(UserModel).filter(UserModel.id == uuid.UUID(p2_entry.user_id)).first()

  p1_cards = load_deck_cards(p1_entry.deck_id, p1_entry.user_id, db)
  p2_cards = load_deck_cards(p2_entry.deck_id, p2_entry.user_id, db)

  p1_deck_type = compute_deck_type(p1_cards if p1_cards else [])
  p2_deck_type = compute_deck_type(p2_cards if p2_cards else [])

  active_deck_ids[p1_entry.user_id] = p1_entry.deck_id
  active_deck_ids[p2_entry.user_id] = p2_entry.deck_id

  if not p1_cards or not p2_cards or not p1_user or not p2_user:
    await send_error(p1_entry.websocket, "Failed to load deck")
    await send_error(p2_entry.websocket, "Failed to load deck")
    return

  state = create_game(
    p1_entry.user_id, p1_user.username, p1_deck_type if p1_deck_type else "", p1_cards,
    p2_entry.user_id, p2_user.username, p2_deck_type if p2_deck_type else "", p2_cards,
  )

  active_games[state.game_id] = state
  connections[state.game_id] = {
    p1_entry.user_id: p1_entry.websocket,
    p2_entry.user_id: p2_entry.websocket,
  }

  # Notify both players the game has started
  for user_id, ws in connections[state.game_id].items():
    await ws.send_json({
      "type": "game_start",
      "game_id": state.game_id,
    })

  await broadcast_state(state.game_id)


## Direct challenge game creation (no WebSocket needed at creation time)

def create_challenge_game(
  challenger_id: str, challenger_deck_id: str,
  challenged_id: str, challenged_deck_id: str,
  db: Session
) -> str:
  challenger = db.query(UserModel).filter(UserModel.id == uuid.UUID(challenger_id)).first()
  challenged = db.query(UserModel).filter(UserModel.id == uuid.UUID(challenged_id)).first()
  p1_cards = load_deck_cards(challenger_deck_id, challenger_id, db)
  p2_cards = load_deck_cards(challenged_deck_id, challenged_id, db)
  if not p1_cards or not p2_cards or not challenger or not challenged:
    raise ValueError("Could not load decks or players")
  p1_deck_type = compute_deck_type(p1_cards)
  p2_deck_type = compute_deck_type(p2_cards)
  state = create_game(
    challenger_id, challenger.username, p1_deck_type or "", p1_cards,
    challenged_id, challenged.username, p2_deck_type or "", p2_cards,
  )
  active_games[state.game_id] = state
  # Initialize with no websockets; players connect via /ws/game/{game_id} after redirect
  connections[state.game_id] = {challenger_id: None, challenged_id: None}
  active_deck_ids[challenger_id] = challenger_deck_id
  active_deck_ids[challenged_id] = challenged_deck_id
  return state.game_id


## Action handler

async def handle_action(game_id: str, user_id: str, message: dict, db: Session):
  state = active_games.get(game_id)
  if not state:
    logger.warning(f"handle_action: game {game_id} not found")
    return
  if state.result:
    logger.warning(f"handle_action: game {game_id} already over")
    return
  if state.active_player_id != user_id:
    logger.warning(f"handle_action: not {user_id}'s turn, active is {state.active_player_id}")
    ws = connections[game_id].get(user_id)
    if ws:
      await send_error(ws, "It's not your turn")
    return

  action = message.get("type")
  err = None

  if action == "play_card":
    err = action_play_card(state, message["hand_index"], message["slot"])
    if not err:
      # Find the card that was just played
      slot = message["slot"]
      card_instance = state.players[user_id].board[slot]
      if card_instance:
        try:
          card = db.query(CardModel).filter(
            CardModel.id == uuid.UUID(card_instance.card_id)
          ).first()
          if card:
            card.times_played += 1
            db.commit()
        except (SQLAlchemyError, ValueError) as e:
          logger.warning(f"Failed to increment times_played for card {card_instance.card_id}: {e}")
          db.rollback()
  elif action == "sacrifice":
    slot = message.get("slot")
    if slot is None:
      err = "No slot provided"
    else:
      # Find the card instance_id before it's removed
      card = state.players[user_id].board[slot]
      if card:
        # Notify opponent first
        opponent_id = state.opponent_id(user_id)
        opp_ws = connections[game_id].get(opponent_id)
        if opp_ws:
          try:
            await opp_ws.send_json({
              "type": "sacrifice_animation",
              "instance_id": card.instance_id,
            })
          except Exception as e:
            logger.debug(f"WebSocket send failed (stale connection): {e}")
        await asyncio.sleep(0.65)
      err = action_sacrifice(state, slot)
  elif action == "end_turn":
    err = action_end_turn(state)
  else:
    ws = connections[game_id].get(user_id)
    if ws:
      await send_error(ws, f"Unknown action: {action}")
    return

  if err:
    ws = connections[game_id].get(user_id)
    if ws:
      await send_error(ws, err)
    return

  await broadcast_state(game_id)

  if state.result:
    record_game_result(state, db)
    for uid in list(connections.get(game_id,{}).keys()):
      active_deck_ids.pop(uid, None)
    active_games.pop(game_id, None)
    connections.pop(game_id, None)

DISCONNECT_GRACE_SECONDS = 15

async def handle_disconnect(game_id: str, user_id: str):
  await asyncio.sleep(DISCONNECT_GRACE_SECONDS)

  # Check if game still exists and player hasn't reconnected
  if game_id not in active_games:
    return
  if user_id in connections.get(game_id, {}):
    return  # player reconnected during grace period

  state = active_games[game_id]
  if state.result:
    return  # game already ended normally

  winner_id = state.opponent_id(user_id)

  state.result = GameResult(
    winner_id=winner_id,
    reason="Opponent disconnected"
  )
  state.phase = "end"

  from core.database import SessionLocal
  db = SessionLocal()
  try:
    record_game_result(state, db)
  finally:
    db.close()

  # Notify the remaining player
  winner_ws = connections[game_id].get(winner_id)
  if winner_ws:
    try:
      await winner_ws.send_json({
        "type": "state",
        "state": serialize_state(state, winner_id),
      })
    except Exception as e:
      logger.debug(f"WebSocket send failed (stale connection): {e}")

  active_deck_ids.pop(user_id, None)
  active_deck_ids.pop(winner_id, None)
  active_games.pop(game_id, None)
  connections.pop(game_id, None)

TURN_TIME_LIMIT_SECONDS = 120

async def handle_timeout_claim(game_id: str, claimant_id: str, db: Session) -> str | None:
  state = active_games.get(game_id)
  if not state:
    return "Game not found"
  if state.result:
    return "Game already ended"
  if state.active_player_id == claimant_id:
    return "It's your turn"
  if not state.turn_started_at:
    return "No turn timer running"

  elapsed = (datetime.now() - state.turn_started_at).total_seconds()
  if elapsed < TURN_TIME_LIMIT_SECONDS:
    return f"Timer has not expired yet ({int(TURN_TIME_LIMIT_SECONDS - elapsed)}s remaining)"

  state.result = GameResult(
    winner_id=claimant_id,
    reason="Opponent ran out of time"
  )
  state.phase = "end"

  record_game_result(state, db)
  await broadcast_state(game_id)

  active_deck_ids.pop(state.active_player_id, None)
  active_deck_ids.pop(claimant_id, None)
  active_games.pop(game_id, None)
  connections.pop(game_id, None)

  return None

def create_solo_game(
    user_id: str,
    username: str,
    player_cards: list,
    ai_cards: list,
    deck_id: str,
    difficulty: int = 5,
) -> str:
    ai_personality = get_random_personality()
    ai_deck = choose_cards(ai_cards, difficulty, ai_personality)

    player_deck_type = compute_deck_type(player_cards) or "Balanced"
    ai_deck_type = compute_deck_type(ai_deck) or "Balanced"

    state = create_game(
        user_id, username, player_deck_type, player_cards,
        AI_USER_ID, "Computer", ai_deck_type, ai_deck,
    )

    state.ai_difficulty = difficulty
    state.ai_personality = ai_personality.value

    active_games[state.game_id] = state
    connections[state.game_id] = {}
    active_deck_ids[user_id] = deck_id
    active_deck_ids[AI_USER_ID] = None

    if state.active_player_id == AI_USER_ID:
      asyncio.create_task(run_ai_turn(state.game_id))

    return state.game_id

ANIMATION_DELAYS = {
  "pre_combat_pause": 0.5,    # pause before end_turn
  "per_attack_pre": 0.1,      # delay before each attack animation
  "lunge_duration": 0.42,     # lunge animation duration
  "shake_duration": 0.4,      # shake animation duration
  "damage_point": 0.22,       # when damage is applied mid-shake
  "post_attack": 0.08,        # gap between attacks
  "destroy_duration": 0.6,    # crumble animation duration
  "post_combat_buffer": 0.3,  # buffer after all animations finish
}

def calculate_combat_animation_time(events: list[CombatEvent]) -> float:
  total = 0.0
  for event in events:
    total += ANIMATION_DELAYS["per_attack_pre"]
    # Lunge and shake run simultaneously, so take the longer of the two
    total += max(
      ANIMATION_DELAYS["lunge_duration"],
      ANIMATION_DELAYS["shake_duration"]
    )
    total += ANIMATION_DELAYS["post_attack"]
    if event.defender_destroyed:
      total += ANIMATION_DELAYS["destroy_duration"]

  total += ANIMATION_DELAYS["post_combat_buffer"]
  return total