File size: 17,189 Bytes
1302ebc
 
 
 
 
 
 
 
 
 
ebdbff1
1302ebc
93ae949
1302ebc
93ae949
 
 
 
 
 
 
 
 
67057ab
93ae949
 
 
 
 
 
 
 
 
 
 
 
 
 
3443892
 
1302ebc
 
 
 
 
758be85
 
 
1302ebc
 
ebdbff1
1302ebc
3443892
1302ebc
 
 
 
 
 
 
b3d428e
1302ebc
 
 
 
 
3443892
758be85
 
67057ab
 
 
758be85
1302ebc
 
 
 
 
 
 
76e92fa
 
 
 
 
67057ab
1302ebc
76e92fa
 
 
 
1302ebc
76e92fa
758be85
 
76e92fa
1302ebc
76e92fa
ebdbff1
76e92fa
3443892
76e92fa
1302ebc
 
 
 
93ae949
 
 
 
 
 
 
 
 
 
 
 
 
1302ebc
b3d428e
 
1302ebc
93ae949
1302ebc
93ae949
 
1302ebc
 
 
 
a23faa4
 
1302ebc
 
 
 
 
 
 
 
 
 
 
 
 
 
b3d428e
1302ebc
 
 
 
b3d428e
 
 
 
1302ebc
 
 
 
 
 
 
b3d428e
1302ebc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
93ae949
 
 
 
 
 
 
 
1302ebc
76e92fa
 
 
 
 
 
 
 
 
1302ebc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a23faa4
 
 
 
1302ebc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ebdbff1
76e92fa
ebdbff1
1302ebc
 
 
 
 
 
 
 
 
 
 
76e92fa
1302ebc
 
76e92fa
1302ebc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
76e92fa
1302ebc
 
76e92fa
 
 
 
 
 
 
 
 
 
 
 
1302ebc
 
 
76e92fa
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1302ebc
 
 
 
 
 
 
 
 
 
76e92fa
 
 
 
 
 
 
 
 
 
 
 
 
 
1302ebc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
/**
 * 使用者與個人統計儲存庫。結構比照 `repository.ts`(鬼影):
 *   InMemoryUserRepository(基底)→ UpstashUserRepository(跨重啟保存)/ JsonFileUserRepository(本機檔)。
 *
 * 設計取捨:
 * - **使用者與統計持久化**(Upstash / JSON 檔)——這是「跨裝置」的關鍵。
 * - **session 只存記憶體**(不持久化):重啟後 token 失效、使用者重新 OAuth 登入即可(一鍵、體驗可接受),
 *   換來介面同步、無 Redis session 讀寫成本與過期管理複雜度。統計不受 session 失效影響。
 */
import { randomUUID } from "node:crypto";
import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
import { dirname } from "node:path";
import type { Campaign, ClassType, RunSummary } from "@wcg/battle-core";

export type RunKind = "single" | "pvp" | "pve";
/** 單場紀錄:單人=該場摘要欄位;pvp/pve=勝負+對手/Boss 名(單人專屬欄位省略)。kind 省略=單人(相容舊資料)。 */
export interface RunRecord {
  at: string;
  kind?: RunKind;
  classType: ClassType;
  cleared: boolean;
  campaign?: Campaign;
  hardMode?: boolean;
  extreme?: boolean; // 極難(insane);隱含 hardMode
  reachedStage?: number;
  peakAtk?: number;
  peakDef?: number;
  turns?: number;
  outcome?: "VICTORY" | "GAME_OVER";
  enemyName?: string; // 連線專屬:pvp="對手"、pve=Boss 名
}
/** 連線(pvp/pve)結果輸入(後端無法重播 → 直接採信此結果,只進逐場紀錄與職業計數)。 */
export interface OnlineRunInput {
  kind: "pvp" | "pve";
  classType: ClassType;
  cleared: boolean;
  enemyName: string;
}
const MAX_RUNS = 100;

