import { EnvironmentId } from "@t3tools/contracts";
import { mediaMimeType } from "@t3tools/shared/filePreview";
import {
  getProjectFaviconCacheKey,
  getProjectFaviconResourceKey,
  isProjectFaviconFallbackUrl,
} from "@t3tools/shared/projectFavicon";
import * as Encoding from "effect/Encoding";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";

export const PROJECT_FAVICON_THUMBNAIL_SIZE = 96;
export const PROJECT_FAVICON_MAX_DATA_URL_LENGTH = 32 * 1024;
/** Larger sources are not worth decoding for an icon and are left to the remote URL. */
export const PROJECT_FAVICON_MAX_SOURCE_BYTES = 4 * 1024 * 1024;
export const PROJECT_FAVICON_CACHE_MAX_BYTES = 1024 * 1024;
export const PROJECT_FAVICON_CACHE_MAX_ENTRIES = 128;

export interface ProjectFaviconTarget {
  readonly environmentId: EnvironmentId;
  readonly cwd: string;
  readonly faviconPath?: string | null | undefined;
}

const ImageDataUrl = Schema.String.check(
  Schema.isMaxLength(PROJECT_FAVICON_MAX_DATA_URL_LENGTH),
  Schema.isPattern(
    /^data:image\/(?:png|jpeg|gif|webp|avif|svg\+xml|x-icon|vnd\.microsoft\.icon);base64,[A-Za-z0-9+/]+={0,2}$/,
  ),
);
const Entry = Schema.Struct({
  environmentId: EnvironmentId,
  cwd: Schema.String,
  faviconPath: Schema.NullOr(Schema.String),
  revision: Schema.String,
  dataUrl: ImageDataUrl,
});
export type ProjectFaviconEntry = typeof Entry.Type;
const decodeEntry = Schema.decodeUnknownOption(Entry);
const isImageDataUrl = Schema.is(ImageDataUrl);

function keyFor(target: ProjectFaviconTarget) {
  return getProjectFaviconResourceKey(target.environmentId, target.cwd, target.faviconPath);
}

export interface ProjectFaviconStorage {
  /** Every persisted record; entries that fail validation are ignored. */
  readonly list: () => Promise<ReadonlyArray<unknown>>;
  readonly put: (key: string, entry: ProjectFaviconEntry) => Promise<void>;
  readonly remove: (key: string, entry: ProjectFaviconEntry) => Promise<void>;
}

async function readBounded(response: Response, maxBytes: number) {
  const declared = Number(response.headers.get("content-length"));
  if (declared > maxBytes) throw new Error("Project icon is too large to decode.");
  if (!response.body) {
    const bytes = new Uint8Array<ArrayBuffer>(await response.arrayBuffer());
    if (bytes.byteLength > maxBytes) throw new Error("Project icon is too large to decode.");
    return bytes;
  }
  const reader = response.body.getReader();
  const chunks: Array<Uint8Array> = [];
  let total = 0;
  try {
    for (;;) {
      const { done, value } = await reader.read();
      if (done) break;
      total += value.byteLength;
      if (total > maxBytes) throw new Error("Project icon is too large to decode.");
      chunks.push(value);
    }
  } finally {
    reader.cancel().catch(() => {});
  }
  const bytes = new Uint8Array<ArrayBuffer>(new ArrayBuffer(total));
  let offset = 0;
  for (const chunk of chunks) {
    bytes.set(chunk, offset);
    offset += chunk.byteLength;
  }
  return bytes;
}

/**
 * Fetches an icon and inlines its bytes when they fit the cache limit, so SVGs
 * and small bitmaps are stored exactly as served. Larger bitmaps go through the
 * platform downscaler; larger SVGs stay remote because rasterizing them without
 * intrinsic dimensions is unreliable.
 */
export function createProjectFaviconImageLoader(input: {
  readonly fetch?: typeof fetch;
  readonly downscale: (
    image: {
      readonly url: string;
      readonly mimeType: string;
      readonly bytes: Uint8Array<ArrayBuffer>;
    },
    signal: AbortSignal,
  ) => Promise<string>;
}) {
  const fetchImpl = input.fetch ?? globalThis.fetch;
  return async (url: string, signal: AbortSignal): Promise<string> => {
    const response = await fetchImpl(url, { signal });
    if (!response.ok) throw new Error(`Project icon request failed with ${response.status}.`);
    const contentType = response.headers
      .get("content-type")
      ?.split(";", 1)[0]
      ?.trim()
      .toLowerCase();
    const mimeType = contentType?.startsWith("image/") ? contentType : mediaMimeType(url);
    if (!mimeType) throw new Error("Project icon has no image type.");
    const bytes = await readBounded(response, PROJECT_FAVICON_MAX_SOURCE_BYTES);
    signal.throwIfAborted();
    const dataUrl = `data:${mimeType};base64,${Encoding.encodeBase64(bytes)}`;
    if (isImageDataUrl(dataUrl)) return dataUrl;
    if (mimeType === "image/svg+xml") throw new Error("Project icon exceeds the cache limit.");
    return input.downscale({ url, mimeType, bytes }, signal);
  };
}

