guandan.dev

import { Card, Rank, is_wild } from './types'

export interface Card_Group {

  type: 'bomb' | 'straight_flush' | 'triple' | 'pair' | 'wild' | 'single'

  cards: Card[]

}

// Group cards for visual display - finds bombs, straights, pairs, etc.

export function group_cards_for_display(cards: Card[], level: Rank): Card_Group[] {

  const groups: Card_Group[] = []

  const used = new Set<number>()

  // First extract wild cards (heart level cards)

  const wilds = cards.filter(c => is_wild(c, level))

  wilds.forEach(c => {

    used.add(c.Id)

    groups.push({ type: 'wild', cards: [c] })

  })

  const remaining = cards.filter(c => !used.has(c.Id))

  // Group by rank

  const by_rank = new Map<number, Card[]>()

  remaining.forEach(c => {

    const arr = by_rank.get(c.Rank) || []

    arr.push(c)

    by_rank.set(c.Rank, arr)

  })

  // Find bombs (4+ of same rank, or joker bomb)

  const jokers = remaining.filter(c => c.Rank === 13 || c.Rank === 14)

  if (jokers.length === 4) {

    jokers.forEach(c => used.add(c.Id))

    groups.push({ type: 'bomb', cards: jokers })

  }

  by_rank.forEach((rank_cards) => {

    const unused = rank_cards.filter(c => !used.has(c.Id))

    if (unused.length >= 4) {

      unused.forEach(c => used.add(c.Id))

      groups.push({ type: 'bomb', cards: unused })

    }

  })

  // Find straight flushes (5+ consecutive same suit)

  const by_suit = new Map<number, Card[]>()

  remaining.filter(c => !used.has(c.Id) && c.Rank < 13).forEach(c => {

    const arr = by_suit.get(c.Suit) || []

    arr.push(c)

    by_suit.set(c.Suit, arr)

  })

  by_suit.forEach((suit_cards) => {

    const sorted = [...suit_cards].sort((a, b) => a.Rank - b.Rank)

    let run: Card[] = []

    for (const card of sorted) {

      if (used.has(card.Id)) continue

      if (run.length === 0 || card.Rank === run[run.length - 1].Rank + 1) {

        run.push(card)

      } else {

        if (run.length >= 5) {

          run.forEach(c => used.add(c.Id))

          groups.push({ type: 'straight_flush', cards: run })

        }

        run = [card]

      }

    }

    if (run.length >= 5) {

      run.forEach(c => used.add(c.Id))

      groups.push({ type: 'straight_flush', cards: run })

    }

  })

  // Find triples

  by_rank.forEach((rank_cards) => {

    const unused = rank_cards.filter(c => !used.has(c.Id))

    if (unused.length === 3) {

      unused.forEach(c => used.add(c.Id))

      groups.push({ type: 'triple', cards: unused })

    }

  })

  // Find pairs

  by_rank.forEach((rank_cards) => {

    const unused = rank_cards.filter(c => !used.has(c.Id))

    if (unused.length === 2) {

      unused.forEach(c => used.add(c.Id))

      groups.push({ type: 'pair', cards: unused })

    }

  })

  // Remaining singles

  remaining.filter(c => !used.has(c.Id)).forEach(c => {

    groups.push({ type: 'single', cards: [c] })

  })

  return groups

}

// Find all cards with same rank as the given card

export function find_same_rank(cards: Card[], rank: number): Card[] {

  return cards.filter(c => c.Rank === rank)

}

// Combo types for play validation

export type Combo_Type =

  | 'single'

  | 'pair'

  | 'triple'

  | 'full_house'

  | 'straight'

  | 'tube' // consecutive pairs

  | 'plate' // consecutive triples

  | 'bomb_4'

  | 'bomb_5'

  | 'bomb_6'

  | 'bomb_7'

  | 'bomb_8'

  | 'straight_flush'

  | 'joker_bomb'

interface Detected_Combo {

  type: Combo_Type

  cards: Card[]

  value: number // for comparison

}

// Detect what combo a set of cards forms

