type KeyType = string | symbol | number;

type CacheEntry<Value> = {
  value: Value;
  expiresAt: number;
};

export class TempCache<OuterKey extends KeyType, InnerKey = any, Value = any> {
  private cache: Map<OuterKey, Map<InnerKey, CacheEntry<Value>>>;
  private TTL: number;

  constructor(ttlMilliseconds: number = 60000) {
    this.cache = new Map();
    this.TTL = ttlMilliseconds; // default 1 minute TTL
  }

  set(outerKey: OuterKey, innerKey: InnerKey, value: Value): void {
    const expiresAt = Date.now() + this.TTL;
    if (!this.cache.has(outerKey)) {
      this.cache.set(outerKey, new Map());
    }
    this.cache.get(outerKey)!.set(innerKey, { value, expiresAt });
  }

  get(outerKey: OuterKey, innerKey: InnerKey): Value | undefined {
    const innerMap = this.cache.get(outerKey);
    if (!innerMap) return undefined;

    const entry = innerMap.get(innerKey);
    if (!entry) return undefined;

    if (Date.now() > entry.expiresAt) {
      // expired, delete it
      innerMap.delete(innerKey);
      if (innerMap.size === 0) {
        this.cache.delete(outerKey);
      }
      return undefined;
    }

    return entry.value;
  }

  has(outerKey: OuterKey, innerKey: InnerKey): boolean {
    const innerMap = this.cache.get(outerKey);
    if (!innerMap) return false;

    const entry = innerMap.get(innerKey);
    if (!entry) return false;

    if (Date.now() > entry.expiresAt) {
      // expired, delete it
      innerMap.delete(innerKey);
      if (innerMap.size === 0) {
        this.cache.delete(outerKey);
      }
      return false;
    }

    return true;
  }

  delete(outerKey: OuterKey, innerKey: InnerKey): boolean {
    const innerMap = this.cache.get(outerKey);
    if (!innerMap) return false;
    const deleted = innerMap.delete(innerKey);
    if (innerMap.size === 0) {
      this.cache.delete(outerKey);
    }
    return deleted;
  }

  deleteOuterKey(outerKey: OuterKey): boolean {
    return this.cache.delete(outerKey);
  }

  clear(): void {
    this.cache.clear();
  }

  outerKeys(): IterableIterator<OuterKey> {
    return this.cache.keys();
  }

  innerKeys(outerKey: OuterKey): IterableIterator<InnerKey> | undefined {
    return this.cache.get(outerKey)?.keys();
  }

  getInnerMap(outerKey: OuterKey): Map<InnerKey, Value> | undefined {
    const innerMap = this.cache.get(outerKey);
    if (!innerMap) return undefined;

    // Filter out expired entries:
    const now = Date.now();
    const result = new Map<InnerKey, Value>();
    for (const [key, entry] of innerMap.entries()) {
      if (now <= entry.expiresAt) {
        result.set(key, entry.value);
      } else {
        // Remove expired entry
        innerMap.delete(key);
      }
    }

    if (innerMap.size === 0) {
      this.cache.delete(outerKey);
    }

    return result.size > 0 ? result : undefined;
  }

  getInnerObject(outerKey: OuterKey): Record<string, Value> | undefined {
    const innerMap = this.getInnerMap(outerKey);
    if (!innerMap) return undefined;

    const obj: Record<string, Value> = {};
    for (const [key, value] of innerMap.entries()) {
      obj[String(key)] = value;
    }

    return obj;
  }
}