HokmPlay/src/lib/game-store.ts

"use client";

import { create } from "zustand";
import { chooseCardAI, chooseTrumpAI } from "./hokm/ai";
import {
  advanceAfterTrick,
  chooseTrump as engineChooseTrump,
  createInitialState,
  dealForTrump,
  playCard,
  selectHakem,
  startNextRound,
} from "./hokm/engine";
import { Card, GameState, RoundResult, Seat, Suit } from "./hokm/types";
import { avatarEmoji } from "./online/types";
import { sound } from "./sound";

const KOT_POINTS = 2;

// Animation/pacing timings (ms) — UI matches these.
export const TIMING = {
  hakemDraw: 1500,
  aiTrump: 1000,
  aiPlay: 850,
  trickPause: 1150,
  roundPause: 2600,
} as const;

/** How long a player has to act before the system plays for them. */
export const TURN_MS = 20000;
/** Grace period to wait for a disconnected player to return. */
export const RECONNECT_MS = 15000;
/** Per-turn chance an online opponent briefly drops (mock). */
const DISCONNECT_CHANCE = 0.07;

export type GameMode = "ai" | "online";

export interface SeatPlayer {
  name: string;
  avatar: string; // emoji
  level: number;
}

export interface GameSettings {
  names: [string, string, string, string];
  targetScore: number;
}

export interface OnlineMatchConfig {
  players: { displayName: string; avatar: string; level: number }[]; // index = seat
  targetScore: number;
  stake: number;
  ranked: boolean;
}

interface MatchTally {
  tricksTeam0: number;
  kotFor: boolean; // your team kot'd opponents at least once
  kotAgainst: boolean;
}

interface GameStore {
  game: GameState;
  started: boolean;
  mode: GameMode;
  seatPlayers: SeatPlayer[];
  matchMeta: { ranked: boolean; stake: number };
  tally: MatchTally;

  /** epoch ms by which the current actor must act (for the turn-timer UI). */
  turnDeadline: number | null;
  /** a seat that has dropped and we're waiting on (online). */
  disconnectedSeat: Seat | null;
  reconnectDeadline: number | null;

  newMatch: (settings: GameSettings) => void;
  newOnlineMatch: (cfg: OnlineMatchConfig) => void;
  chooseTrump: (suit: Suit) => void;
  playHuman: (card: Card) => void;
  reset: () => void;
}

const AI_AVATARS = ["🦊", "🦁", "🦉", "🐯"];

let pending: ReturnType<typeof setTimeout> | null = null;
function clearPending() {
  if (pending) {
    clearTimeout(pending);
    pending = null;
  }
}

function freshTally(): MatchTally {
  return { tricksTeam0: 0, kotFor: false, kotAgainst: false };
}