export function detect_combo(cards: Card[], level: Rank): Detected_Combo | null {

  if (cards.length === 0) return null

  const sorted = [...cards].sort((a, b) => a.Rank - b.Rank)

  const n = sorted.length

  // Check joker bomb (4 jokers)

  if (n === 4 && sorted.every(c => c.Rank === 13 || c.Rank === 14)) {

    return { type: 'joker_bomb', cards, value: 1000 }

  }

  // Group by rank

  const by_rank = new Map<number, Card[]>()

  sorted.forEach(c => {

    const arr = by_rank.get(c.Rank) || []

    arr.push(c)

    by_rank.set(c.Rank, arr)

  })

  // Single

  if (n === 1) {

    return { type: 'single', cards, value: get_card_value(sorted[0], level) }

  }

  // Pair

  if (n === 2 && by_rank.size === 1) {

    return { type: 'pair', cards, value: get_card_value(sorted[0], level) }

  }

  // Triple

  if (n === 3 && by_rank.size === 1) {

    return { type: 'triple', cards, value: get_card_value(sorted[0], level) }

  }

  // Bombs (4-8 of same rank)

  if (by_rank.size === 1 && n >= 4 && n <= 8) {

    const bomb_types: Record<number, Combo_Type> = {

      4: 'bomb_4', 5: 'bomb_5', 6: 'bomb_6', 7: 'bomb_7', 8: 'bomb_8'

    }

    return { type: bomb_types[n], cards, value: get_card_value(sorted[0], level) + n * 100 }

  }

  // Full house (3+2)

  if (n === 5) {

    const counts = Array.from(by_rank.values()).map(arr => arr.length).sort()

    if (counts.length === 2 && counts[0] === 2 && counts[1] === 3) {

      const triple_rank = Array.from(by_rank.entries()).find(([_, arr]) => arr.length === 3)![0]

      return { type: 'full_house', cards, value: get_rank_value(triple_rank, level) }

    }

  }

  // Straight (5+ consecutive)

  if (n >= 5 && by_rank.size === n) {

    const ranks = sorted.map(c => c.Rank)

    if (is_consecutive(ranks)) {

      // Check if straight flush

      if (sorted.every(c => c.Suit === sorted[0].Suit)) {

        return { type: 'straight_flush', cards, value: get_card_value(sorted[n-1], level) + 500 + n * 10 }

      }

      return { type: 'straight', cards, value: get_card_value(sorted[n-1], level) }

    }

  }

  // Tube (consecutive pairs)

  if (n >= 4 && n % 2 === 0) {

    const pairs = Array.from(by_rank.entries())

    if (pairs.every(([_, arr]) => arr.length === 2)) {

      const ranks = pairs.map(([r, _]) => r).sort((a, b) => a - b)

      if (is_consecutive(ranks)) {

        return { type: 'tube', cards, value: get_rank_value(ranks[ranks.length - 1], level) }

      }

    }

  }

  // Plate (consecutive triples)

  if (n >= 6 && n % 3 === 0) {

    const triples = Array.from(by_rank.entries())

    if (triples.every(([_, arr]) => arr.length === 3)) {

      const ranks = triples.map(([r, _]) => r).sort((a, b) => a - b)

      if (is_consecutive(ranks)) {

        return { type: 'plate', cards, value: get_rank_value(ranks[ranks.length - 1], level) }

      }

    }

  }

  return null

}

function is_consecutive(ranks: number[]): boolean {

  const sorted = [...ranks].sort((a, b) => a - b)

  for (let i = 1; i < sorted.length; i++) {

    if (sorted[i] !== sorted[i - 1] + 1) return false

  }

  // Can't include 2 (rank 0) in straights

  if (sorted.includes(0)) return false

  return true

}

function get_card_value(card: Card, level: Rank): number {

  return get_rank_value(card.Rank, level)

}

function get_rank_value(rank: number, level: Rank): number {

  if (rank === 14) return 100 // red joker

  if (rank === 13) return 99  // black joker

  if (rank === level) return 98 // level card

  // 2 is highest non-special

  if (rank === 0) return 15

  // A is second highest

  if (rank === 12) return 14

  // rest are 3-K (ranks 1-11)

  return rank + 2

}

// Find valid plays that can beat the current table

