import type { SessionAdapter, SessionData } from "../types.ts";

export class MemoryAdapter implements SessionAdapter {
  private sessions = new Map<string, SessionData>();

  get(sessionId: string): Promise<SessionData | null> {
    return Promise.resolve(this.sessions.get(sessionId) ?? null);
  }

  set(sessionId: string, data: SessionData): Promise<void> {
    this.sessions.set(sessionId, data);
    return Promise.resolve();
  }

  update(sessionId: string, updates: Partial<SessionData>): Promise<boolean> {
    const existing = this.sessions.get(sessionId);
    if (!existing) return Promise.resolve(false);

    this.sessions.set(sessionId, { ...existing, ...updates });
    return Promise.resolve(true);
  }

  delete(sessionId: string): Promise<void> {
    this.sessions.delete(sessionId);
    return Promise.resolve();
  }

  cleanup(expiresBeforeMs: number): Promise<number> {
    let cleanedCount = 0;
    
    for (const [sessionId, data] of this.sessions.entries()) {
      if (data.expiresAt < expiresBeforeMs) {
        this.sessions.delete(sessionId);
        cleanedCount++;
      }
    }
    
    return Promise.resolve(cleanedCount);
  }

  exists(sessionId: string): Promise<boolean> {
    return Promise.resolve(this.sessions.has(sessionId));
  }

  // Memory-specific methods
  clear(): void {
    this.sessions.clear();
  }

  size(): number {
    return this.sessions.size;
  }

  keys(): string[] {
    return Array.from(this.sessions.keys());
  }
}