bunch of shit from claude code

backend/src/application/services/QueueService.ts

@@ -0,0 +1,183 @@
+import type { IQueueRepository } from "../../domain/interfaces/IQueueRepository";
+import type { MatchService } from "./MatchService";
+import type { EventBus } from "../events/EventBus";
+import type { Team } from "../../domain/models/Team";
+import type { Match } from "../../domain/models/Match";
+import { type QueueEntry, createQueueEntry } from "../../domain/models/QueueEntry";
+import { getAverageRating } from "../../domain/models/Team";
+import { QueueEvents } from "../../domain/events/QueueEvents";
+
+export interface MatchmakingConfig {
+  maxRatingDifference: number;
+  ratingExpansionRate: number;
+  minQueueTime: number;
+  protocol: string;
+}
+
+const DEFAULT_CONFIG: MatchmakingConfig = {
+  maxRatingDifference: 200,
+  ratingExpansionRate: 50,
+  minQueueTime: 10000,
+  protocol: "standard-osu",
+};
+
+export class QueueService {
+  private config: MatchmakingConfig;
+  private matchmakingInterval?: ReturnType<typeof setInterval>;
+
+  constructor(
+    private queueRepo: IQueueRepository,
+    private matchService: MatchService,
+    private eventBus: EventBus,
+    config?: Partial<MatchmakingConfig>
+  ) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  async joinQueue(team: Team, queueType: string): Promise<QueueEntry> {
+    const existing = await this.queueRepo.findByTeamId(team.id);
+    if (existing) {
+      throw new Error(`Team ${team.id} is already in queue`);
+    }
+
+    const entry = createQueueEntry({
+      team,
+      queueType,
+    });
+
+    await this.queueRepo.add(entry);
+    await this.eventBus.publish(QueueEvents.teamJoined(entry));
+
+    return entry;
+  }
+
+  async leaveQueue(teamId: string): Promise<void> {
+    const entry = await this.queueRepo.findByTeamId(teamId);
+    if (!entry) {
+      throw new Error(`Team ${teamId} is not in queue`);
+    }
+
+    await this.queueRepo.remove(teamId);
+    await this.eventBus.publish(QueueEvents.teamLeft(teamId, entry.queueType));
+  }
+
+  async findMatch(queueType: string): Promise<Match | null> {
+    const entries = await this.queueRepo.findByType(queueType);
+    if (entries.length < 2) {
+      return null;
+    }
+
+    const matchPair = this.findBestMatch(entries);
+    if (!matchPair) {
+      return null;
+    }
+
+    const [entry1, entry2] = matchPair;
+
+    await this.queueRepo.remove(entry1.team.id);
+    await this.queueRepo.remove(entry2.team.id);
+
+    const teams = [entry1.team, entry2.team];
+    await this.eventBus.publish(QueueEvents.matchFound(teams, queueType));
+
+    const match = await this.matchService.createMatch(teams, this.config.protocol);
+    await this.matchService.startMatch(match.id);
+
+    return match;
+  }
+
+  async runMatchmaking(): Promise<void> {
+    const queueTypes = new Set<string>();
+    const allEntries = await this.queueRepo.findAll();
+
+    for (const entry of allEntries) {
+      queueTypes.add(entry.queueType);
+    }
+
+    for (const queueType of queueTypes) {
+      await this.findMatch(queueType);
+    }
+  }
+
+  startAutoMatchmaking(intervalMs: number = 5000): void {
+    if (this.matchmakingInterval) {
+      clearInterval(this.matchmakingInterval);
+    }
+    this.matchmakingInterval = setInterval(() => {
+      this.runMatchmaking().catch(console.error);
+    }, intervalMs);
+  }
+
+  stopAutoMatchmaking(): void {
+    if (this.matchmakingInterval) {
+      clearInterval(this.matchmakingInterval);
+      this.matchmakingInterval = undefined;
+    }
+  }
+
+  private findBestMatch(entries: QueueEntry[]): [QueueEntry, QueueEntry] | null {
+    const now = Date.now();
+    let bestPair: [QueueEntry, QueueEntry] | null = null;
+    let bestScore = Infinity;
+
+    for (let i = 0; i < entries.length; i++) {
+      for (let j = i + 1; j < entries.length; j++) {
+        const entry1 = entries[i];
+        const entry2 = entries[j];
+
+        if (!entry1 || !entry2) continue;
+
+        const rating1 = getAverageRating(entry1.team);
+        const rating2 = getAverageRating(entry2.team);
+        const ratingDiff = Math.abs(rating1 - rating2);
+
+        const waitTime1 = now - entry1.joinedAt.getTime();
+        const waitTime2 = now - entry2.joinedAt.getTime();
+        const minWaitTime = Math.min(waitTime1, waitTime2);
+
+        if (minWaitTime < this.config.minQueueTime) {
+          continue;
+        }
+
+        const expansionMultiplier = Math.floor(minWaitTime / this.config.minQueueTime);
+        const maxAllowedDiff =
+          this.config.maxRatingDifference +
+          expansionMultiplier * this.config.ratingExpansionRate;
+
+        if (ratingDiff > maxAllowedDiff) {
+          continue;
+        }
+
+        const score = ratingDiff - minWaitTime / 1000;
+
+        if (score < bestScore) {
+          bestScore = score;
+          bestPair = [entry1, entry2];
+        }
+      }
+    }
+
+    return bestPair;
+  }
+
+  async getQueueStatus(queueType: string): Promise<{
+    count: number;
+    entries: Array<{
+      teamName: string;
+      rating: number;
+      waitTime: number;
+    }>;
+  }> {
+    const entries = await this.queueRepo.findByType(queueType);
+    const now = Date.now();
+
+    return {
+      count: entries.length,
+      entries: entries.map((e) => ({
+        teamName: e.team.name,
+        rating: getAverageRating(e.team),
+        waitTime: now - e.joinedAt.getTime(),
+      })),
+    };
+  }
+}