import random
import uuid
from dataclasses import dataclass, field
from datetime import datetime
from typing import Optional

from core.models import Card as CardModel

STARTING_LIFE = 1000
MAX_ENERGY_CAP = 6
BOARD_SIZE = 5
HAND_SIZE = 5

@dataclass
class CardInstance:
  instance_id: str
  card_id: str
  name: str
  attack: int
  defense: int
  max_defense: int
  cost: int
  card_type: str
  card_rarity: str
  image_link: str
  text: str
  is_favorite: bool = False
  willing_to_trade: bool = False

  @classmethod
  def from_db_card(cls, card: CardModel) -> "CardInstance":
    return cls(
      instance_id=str(uuid.uuid4()),
      card_id=str(card.id),
      name=card.name,
      attack=card.attack,
      defense=card.defense,
      max_defense=card.defense,
      cost=card.cost,
      card_type=card.card_type,
      card_rarity=card.card_rarity,
      image_link=card.image_link or "",
      text=card.text,
      is_favorite=card.is_favorite,
      willing_to_trade=card.willing_to_trade,
    )

@dataclass
class PlayerState:
  user_id: str
  username: str
  deck_type: str
  life: int = STARTING_LIFE
  hand: list[CardInstance] = field(default_factory=list)
  deck: list[CardInstance] = field(default_factory=list)
  board: list[Optional[CardInstance]] = field(default_factory=lambda: [None] * BOARD_SIZE)
  energy: int = 0
  energy_cap: int = 0

  def draw_to_full(self):
    """Draw cards until hand has HAND_SIZE cards or deck is empty."""
    while len(self.hand) < HAND_SIZE and self.deck:
      self.hand.append(self.deck.pop())

  def refill_energy(self):
    self.energy = self.energy_cap

  def increment_energy_cap(self):
    self.energy_cap = min(self.energy_cap + 1, MAX_ENERGY_CAP)

  def has_playable_cards(self) -> bool:
    """True if the player has any playable cards left in deck or hand or on board."""
    board_empty = all([c is None for c in self.board])
    non_played_cards = self.deck + self.hand
    return (not board_empty) or any(c.cost <= max(MAX_ENERGY_CAP,self.energy) for c in non_played_cards)

@dataclass
class CombatEvent:
  attacker_slot: int
  attacker_name: str
  defender_slot: Optional[int]        # None if attacking life
  defender_name: Optional[str]
  damage: int
  defender_destroyed: bool
  life_damage: int                    # > 0 if hitting life total

@dataclass
class GameResult:
  winner_id: Optional[str]            # None if still ongoing
  reason: Optional[str]

@dataclass
class GameState:
  game_id: str
  players: dict[str, PlayerState]
  player_order: list[str]             # [player1_id, player2_id]
  active_player_id: str
  phase: str                          # "main" | "combat" | "end"
  turn: int = 1
  result: Optional[GameResult] = None
  last_combat_events: list[CombatEvent] = field(default_factory=list)
  turn_started_at: Optional[datetime] = None
  ai_difficulty: int = 5              # 1-10, only used for AI games
  ai_personality: Optional[str] = None  # AI personality type, only used for AI games

  def opponent_id(self, player_id: str) -> str:
    return next(p for p in self.player_order if p != player_id)

  def active_player(self) -> PlayerState:
    return self.players[self.active_player_id]

  def opponent(self) -> PlayerState:
    return self.players[self.opponent_id(self.active_player_id)]


def create_game(
  player1_id: str,
  player1_username: str,
  player1_deck_type: str,
  player1_cards: list,
  player2_id: str,
  player2_username: str,
  player2_deck_type: str,
  player2_cards: list,
) -> GameState:
  def make_player(user_id, username, deck_type, cards):
    deck = [CardInstance.from_db_card(c) for c in cards]
    random.shuffle(deck)
    player = PlayerState(user_id=user_id, username=username, deck_type=deck_type, deck=deck)
    return player

  p1 = make_player(player1_id, player1_username, player1_deck_type, player1_cards)
  p2 = make_player(player2_id, player2_username, player2_deck_type, player2_cards)

  # Randomly decide who goes first
  order = [player1_id, player2_id]
  random.shuffle(order)
  first = order[0]

  # First player starts with energy cap 1, draw immediately
  p1.increment_energy_cap()
  p2.increment_energy_cap()
  players = {player1_id: p1, player2_id: p2}
  players[first].refill_energy()
  players[first].draw_to_full()

  state = GameState(
    game_id=str(uuid.uuid4()),
    players=players,
    player_order=order,
    active_player_id=first,
    phase="main",
    turn=1,
  )
  state.turn_started_at = datetime.now()

  return state