export interface UserStats {
  plays: number; // 遊玩次數(總場數)
  clears: number; // 過關次數(破完整 campaign)
  peakAtk: number; // 單回合峰值 ATK(跨場取 max)
  peakDef: number; // 單回合峰值 DEF(跨場取 max)
  maxReachedStage: number; // 未過關時到達的最高 Stage(全路線合併;保留相容)
  // 各「敵人×難度」的最高到達 Stage(含破關=到達該路線最終關)。key:`slime`/`slime:hard`/`sanctus`/`sanctus:hard`
  maxStageByMode?: Record<string, number>;
  totalTurns: number; // 生涯總回合數(累加型統計示範)
  classPlays: Partial<Record<ClassType, number>>; // 各職業遊玩場數(動態 key:日後新增職業免改此型別)
  recentClasses: ClassType[]; // 最近 100 場的職業序列(算「前 100 場最常使用職業」用,最新在尾)
  lastPlayedAt?: string; // 最後遊玩時間(後端 now,不信 client 時鐘)
  runs?: RunRecord[]; // 最近 N 場逐場紀錄(舊→新);統計頁點數字可跳出「遊玩紀錄」
}

export interface UserRecord {
  id: string;
  provider: string; // "discord" | "google" | "dev"
  providerUserId: string;
  displayName: string;
  email?: string; // 目前只有 Google 帶;僅供管理員白名單比對,不對外投影
  createdAt: string;
  stats: UserStats;
}

export function emptyStats(): UserStats {
  return { plays: 0, clears: 0, peakAtk: 0, peakDef: 0, maxReachedStage: 0, maxStageByMode: {}, totalTurns: 0, classPlays: {}, recentClasses: [], runs: [] };
}

/** 「敵人×難度」統計 key:normal=campaign 本身;hard=加 :hard;insane(extreme)=加 :extreme。 */
export function stageModeKey(campaign: string, hardMode?: boolean, extreme?: boolean): string {
  if (extreme) return `${campaign}:extreme`;
  return hardMode ? `${campaign}:hard` : campaign;
}

/**
 * 把一場 RunSummary 聚合進既有統計(純函式、冪等於 peak)。
 * 注意:summary 由後端重播產生(權威),此處不再夾值;除錯關卡數的 cleared 修正在 runService 先處理。
 */
export function applyRun(stats: UserStats, s: RunSummary, nowIso: string): UserStats {
  // 舊帳號的 stats 可能缺後來才加的欄位(recentClasses/runs/maxStageByMode…)→ 下方 spread 到 undefined 會拋
  // 「not iterable」讓 /api/me/runs 回 500、戰績永遠記不進去。先用 emptyStats() 補齊缺欄位:修崩潰,
  // 且首次成功聚合後該帳號即被寫成完整結構(自我修復),無須額外資料遷移。
  const prev = { ...emptyStats(), ...stats };
  const prevStage = prev.maxStageByMode ?? {};
  const k = stageModeKey(s.campaign, s.hardMode, s.extreme);
  return {
    plays: prev.plays + 1,
    clears: prev.clears + (s.cleared ? 1 : 0),
    peakAtk: Math.max(prev.peakAtk, s.peakAtk),
    peakDef: Math.max(prev.peakDef, s.peakDef),
    // 「未過關時到達的最高 Stage」:破關場不更新此值(破關走 clears)。
    maxReachedStage: s.cleared ? prev.maxReachedStage : Math.max(prev.maxReachedStage, s.reachedStage),
    // 各敵人×難度的最高 Stage:含破關(reachedStage=最終關),普通/困難分開累積。
    maxStageByMode: { ...prevStage, [k]: Math.max(prevStage[k] ?? 0, s.reachedStage) },
    totalTurns: prev.totalTurns + s.turns,
    // 動態累加:以 classType 為 key 累加 → 日後新增職業不必改這裡(新 key 自動長出來)。
    classPlays: { ...prev.classPlays, [s.classType]: (prev.classPlays[s.classType] ?? 0) + 1 },
    // 最近 100 場職業(環形緩衝,最新在尾)→ 算「前 100 場最常使用職業」。
    recentClasses: [...(prev.recentClasses ?? []), s.classType].slice(-100),
    // 逐場紀錄(含難度/敵人/到達/結果/峰值),只留最近 N 場供「遊玩紀錄」彈窗。
    runs: [...(prev.runs ?? []), { ...s, at: nowIso }].slice(-MAX_RUNS),
    lastPlayedAt: nowIso,
  };
}