/** Stores small, self-contained images so startup never needs an old signed URL. */
export function createProjectFaviconCache(input: {
  readonly storage: ProjectFaviconStorage;
  readonly load: (url: string, signal: AbortSignal) => Promise<string>;
}) {
  const entries = new Map<string, ProjectFaviconEntry>();
  const environmentRevisions = new Map<EnvironmentId, number>();
  let generation = 0;
  let hydration: Promise<void> | undefined;
  let clearing: Promise<void> | undefined;
  const pending = new Set<Promise<void>>();

  const persist = (operation: () => Promise<void>) => {
    const task: Promise<void> = operation()
      .catch(() => {
        // Keep the in-memory image if local storage is full or unavailable.
      })
      .finally(() => pending.delete(task));
    pending.add(task);
  };

  const remove = (key: string) => {
    const entry = entries.get(key);
    if (!entry) return;
    entries.delete(key);
    persist(() => input.storage.remove(key, entry));
  };

  const trim = () => {
    let bytes = 0;
    for (const entry of entries.values()) bytes += entry.dataUrl.length;
    while (
      entries.size > PROJECT_FAVICON_CACHE_MAX_ENTRIES ||
      bytes > PROJECT_FAVICON_CACHE_MAX_BYTES
    ) {
      const oldest = entries.entries().next().value;
      if (!oldest) break;
      bytes -= oldest[1].dataUrl.length;
      remove(oldest[0]);
    }
  };

  const hydrate = () =>
    (hydration ??= (async () => {
      try {
        for (const record of await input.storage.list()) {
          const entry = decodeEntry(record);
          if (Option.isSome(entry)) entries.set(keyFor(entry.value), entry.value);
        }
        trim();
      } catch {
        // A missing, corrupt, or unavailable cache must not prevent startup.
      }
    })());

  const peek = (target: ProjectFaviconTarget) => entries.get(keyFor(target))?.dataUrl ?? null;

  const resolve = async (
    target: ProjectFaviconTarget,
    url: string | null,
    signal: AbortSignal,
  ): Promise<string | null> => {
    await clearing;
    const startGeneration = generation;
    const startRevision = environmentRevisions.get(target.environmentId) ?? 0;
    await hydrate();
    if (signal.aborted || url === null) return peek(target);
    const key = keyFor(target);
    if (isProjectFaviconFallbackUrl(url)) {
      remove(key);
      return null;
    }
    const revision = getProjectFaviconCacheKey(target.environmentId, target.cwd, url);
    const cached = entries.get(key);
    if (cached) {
      entries.delete(key);
      entries.set(key, cached);
      if (cached.revision === revision) return cached.dataUrl;
    }
    try {
      const dataUrl = await input.load(url, signal);
      if (
        signal.aborted ||
        startGeneration !== generation ||
        startRevision !== (environmentRevisions.get(target.environmentId) ?? 0)
      ) {
        return peek(target);
      }
      if (isImageDataUrl(dataUrl)) {
        const entry = {
          environmentId: target.environmentId,
          cwd: target.cwd,
          faviconPath: target.faviconPath || null,
          revision,
          dataUrl,
        };
        entries.set(key, entry);
        persist(() => input.storage.put(key, entry));
        trim();
        return dataUrl;
      }
    } catch {
      // An outage or failed decode leaves the last successful image visible.
    }
    return peek(target) ?? url;
  };

  const flush = async () => {
    await Promise.all(pending);
  };

  // A download that started before the clear sees the revision change and is discarded;
  // one that starts during the clear waits for it, so it cannot repopulate storage.
  const clear = async (environmentId?: EnvironmentId) => {
    if (environmentId === undefined) generation += 1;
    else
      environmentRevisions.set(environmentId, (environmentRevisions.get(environmentId) ?? 0) + 1);
    const previous = clearing;
    const task = (async () => {
      await previous;
      await hydrate();
      for (const [key, entry] of entries) {
        if (environmentId === undefined || entry.environmentId === environmentId) remove(key);
      }
      await flush();
    })().finally(() => {
      if (clearing === task) clearing = undefined;
    });
    clearing = task;
    await task;
  };

  return {
    hydrate,
    peek,
    resolve,
    clearEnvironment: (environmentId: EnvironmentId) => clear(environmentId),
    clearAll: () => clear(),
    flush,
  };
}

export type ProjectFaviconCache = ReturnType<typeof createProjectFaviconCache>;