def check_win_condition(state: GameState) -> Optional[GameResult]:
  for pid, player in state.players.items():
    if player.life <= 0:
      return GameResult(
        winner_id=state.opponent_id(pid),
        reason="Life reduced to zero"
      )

  for pid, player in state.players.items():
    opp = state.players[state.opponent_id(pid)]
    if any(c for c in player.board if c) and not opp.has_playable_cards():
      return GameResult(
        winner_id=pid,
        reason="Opponent has no playable cards remaining"
      )

  return None


def resolve_combat(state: GameState) -> list[CombatEvent]:
  active = state.active_player()
  opponent = state.opponent()
  events = []

  for slot in range(BOARD_SIZE):
    attacker = active.board[slot]
    if attacker is None:
      continue

    defender = opponent.board[slot]

    if defender is None:
      # Direct life damage
      opponent.life -= attacker.attack
      events.append(CombatEvent(
        attacker_slot=slot,
        attacker_name=attacker.name,
        defender_slot=None,
        defender_name=None,
        damage=attacker.attack,
        defender_destroyed=False,
        life_damage=attacker.attack,
      ))
    else:
      # Attack the opposing card
      defender.defense -= attacker.attack
      destroyed = defender.defense <= 0
      if destroyed:
          opponent.board[slot] = None

      events.append(CombatEvent(
        attacker_slot=slot,
        attacker_name=attacker.name,
        defender_slot=slot,
        defender_name=defender.name,
        damage=attacker.attack,
        defender_destroyed=destroyed,
        life_damage=0,
      ))

  return events


def action_play_card(state: GameState, hand_index: int, slot: int) -> str | None:
  if state.phase != "main":
    return "Not in main phase"

  player = state.active_player()

  if slot < 0 or slot >= BOARD_SIZE:
    return f"Invalid slot {slot}"
  if hand_index < 0 or hand_index >= len(player.hand):
    return "Invalid hand index"
  if player.board[slot] is not None:
    return "Slot already occupied"

  card = player.hand[hand_index]

  if card.cost > player.energy:
    return f"Not enough energy (have {player.energy}, need {card.cost})"

  player.energy -= card.cost
  player.board[slot] = card
  player.hand.pop(hand_index)
  return None


def action_sacrifice(state: GameState, slot: int) -> str | None:
  if state.phase != "main":
    return "Not in main phase"

  player = state.active_player()

  if slot < 0 or slot >= BOARD_SIZE:
    return f"Invalid slot {slot}"

  card = player.board[slot]
  if card is None:
    return "No card in that slot"

  # player.energy += card.cost
  player.energy += 1
  player.board[slot] = None
  return None


def action_end_turn(state: GameState) -> str | None:
  if state.phase != "main":
    return "Not in main phase"

  state.phase = "combat"

  # Resolve combat
  events = resolve_combat(state)
  state.last_combat_events = events

  # Check win condition after combat
  result = check_win_condition(state)
  if result:
    state.result = result
    state.phase = "end"
    return None

  # Switch to next player
  next_player_id = state.opponent_id(state.active_player_id)
  state.active_player_id = next_player_id
  state.turn += 1

  next_player = state.active_player()
  next_player.increment_energy_cap()
  next_player.refill_energy()
  next_player.draw_to_full()

  # Check if next player can't do anything
  result = check_win_condition(state)
  if result:
    state.result = result
    state.phase = "end"
    return None

  state.phase = "main"
  state.turn_started_at = datetime.now()
  return None