/** 把一場連線(pvp/pve)結果聚合進統計:只進逐場紀錄與職業計數,不污染單人關卡/峰值聚合。 */
export function applyOnlineRun(stats: UserStats, o: OnlineRunInput, nowIso: string): UserStats {
  const prev = { ...emptyStats(), ...stats };
  const rec: RunRecord = { at: nowIso, kind: o.kind, classType: o.classType, cleared: o.cleared, enemyName: o.enemyName };
  return {
    ...prev,
    classPlays: { ...prev.classPlays, [o.classType]: (prev.classPlays[o.classType] ?? 0) + 1 },
    recentClasses: [...(prev.recentClasses ?? []), o.classType].slice(-MAX_RUNS),
    runs: [...(prev.runs ?? []), rec].slice(-MAX_RUNS),
    lastPlayedAt: nowIso,
  };
}

export interface UserRepository {
  /** 依 OAuth 身分找既有帳號或建新帳號(並更新顯示名 / email)。 */
  upsertByOAuth(provider: string, providerUserId: string, displayName: string, email?: string): UserRecord;
  getById(id: string): UserRecord | null;
  /** 聚合一場單人結果到該使用者統計,回傳更新後統計;找不到使用者回 null。 */
  updateStats(id: string, summary: RunSummary, nowIso: string): UserStats | null;
  /** 聚合一場連線(pvp/pve)結果;找不到使用者回 null。 */
  updateOnlineStats(id: string, online: OnlineRunInput, nowIso: string): UserStats | null;
  putSession(token: string, userId: string, ttlSec: number, nowMs: number): void;
  getSession(token: string, nowMs: number): string | null;
  deleteSession(token: string): void;
  count(): number;
  /** 列出所有使用者(管理用;Upstash/JSON 版都已把全部載入記憶體快取,故由基底實作即可)。 */
  listAll(): UserRecord[];
}

/** 純記憶體(測試用,亦為基底)。session 一律在此層、不持久化。 */
export class InMemoryUserRepository implements UserRepository {
  protected byId = new Map<string, UserRecord>();
  protected oauthIndex = new Map<string, string>(); // `${provider}:${providerUserId}` → userId
  private sessions = new Map<string, { userId: string; exp: number }>();

  static readonly MAX_SESSIONS = 50000; // 防無界成長

  private oauthKey(provider: string, providerUserId: string): string {
    return `${provider}:${providerUserId}`;
  }

  upsertByOAuth(provider: string, providerUserId: string, displayName: string, email?: string): UserRecord {
    const key = this.oauthKey(provider, providerUserId);
    const existingId = this.oauthIndex.get(key);
    if (existingId) {
      const rec = this.byId.get(existingId)!;
      let changed = false;
      if (displayName && rec.displayName !== displayName) { rec.displayName = displayName; changed = true; }
      if (email && rec.email !== email) { rec.email = email; changed = true; }
      if (changed) this.persistUser(rec, false);
      return rec;
    }
    const rec: UserRecord = {
      id: randomUUID(),
      provider,
      providerUserId,
      displayName: displayName || `${provider}-user`,
      email,
      createdAt: new Date().toISOString(),
      stats: emptyStats(),
    };
    this.byId.set(rec.id, rec);
    this.oauthIndex.set(key, rec.id);
    this.persistUser(rec, true);
    return rec;
  }

  getById(id: string): UserRecord | null {
    return this.byId.get(id) ?? null;
  }

  updateStats(id: string, summary: RunSummary, nowIso: string): UserStats | null {
    const rec = this.byId.get(id);
    if (!rec) return null;
    rec.stats = applyRun(rec.stats, summary, nowIso); // 讀-改-寫,單實例同步完成 → 無覆寫競態
    this.persistUser(rec, false);
    return rec.stats;
  }

  updateOnlineStats(id: string, online: OnlineRunInput, nowIso: string): UserStats | null {
    const rec = this.byId.get(id);
    if (!rec) return null;
    rec.stats = applyOnlineRun(rec.stats, online, nowIso);
    this.persistUser(rec, false);
    return rec.stats;
  }

