// === Player Card Data ===

export type PlayerType = 'GK' | 'OUTFIELD';

export interface AttackAttributes {
  dribbeln: number;
  finte: number;
  flacherPass: number;
  hoherPass: number;
  offKopfball: number;
  schuss: number;
}

export interface OutfieldDefenseAttributes {
  positionieren: number;
  zweikampf: number;
  abfangen: number;
  defKopfball: number;
  decken: number;
  blocken: number;
}

export interface GoalkeeperDefenseAttributes {
  positionieren: number;
  einsVsEins: number;
  kick: number;
  abfangen: number;
  fausten: number;
  parade: number;
}

export type DefenseAttributes = OutfieldDefenseAttributes | GoalkeeperDefenseAttributes;

export interface PlayerCard {
  id: string;
  name: string;
  type: PlayerType;
  rating: number;
  attack: AttackAttributes;
  defense: DefenseAttributes;
  cardImage: string;
  photo: string | null;
}

// === Attack Attribute Keys ===
export type AttackKey = keyof AttackAttributes;
export type OutfieldDefenseKey = keyof OutfieldDefenseAttributes;
export type GoalkeeperDefenseKey = keyof GoalkeeperDefenseAttributes;

// === Game State ===

export type GamePhase =
  | 'lobby'
  | 'coin_flip'
  | 'draft'
  | 'half_1'
  | 'half_time'
  | 'half_2'
  | 'finished';

export type TurnPhase =
  | 'draw_card'
  | 'pre_action'
  | 'choose_attribute'
  | 'resolve_duel'
  | 'post_duel';

export type DuelOutcome = 'attacker_wins' | 'defender_wins';

export interface DuelResult {
  attackerCardId: string;
  defenderCardId: string;
  attackAttribute: AttackKey;
  defenseAttribute: string;
  attackValue: number;
  defenseValue: number;
  outcome: DuelOutcome;
  pointDifference: number;
  coinFlipDecided: boolean;
  goalScored: boolean;
  scorer?: string;
}

export interface TeamState {
  sessionId: string;
  displayName: string;
  starters: string[];
  bench: string[];
  deck: string[];
  discard: string[];
  currentCard: string | null;
  goals: number;
  goalScorers: string[];
  piggyBank: number;
  attacksRemaining: number;
  consecutiveWins: number;
  substitutionsUsed: number;
}

export interface GameState {
  id: string;
  roomId: string;
  phase: GamePhase;
  turnPhase: TurnPhase;
  half: 1 | 2;
  attackingTeam: 'player1' | 'player2';
  player1: TeamState;
  player2: TeamState;
  duelHistory: DuelResult[];
  coinFlipWinner: 'player1' | 'player2' | null;
  turnNumber: number;
  lastUpdated: string;
}

// === Room ===

export type RoomStatus = 'waiting' | 'drafting' | 'playing' | 'paused' | 'finished';

export interface Room {
  id: string;
  name: string;
  status: RoomStatus;
  createdAt: string;
  updatedAt: string;
  player1: PlayerSlot | null;
  player2: PlayerSlot | null;
  gameStateId: string | null;
}

export interface PlayerSlot {
  sessionId: string;
  displayName: string;
  connected: boolean;
}

// === Client Game State (sanitized view) ===

export interface ClientTeamState {
  displayName: string;
  deckCount: number;
  discard: string[];
  currentCard: PlayerCard | null;
  goals: number;
  goalScorers: string[];
  piggyBank: number;
  attacksRemaining: number;
  consecutiveWins: number;
  bench: PlayerCard[];
  starters: PlayerCard[];
}

export interface ClientOpponentState {
  displayName: string;
  deckCount: number;
  discardCount: number;
  currentCard: PlayerCard | null;
  goals: number;
  goalScorers: string[];
  piggyBank: number;
  attacksRemaining: number;
  consecutiveWins: number;
}

export interface ClientGameState {
  phase: GamePhase;
  turnPhase: TurnPhase;
  half: 1 | 2;
  isMyTurn: boolean;
  amAttacking: boolean;
  myTeam: ClientTeamState;
  opponent: ClientOpponentState;
  duelHistory: DuelResult[];
  score: [number, number];
  availableActions: ActionDefinition[];
}

// === Actions ===

export interface ActionDefinition {
  id: string;
  name: string;
  description: string;
  cost: number;
  enabled: boolean;
}

// === Socket Events ===

export interface ServerToClientEvents {
  'room:created': (room: Room) => void;
  'room:joined': (room: Room) => void;
  'room:list': (rooms: Room[]) => void;
  'room:error': (data: { message: string }) => void;
  'room:player_disconnected': (data: { playerName: string }) => void;
  'room:player_reconnected': (data: { playerName: string }) => void;

  'draft:start': (data: { availablePlayers: PlayerCard[]; pickingPlayer: string }) => void;
  'draft:your_turn': (data: { remainingPlayers: PlayerCard[] }) => void;
  'draft:opponent_picked': (data: { remainingCount: number }) => void;
  'draft:pick_confirmed': (data: { cardId: string; remainingPlayers: PlayerCard[] }) => void;
  'draft:lineup_confirmed': () => void;
  'draft:complete': () => void;

  'game:state_update': (state: ClientGameState) => void;
  'game:coin_flip': (data: { winner: string; result: 'heads' | 'tails' }) => void;
  'game:half_start': (data: { half: 1 | 2; firstAttacker: string }) => void;
  'game:card_drawn': (data: { card: PlayerCard }) => void;
  'game:waiting_for_attribute': (data: { attackerCard: PlayerCard }) => void;
  'game:duel_result': (result: DuelResult) => void;
  'game:possession_change': (data: { newAttacker: string }) => void;
  'game:goal': (data: { scorer: string; team: string; score: [number, number] }) => void;
  'game:half_end': (data: { half: 1 | 2; score: [number, number] }) => void;
  'game:finished': (data: { finalScore: [number, number]; matchLog: DuelResult[] }) => void;
  'game:action_result': (data: { actionId: string; success: boolean; message: string }) => void;
}

export interface ClientToServerEvents {
  'room:create': (data: { playerName: string; roomName: string }) => void;
  'room:join': (data: { playerName: string; roomId: string }) => void;
  'room:list': () => void;
  'room:reconnect': (data: { sessionId: string; roomId: string }) => void;

  'draft:pick': (data: { cardId: string }) => void;
  'draft:set_lineup': (data: { starters: string[]; bench: string[] }) => void;

  'game:choose_attribute': (data: { attribute: AttackKey }) => void;
  'game:use_action': (data: { actionId: string; params?: Record<string, unknown> }) => void;
  'game:skip_action': () => void;
}