) : (
// bench = players NOT on any court AND NOT in any queue
// So 0 bench means everyone is either playing OR waiting in queue
(() => {
const inQueue = new Set();
(group.upcoming || []).forEach(m => m.players?.forEach(id => inQueue.add(id)));
const hasQueue = inQueue.size > 0;
const hasActive = activePlayerIds.size > 0;
let msg, sub;
if (hasActive && hasQueue) {
msg = "ทุกคนอยู่ในสนามหรือคิวแล้ว";
sub = `${activePlayerIds.size} คนกำลังเล่น · ${inQueue.size} คนรอในคิว`;
} else if (hasActive) {
msg = "ทุกคนกำลังลงสนามอยู่ 🏸";
sub = null;
} else if (hasQueue) {
msg = "ทุกคนอยู่ในคิวรอลงสนาม";
sub = "เลือกสนามว่างเพื่อเริ่มเล่น";
} else {
msg = "ยังไม่มีผู้เล่นในก๊วนนี้";
sub = null;
}
return (
)}
);
}
/* -------- Swap player modal -------- */
function SwapPlayerModal({ group, playerById, bench, swap, onClose, onPick }) {
const out = playerById[swap.outId];
const court = group.courts.find(c => c.id === swap.courtId);
const match = group.active[swap.courtId];
const teammateIds = match
? (group.mode === "double"
? (match.players.slice(0,2).includes(swap.outId) ? match.players.slice(0,2) : match.players.slice(2,4))
: [])
: [];
const teammateAvg = teammateIds
.filter(id => id !== swap.outId)
.reduce((s, id) => s + (playerById[id]?.level || 0), 0) /
Math.max(1, teammateIds.length - 1);
// From upcoming queue: list candidates (deduped) — each player appears once
// Exclude: the outgoing player, anyone currently playing on ANY active court
// (a player can be both on a court now AND scheduled in upcoming — must not
// appear as a swap candidate or they'd be on two courts at once).
const activeIds = new Set();
Object.values(group.active || {}).forEach(m => m?.players?.forEach(id => activeIds.add(id)));
const seenInQueue = new Set();
const upcomingCands = [];
(group.upcoming || []).forEach((m, mi) => {
m.players.forEach(pid => {
if (pid === swap.outId) return; // exclude outgoing
if (activeIds.has(pid)) return; // exclude anyone playing right now
if (seenInQueue.has(pid)) return; // dedupe by player id
seenInQueue.add(pid);
const p = playerById[pid];
if (p) upcomingCands.push({ player: p, fromQueueIdx: mi + 1, courtId: m.court });
});
});
// Bench candidates — already excludes anyone in active/upcoming (computed in GroupSession),
// but guard against the outgoing player and dedupe defensively
const seenBench = new Set();
const benchUniq = bench.filter(p => {
if (p.id === swap.outId) return false;
if (activeIds.has(p.id)) return false;
if (seenBench.has(p.id)) return false;
seenBench.add(p.id);
return true;
});
function levelDelta(p) {
return Math.abs(p.level - (out?.level || 0));
}
const benchSorted = benchUniq.slice().sort((a, b) => {
// Suggest closest level first; tiebreak by fewer plays
const da = levelDelta(a), db = levelDelta(b);
if (da !== db) return da - db;
return (group.plays?.[a.id] || 0) - (group.plays?.[b.id] || 0);
});
return (
ยกเลิก}>
)}
);
}
/* -------- Manual queue modal -------- */
// Host hand-picks who plays whom. Only bench players are eligible. The host
// taps a player to drop them into the currently-targeted team; the target
// auto-advances to the other team when one side fills.
function ManualQueueModal({ mode, players, activeIds, queuedIds, plays, systemConfig, onClose, onConfirm }) {
const need = mode === "double" ? 2 : 1;
const [teamA, setTeamA] = useState_grp([]);
const [teamB, setTeamB] = useState_grp([]);
const [target, setTarget] = useState_grp("A");
const _active = activeIds || new Set();
const _queued = queuedIds || new Set();
const statusOf = (id) => _active.has(id) ? "active" : (_queued.has(id) ? "queued" : "free");
const picked = new Set([...teamA, ...teamB]);
// FREE pick: everyone in the group is selectable. Sort free/resting players first
// (the natural picks), then those already playing or queued, each by fewest plays.
const rank = { free: 0, queued: 1, active: 2 };
const candidates = players
.slice()
.filter(p => !picked.has(p.id))
.sort((a, b) => (rank[statusOf(a.id)] - rank[statusOf(b.id)]) || ((plays[a.id] || 0) - (plays[b.id] || 0)));
const canConfirm = teamA.length === need && teamB.length === need;
function pick(id) {
// If already placed, remove from whichever team holds them
if (teamA.includes(id)) { setTeamA(teamA.filter(x => x !== id)); return; }
if (teamB.includes(id)) { setTeamB(teamB.filter(x => x !== id)); return; }
// Add to the target team if it has room; otherwise to the other side
if (target === "A" && teamA.length < need) {
const next = [...teamA, id];
setTeamA(next);
if (next.length === need && teamB.length < need) setTarget("B");
} else if (target === "B" && teamB.length < need) {
const next = [...teamB, id];
setTeamB(next);
if (next.length === need && teamA.length < need) setTarget("A");
} else if (teamA.length < need) {
const next = [...teamA, id]; setTeamA(next);
if (next.length === need && teamB.length < need) setTarget("B");
} else if (teamB.length < need) {
const next = [...teamB, id]; setTeamB(next);
}
}
function removeFrom(team, id) {
if (team === "A") { setTeamA(teamA.filter(x => x !== id)); setTarget("A"); }
else { setTeamB(teamB.filter(x => x !== id)); setTarget("B"); }
}
const playerById = Object.fromEntries(players.map(p => [p.id, p]));
return (
}>