export function find_valid_plays(

  hand: Card[],

  table_combo: Detected_Combo | null,

  level: Rank

): Card[][] {

  const suggestions: Card[][] = []

  if (!table_combo) {

    // Can play anything - suggest singles, pairs, triples

    const by_rank = new Map<number, Card[]>()

    hand.forEach(c => {

      const arr = by_rank.get(c.Rank) || []

      arr.push(c)

      by_rank.set(c.Rank, arr)

    })

    // Suggest lowest single

    const sorted = [...hand].sort((a, b) => get_card_value(a, level) - get_card_value(b, level))

    if (sorted.length > 0) {

      suggestions.push([sorted[0]])

    }

    // Suggest lowest pair

    for (const [_, cards] of by_rank) {

      if (cards.length >= 2) {

        suggestions.push(cards.slice(0, 2))

        break

      }

    }

    return suggestions.slice(0, 3)

  }

  // Need to beat the table combo

  const by_rank = new Map<number, Card[]>()

  hand.forEach(c => {

    const arr = by_rank.get(c.Rank) || []

    arr.push(c)

    by_rank.set(c.Rank, arr)

  })

  switch (table_combo.type) {

    case 'single': {

      const candidates = hand.filter(c => get_card_value(c, level) > table_combo.value)

        .sort((a, b) => get_card_value(a, level) - get_card_value(b, level))

      if (candidates.length > 0) {

        suggestions.push([candidates[0]])

      }

      break

    }

    case 'pair': {

      for (const [rank, cards] of by_rank) {

        if (cards.length >= 2 && get_rank_value(rank, level) > table_combo.value) {

          suggestions.push(cards.slice(0, 2))

          if (suggestions.length >= 2) break

        }

      }

      break

    }

    case 'triple': {

      for (const [rank, cards] of by_rank) {

        if (cards.length >= 3 && get_rank_value(rank, level) > table_combo.value) {

          suggestions.push(cards.slice(0, 3))

          if (suggestions.length >= 2) break

        }

      }

      break

    }

    default:

      // For complex combos, just return empty for now

      break

  }

  // Always suggest bombs as alternatives

  for (const [_, cards] of by_rank) {

    if (cards.length >= 4) {

      suggestions.push(cards)

    }

  }

  // Joker bomb

  const jokers = hand.filter(c => c.Rank === 13 || c.Rank === 14)

  if (jokers.length === 4) {

    suggestions.push(jokers)

  }

  return suggestions.slice(0, 3)

}

// Quick select helpers

export function select_pair(hand: Card[], level: Rank): Card[] | null {

  const by_rank = new Map<number, Card[]>()

  hand.forEach(c => {

    const arr = by_rank.get(c.Rank) || []

    arr.push(c)

    by_rank.set(c.Rank, arr)

  })

  // Find lowest pair

  const sorted_ranks = Array.from(by_rank.keys())

    .sort((a, b) => get_rank_value(a, level) - get_rank_value(b, level))

  for (const rank of sorted_ranks) {

    const cards = by_rank.get(rank)!

    if (cards.length >= 2) {

      return cards.slice(0, 2)

    }

  }

  return null

}

export function select_triple(hand: Card[], level: Rank): Card[] | null {

  const by_rank = new Map<number, Card[]>()

  hand.forEach(c => {

    const arr = by_rank.get(c.Rank) || []

    arr.push(c)

    by_rank.set(c.Rank, arr)

  })

  const sorted_ranks = Array.from(by_rank.keys())

    .sort((a, b) => get_rank_value(a, level) - get_rank_value(b, level))

  for (const rank of sorted_ranks) {

    const cards = by_rank.get(rank)!

    if (cards.length >= 3) {

      return cards.slice(0, 3)

    }

  }

  return null

}

export function select_bomb(hand: Card[], level: Rank): Card[] | null {

  const by_rank = new Map<number, Card[]>()

  hand.forEach(c => {

    const arr = by_rank.get(c.Rank) || []

    arr.push(c)

    by_rank.set(c.Rank, arr)

  })

  // Joker bomb first

  const jokers = hand.filter(c => c.Rank === 13 || c.Rank === 14)

  if (jokers.length === 4) {

    return jokers

  }

  const sorted_ranks = Array.from(by_rank.keys())

    .sort((a, b) => get_rank_value(a, level) - get_rank_value(b, level))

  for (const rank of sorted_ranks) {

    const cards = by_rank.get(rank)!

    if (cards.length >= 4) {

      return cards

    }

  }

  return null

}