  putSession(token: string, userId: string, ttlSec: number, nowMs: number): void {
    // 達上限不再整批 clear()(會讓所有在線 token 同時失效):先回收過期死 session,仍滿才用插入序砍最舊一批。
    if (this.sessions.size >= InMemoryUserRepository.MAX_SESSIONS) {
      for (const [t, s] of this.sessions) if (s.exp <= nowMs) this.sessions.delete(t); // 回收死 session
      if (this.sessions.size >= InMemoryUserRepository.MAX_SESSIONS) {
        const drop = Math.ceil(InMemoryUserRepository.MAX_SESSIONS * 0.1); // Map 天然 FIFO → 砍最舊 10%
        let i = 0;
        for (const t of this.sessions.keys()) { if (i++ >= drop) break; this.sessions.delete(t); }
      }
    }
    this.sessions.set(token, { userId, exp: nowMs + ttlSec * 1000 });
  }

  getSession(token: string, nowMs: number): string | null {
    const s = this.sessions.get(token);
    if (!s) return null;
    if (s.exp <= nowMs) { this.sessions.delete(token); return null; } // 過期 lazy 清除
    return s.userId;
  }

  deleteSession(token: string): void {
    this.sessions.delete(token);
  }

  count(): number {
    return this.byId.size;
  }

  listAll(): UserRecord[] {
    return [...this.byId.values()];
  }

  /** 持久化單一使用者。記憶體版不做事;isNew 供子類決定是否一併寫索引。 */
  protected persistUser(_rec: UserRecord, _isNew: boolean): void {
    /* 記憶體版不持久化 */
  }
}

/** JSON 檔持久化版(本機)。每次變更寫整份使用者清單(量小、夠用)。 */
export class JsonFileUserRepository extends InMemoryUserRepository {
  private file: string;

  constructor(file: string) {
    super();
    this.file = file;
    if (existsSync(file)) {
      try {
        const parsed = JSON.parse(readFileSync(file, "utf8")) as UserRecord[];
        if (Array.isArray(parsed)) {
          for (const rec of parsed) {
            if (rec && typeof rec.id === "string") {
              this.byId.set(rec.id, rec);
              this.oauthIndex.set(`${rec.provider}:${rec.providerUserId}`, rec.id);
            }
          }
        }
      } catch {
        /* 壞檔則以空起始 */
      }
    }
  }

  protected override persistUser(_rec: UserRecord, _isNew: boolean): void {
    mkdirSync(dirname(this.file), { recursive: true });
    const tmp = `${this.file}.tmp`;
    writeFileSync(tmp, JSON.stringify([...this.byId.values()]), "utf8"); // 緊湊序列化(去 pretty)
    renameSync(tmp, this.file); // 原子置換:避免崩潰留下半截檔讓整份使用者資料毀損
  }
}

/**
 * Upstash Redis(REST)持久化版。比照 UpstashGhostRepository:開機 load() 載入記憶體快取,
 * 之後讀走同步介面;變更同步更新快取後「背景」寫回(失敗只記錄)。
 */
export class UpstashUserRepository extends InMemoryUserRepository {
  private url: string;
  private token: string;
  private static readonly IDS_KEY = "wcg:user_ids";
  private static readonly SESSION_PREFIX = "wcg:session:";
  private userKey(id: string): string { return `wcg:user:${id}`; }
  private oauthRedisKey(provider: string, providerUserId: string): string { return `wcg:oauth:${provider}:${providerUserId}`; }
  private sessionKey(token: string): string { return `${UpstashUserRepository.SESSION_PREFIX}${token}`; }

  constructor(url: string, token: string) {
    super();
    this.url = url.trim().replace(/\/+$/, "");
    this.token = token.trim();
  }

  private async redis(cmd: string[]): Promise<unknown> {
    const res = await fetch(this.url, {
      method: "POST",
      headers: { Authorization: `Bearer ${this.token}`, "Content-Type": "application/json" },
      body: JSON.stringify(cmd),
    });
    if (!res.ok) throw new Error(`upstash HTTP ${res.status}`);
    const json = (await res.json()) as { result?: unknown; error?: string };
    if (json.error) throw new Error(json.error);
    return json.result;
  }