export const useGameStore = create<GameStore>((set, get) => {
  function recordRound(result: RoundResult | null) {
    if (!result) return;
    const t = get().tally;
    set({
      tally: {
        tricksTeam0: t.tricksTeam0 + result.tricks[0],
        kotFor: t.kotFor || (result.winningTeam === 0 && result.kot),
        kotAgainst: t.kotAgainst || (result.winningTeam === 1 && result.kot),
      },
    });
  }

  function playSeatAI(seat: Seat) {
    const cur = get().game;
    if (cur.phase !== "playing" || cur.turn !== seat) return;
    const card = chooseCardAI(cur, seat);
    set({ game: playCard(cur, seat, card) });
    sound.play("cardPlay");
    scheduleAuto();
  }

  function scheduleAuto() {
    clearPending();
    const g = get().game;

    switch (g.phase) {
      case "selecting-hakem":
        set({ turnDeadline: null, disconnectedSeat: null, reconnectDeadline: null });
        pending = setTimeout(() => {
          set({ game: dealForTrump(get().game) });
          sound.play("deal");
          scheduleAuto();
        }, TIMING.hakemDraw);
        break;

      case "choosing-trump": {
        const hakem = g.hakem!;
        if (g.players[hakem].isHuman) {
          // human hakem: timed choice, system auto-picks on timeout
          set({ turnDeadline: Date.now() + TURN_MS, disconnectedSeat: null, reconnectDeadline: null });
          pending = setTimeout(() => {
            const cur = get().game;
            if (cur.phase !== "choosing-trump") return;
            const suit = chooseTrumpAI(cur.players[cur.hakem!].hand);
            set({ game: engineChooseTrump(cur, suit), turnDeadline: null });
            scheduleAuto();
          }, TURN_MS);
        } else {
          set({ turnDeadline: null });
          pending = setTimeout(() => {
            const cur = get().game;
            const suit = chooseTrumpAI(cur.players[cur.hakem!].hand);
            set({ game: engineChooseTrump(cur, suit) });
            sound.play("trump");
            scheduleAuto();
          }, TIMING.aiTrump);
        }
        break;
      }

      case "playing": {
        const seat = g.turn!;
        if (g.players[seat].isHuman) {
          // human turn: timed; system plays a smart legal move on timeout
          set({ turnDeadline: Date.now() + TURN_MS, disconnectedSeat: null, reconnectDeadline: null });
          pending = setTimeout(() => {
            const cur = get().game;
            if (cur.phase !== "playing" || cur.turn !== seat) return;
            set({ game: playCard(cur, seat, chooseCardAI(cur, seat)), turnDeadline: null });
            sound.play("cardPlay");
            scheduleAuto();
          }, TURN_MS);
        } else {
          const st = get();
          if (
            st.mode === "online" &&
            st.disconnectedSeat == null &&
            Math.random() < DISCONNECT_CHANCE
          ) {
            // simulate this opponent dropping; wait for them, then they return
            set({
              turnDeadline: null,
              disconnectedSeat: seat,
              reconnectDeadline: Date.now() + RECONNECT_MS,
            });
            const back = Math.floor(RECONNECT_MS * (0.4 + Math.random() * 0.45));
            pending = setTimeout(() => {
              set({ disconnectedSeat: null, reconnectDeadline: null });
              playSeatAI(seat);
            }, back);
          } else {
            set({ turnDeadline: null });
            pending = setTimeout(() => playSeatAI(seat), TIMING.aiPlay);
          }
        }
        break;
      }

      case "trick-complete":
        set({ turnDeadline: null, disconnectedSeat: null, reconnectDeadline: null });
        sound.play("trickWin");
        pending = setTimeout(() => {
          const next = advanceAfterTrick(get().game, KOT_POINTS);
          set({ game: next });
          if (next.phase === "match-over") {
            recordRound(next.lastRoundResult);
            sound.play(next.matchWinner === 0 ? "win" : "lose");
          } else if (next.phase === "round-over" && next.lastRoundResult?.kot) {
            sound.play("kot");
          }
          scheduleAuto();
        }, TIMING.trickPause);
        break;

      case "round-over":
        set({ turnDeadline: null, disconnectedSeat: null, reconnectDeadline: null });
        pending = setTimeout(() => {
          recordRound(get().game.lastRoundResult);
          set({ game: startNextRound(get().game) });
          scheduleAuto();
        }, TIMING.roundPause);
        break;

      default:
        set({ turnDeadline: null });
        break;
    }
  }

  return {
    game: createInitialState({ names: ["", "", "", ""], targetScore: 7 }),
    started: false,
    mode: "ai",
    seatPlayers: [],
    matchMeta: { ranked: false, stake: 0 },
    tally: freshTally(),
    turnDeadline: null,
    disconnectedSeat: null,
    reconnectDeadline: null,

    newMatch: (settings) => {
      clearPending();
      sound.init();
      const initial = createInitialState(settings);
      set({
        game: selectHakem(initial),
        started: true,
        mode: "ai",
        matchMeta: { ranked: false, stake: 0 },
        tally: freshTally(),
        turnDeadline: null,
        disconnectedSeat: null,
        reconnectDeadline: null,
        seatPlayers: settings.names.map((name, i) => ({
          name,
          avatar: AI_AVATARS[i],
          level: 0,
        })),
      });
      scheduleAuto();
    },

    newOnlineMatch: (cfg) => {
      clearPending();
      sound.init();
      const names = cfg.players.map((p) => p.displayName) as GameSettings["names"];
      const initial = createInitialState({ names, targetScore: cfg.targetScore });
      set({
        game: selectHakem(initial),
        started: true,
        mode: "online",
        matchMeta: { ranked: cfg.ranked, stake: cfg.stake },
        tally: freshTally(),
        turnDeadline: null,
        disconnectedSeat: null,
        reconnectDeadline: null,
        seatPlayers: cfg.players.map((p) => ({
          name: p.displayName,
          avatar: avatarEmoji(p.avatar),
          level: p.level,
        })),
      });
      scheduleAuto();
    },

    chooseTrump: (suit) => {
      const g = get().game;
      if (g.phase !== "choosing-trump") return;
      set({ game: engineChooseTrump(g, suit), turnDeadline: null });
      sound.play("trump");
      scheduleAuto();
    },

    playHuman: (card) => {
      const g = get().game;
      if (g.phase !== "playing" || g.turn !== 0) return;
      set({ game: playCard(g, 0, card), turnDeadline: null });
      sound.play("cardPlay");
      scheduleAuto();
    },

    reset: () => {
      clearPending();
      set({
        game: createInitialState({ names: ["", "", "", ""], targetScore: 7 }),
        started: false,
        mode: "ai",
        seatPlayers: [],
        tally: freshTally(),
        turnDeadline: null,
        disconnectedSeat: null,
        reconnectDeadline: null,
      });
    },
  };
});