import type { GeoapifyFeature } from './geoapify-types';

const CACHE_TTL_MS = 30 * 60 * 1000;
const MAX_MEMORY_ENTRIES = 80;
const MAX_SESSION_ENTRIES = 40;
const MIN_REQUEST_INTERVAL_MS = 750;
const SESSION_CACHE_KEY = 'shahi-geoapify-cache';

interface CacheEntry {
  features: GeoapifyFeature[];
  cachedAt: number;
}

const memoryCache = new Map<string, CacheEntry>();
const inFlight = new Map<string, Promise<GeoapifyFeature[]>>();
let lastNetworkRequestAt = 0;
let sessionHydrated = false;

export function buildGeoapifyCacheKey(query: string, lang: string): string {
  return `${lang}:${query.trim().toLowerCase()}`;
}

function isFresh(entry: CacheEntry): boolean {
  return Date.now() - entry.cachedAt < CACHE_TTL_MS;
}

function trimMemoryCache(): void {
  while (memoryCache.size > MAX_MEMORY_ENTRIES) {
    const oldestKey = memoryCache.keys().next().value;
    if (!oldestKey) break;
    memoryCache.delete(oldestKey);
  }
}

function hydrateFromSessionStorage(): void {
  if (sessionHydrated || typeof window === 'undefined') return;
  sessionHydrated = true;

  try {
    const raw = sessionStorage.getItem(SESSION_CACHE_KEY);
    if (!raw) return;

    const parsed = JSON.parse(raw) as Record<string, CacheEntry>;
    for (const [key, entry] of Object.entries(parsed)) {
      if (isFresh(entry)) {
        memoryCache.set(key, entry);
      }
    }
  } catch {
    // Ignore corrupt cache payloads
  }
}

function persistToSessionStorage(): void {
  if (typeof window === 'undefined') return;

  try {
    const payload: Record<string, CacheEntry> = {};
    const entries = [...memoryCache.entries()]
      .filter(([, entry]) => isFresh(entry))
      .slice(-MAX_SESSION_ENTRIES);

    for (const [key, entry] of entries) {
      payload[key] = entry;
    }

    sessionStorage.setItem(SESSION_CACHE_KEY, JSON.stringify(payload));
  } catch {
    // sessionStorage may be full or unavailable
  }
}

export function getCachedGeoapifyFeatures(
  query: string,
  lang: string,
): GeoapifyFeature[] | null {
  hydrateFromSessionStorage();

  const key = buildGeoapifyCacheKey(query, lang);
  const entry = memoryCache.get(key);
  if (!entry || !isFresh(entry)) {
    if (entry) memoryCache.delete(key);
    return null;
  }

  return entry.features;
}

export function setCachedGeoapifyFeatures(
  query: string,
  lang: string,
  features: GeoapifyFeature[],
): void {
  hydrateFromSessionStorage();

  const key = buildGeoapifyCacheKey(query, lang);
  memoryCache.set(key, { features, cachedAt: Date.now() });
  trimMemoryCache();
  persistToSessionStorage();
}

export function getInFlightGeoapifyRequest(
  query: string,
  lang: string,
): Promise<GeoapifyFeature[]> | null {
  return inFlight.get(buildGeoapifyCacheKey(query, lang)) ?? null;
}

export function trackInFlightGeoapifyRequest(
  query: string,
  lang: string,
  request: Promise<GeoapifyFeature[]>,
): Promise<GeoapifyFeature[]> {
  const key = buildGeoapifyCacheKey(query, lang);
  inFlight.set(key, request);
  return request.finally(() => {
    if (inFlight.get(key) === request) {
      inFlight.delete(key);
    }
  });
}

export async function waitForGeoapifyRateLimit(): Promise<void> {
  const elapsed = Date.now() - lastNetworkRequestAt;
  const waitMs = MIN_REQUEST_INTERVAL_MS - elapsed;
  if (waitMs > 0) {
    await new Promise((resolve) => setTimeout(resolve, waitMs));
  }
  lastNetworkRequestAt = Date.now();
}