  private async pipeline(cmds: string[][]): Promise<void> {
    const res = await fetch(`${this.url}/pipeline`, {
      method: "POST",
      headers: { Authorization: `Bearer ${this.token}`, "Content-Type": "application/json" },
      body: JSON.stringify(cmds),
    });
    if (!res.ok) throw new Error(`upstash HTTP ${res.status}`);
    const arr = (await res.json()) as { result?: unknown; error?: string }[];
    for (const j of arr) if (j.error) throw new Error(j.error);
  }

  /** 開機載入:把 Upstash 內使用者與未過期 session 載入記憶體快取。 */
  async load(): Promise<void> {
    const ids = (await this.redis(["LRANGE", UpstashUserRepository.IDS_KEY, "0", "-1"])) as string[] | null;
    if (ids && ids.length > 0) {
      const vals = (await this.redis(["MGET", ...ids.map((id) => this.userKey(id))])) as (string | null)[];
      for (const v of vals) {
        if (!v) continue;
        try {
          const rec = JSON.parse(v) as UserRecord;
          if (rec && typeof rec.id === "string") {
            this.byId.set(rec.id, rec);
            this.oauthIndex.set(`${rec.provider}:${rec.providerUserId}`, rec.id);
          }
        } catch {
          /* 略過壞資料 */
        }
      }
    }
    await this.loadSessions();
  }

  /** 載入未過期 session 到記憶體快取(SCAN 自清:已過 Redis TTL 的 key 不會出現 → 重啟後登入狀態仍在)。 */
  private async loadSessions(): Promise<void> {
    const now = Date.now();
    let cursor = "0";
    do {
      const reply = (await this.redis(["SCAN", cursor, "MATCH", `${UpstashUserRepository.SESSION_PREFIX}*`, "COUNT", "300"])) as [string, string[]];
      cursor = reply?.[0] ?? "0";
      const keys = reply?.[1] ?? [];
      if (keys.length > 0) {
        const vals = (await this.redis(["MGET", ...keys])) as (string | null)[];
        for (let i = 0; i < keys.length; i++) {
          const v = vals[i];
          if (!v) continue;
          try {
            const { userId, exp } = JSON.parse(v) as { userId: string; exp: number };
            const ttlSec = Math.ceil((exp - now) / 1000);
            if (userId && ttlSec > 0) super.putSession(keys[i]!.slice(UpstashUserRepository.SESSION_PREFIX.length), userId, ttlSec, now);
          } catch {
            /* 略過壞資料 */
          }
        }
      }
    } while (cursor !== "0");
  }

  protected override persistUser(rec: UserRecord, isNew: boolean): void {
    const cmds: string[][] = [["SET", this.userKey(rec.id), JSON.stringify(rec)]];
    if (isNew) {
      cmds.push(["SET", this.oauthRedisKey(rec.provider, rec.providerUserId), rec.id]);
      cmds.push(["RPUSH", UpstashUserRepository.IDS_KEY, rec.id]);
    }
    void this.pipeline(cmds).catch((e) => console.error("[users] Upstash 持久化失敗:", e));
  }

  // session 也持久化到 Redis(帶原生 TTL)→ 容器休眠/重啟後登入狀態仍在,不會把使用者打成遊客。
  // 記憶體快取(基底 Map)仍是同步讀的唯一來源;Redis 僅供重啟後由 loadSessions() 還原。
  override putSession(token: string, userId: string, ttlSec: number, nowMs: number): void {
    super.putSession(token, userId, ttlSec, nowMs);
    const ttl = Math.max(1, Math.ceil(ttlSec));
    const val = JSON.stringify({ userId, exp: nowMs + ttl * 1000 });
    void this.redis(["SET", this.sessionKey(token), val, "EX", String(ttl)]).catch((e) => console.error("[session] Upstash 寫入失敗:", e));
  }

  override deleteSession(token: string): void {
    super.deleteSession(token);
    void this.redis(["DEL", this.sessionKey(token)]).catch((e) => console.error("[session] Upstash 刪除失敗:", e));
  }
}