/**
 * @file createChunkListAutomat.js
 * @description Factory function for company-scoped, chunk-cached double-buffered
 * list automats with LRU memory caching, debounced prefetching, and multi-filter
 * retention (like `orderAutomat` and `quoteAutomat`).
 *
 * Upstream Triggers:
 * - `authAutomat`: Subscribes each created automat to auth state — resets on `'anon'`
 *   or when `selectedCompanyId` changes.
 * - Consumer UI (e.g. `FillSpace`): Calls `getItems()` and `requireChunk(start, end)`.
 */

import { Automat } from 'react-automat';
import authAutomat from './authAutomat';

export const DEFAULT_CHUNK_SIZE = 50;
export const DEFAULT_MAX_LRU_CHUNKS = 50;
const PREFETCH_CHUNKS = 1;
const CHUNK_DEBOUNCE_MS = 130;
const MAX_CHUNK_EVENTS = 150;

export function formatNegativeSeek(months) {
  if (!months || months >= 0) return '';
  const total = Math.abs(months);
  const years = Math.floor(total / 12);
  const remMonths = total % 12;
  const parts = [];
  if (years > 0) {
    parts.push(`${years} ${years === 1 ? 'Jahr' : 'Jahre'}`);
  }
  if (remMonths > 0) {
    parts.push(`${remMonths} ${remMonths === 1 ? 'Monat' : 'Monate'}`);
  }
  return `-${parts.join(' ')}`;
}

/**
 * Creates a chunk-paginated, double-buffered automat.
 *
 * @param {object} options
 * @param {string} options.name Name for the Automat instance.
 * @param {(params: { offset: number, limit: number, search?: string, seekMonths?: number }) => Promise<{ items?: any[], history?: any[], rows?: any[], entries?: any[], total?: number, unfilteredTotal?: number }>} options.fetchPage
 * @param {number} [options.chunkSize=50]
 * @param {number} [options.maxLruChunks=50]
 * @returns {Automat} Configured chunk-list automat.
 */
export function createChunkListAutomat({
  name,
  fetchPage,
  chunkSize = DEFAULT_CHUNK_SIZE,
  maxLruChunks = DEFAULT_MAX_LRU_CHUNKS,
}) {
  const initialState = {
    items: null,
    total: 0,
    unfilteredTotal: 0,
    filter: '',
    seekMonths: 0,
    seekYears: 0,
    negativeSeekMonths: 0,
    status: 'idle',
    error: null,
  };

  let automat;
  let queryEpoch = 0;
  let filterDebounceTimer = null;
  let chunkDebounceTimer = null;
  let currentEventTick = 0;
  let lastRequireChunkTick = -1;

  const pendingTargetChunks = new Set();
  let pendingChunkPromise = null;
  let pendingChunkResolve = null;
  let pendingChunkReject = null;

  // Multi-Filter Cache & Global LRU Management
  const filterCaches = new Map();
  const lruChunks = new Map();
  const inflightChunks = new Map();

  // Observability & Stats
  let nextEventId = 0;
  const chunkEvents = [];
  const chunkStatsListeners = new Set();

  function makeLruKey(filterKey, chunkIndex) {
    return `${filterKey}:::${chunkIndex}`;
  }

  function parseLruKey(key) {
    const [filterKey, chunkStr] = key.split(':::');
    return { filterKey, chunkIndex: Number(chunkStr) };
  }

  function getFilterParams(state = automat?.state || initialState) {
    const filter = String(state.filter ?? '').trim();
    const negativeSeekMonths =
      state.negativeSeekMonths != null && Number(state.negativeSeekMonths) < 0
        ? Number(state.negativeSeekMonths)
        : 0;
    return { filter, negativeSeekMonths };
  }

  function getFilterKey(state = automat?.state || initialState) {
    const { filter, negativeSeekMonths } = getFilterParams(state);
    return JSON.stringify({ f: filter, s: negativeSeekMonths });
  }

  function formatFilterLabel(filterKeyOrState) {
    let f, s;
    if (typeof filterKeyOrState === 'string') {
      try {
        const parsed = JSON.parse(filterKeyOrState);
        f = parsed.f;
        s = parsed.s;
      } catch {
        return filterKeyOrState;
      }
    } else if (filterKeyOrState && typeof filterKeyOrState === 'object') {
      if ('f' in filterKeyOrState) {
        f = filterKeyOrState.f;
        s = filterKeyOrState.s;
      } else {
        const params = getFilterParams(filterKeyOrState);
        f = params.filter;
        s = params.negativeSeekMonths;
      }
    }

    const parts = [];
    if (f) parts.push(`Suche: „${f}“`);
    if (s < 0) parts.push(`Seek: ${formatNegativeSeek(s)}`);
    if (parts.length === 0) return 'Standard (Alle Einträge)';
    return parts.join(' · ');
  }

  function countNonNullItems(items) {
    if (!Array.isArray(items)) return 0;
    let count = 0;
    for (let i = 0; i < items.length; i++) {
      if (items[i] != null) count++;
    }
    return count;
  }

  function getOrCreateFilterCache(filterKey, filterState = automat?.state || initialState) {
    let entry = filterCaches.get(filterKey);
    if (!entry) {
      const params = getFilterParams(filterState);
      entry = {
        key: filterKey,
        label: formatFilterLabel(params),
        params,
        total: 0,
        unfilteredTotal: automat?.state?.unfilteredTotal || 0,
        items: null,
        loadedChunks: new Set(),
        status: 'idle',
        error: null,
        lastAccessed: Date.now(),
        epoch: queryEpoch,
      };
      filterCaches.set(filterKey, entry);
    }
    return entry;
  }

  function touchChunkLRU(filterKey, chunkIndex) {
    const key = makeLruKey(filterKey, chunkIndex);
    const existing = lruChunks.get(key);
    if (existing) {
      lruChunks.delete(key);
      lruChunks.set(key, { ...existing, accessedAt: Date.now() });
    }
  }

  function registerChunkLRU(filterKey, chunkIndex, itemCount = 0) {
    const key = makeLruKey(filterKey, chunkIndex);
    if (lruChunks.has(key)) {
      lruChunks.delete(key);
    }
    const now = Date.now();
    lruChunks.set(key, {
      filterKey,
      chunkIndex,
      loadedAt: now,
      accessedAt: now,
      itemCount,
    });

    while (lruChunks.size > maxLruChunks) {
      const oldestKey = lruChunks.keys().next().value;
      const oldestInfo = lruChunks.get(oldestKey);
      lruChunks.delete(oldestKey);
      if (oldestInfo) {
        evictChunkFromMemory(oldestInfo.filterKey, oldestInfo.chunkIndex, 'lru');
      }
    }
  }

  function evictChunkFromMemory(filterKey, chunkIndex, reason = 'manual') {
    const entry = filterCaches.get(filterKey);
    if (!entry) return;

    if (entry.loadedChunks.has(chunkIndex)) {
      entry.loadedChunks.delete(chunkIndex);
      if (Array.isArray(entry.items)) {
        const offset = chunkIndex * chunkSize;
        for (let i = offset; i < offset + chunkSize && i < entry.items.length; i++) {
          entry.items[i] = null;
        }
      }

      const currentKey = getFilterKey(automat.state);
      if (filterKey === currentKey) {
        automat.setState({ items: [...entry.items] });
      }

      recordChunkEvent({
        type: reason === 'lru' ? 'lru_evict' : 'evict',
        chunkIndex,
        filterKey,
        message:
          reason === 'lru'
            ? `LRU-Eviction: Chunk #${chunkIndex} von Filter "${entry.label}" verworfen`
            : `Chunk #${chunkIndex} von Filter "${entry.label}" verworfen`,
      });
      notifyChunkStats();
    }
  }

  function recordChunkEvent(entry) {
    const event = {
      id: ++nextEventId,
      time: Date.now(),
      epoch: queryEpoch,
      filterKey: entry.filterKey ?? getFilterKey(automat?.state),
      ...entry,
    };
    chunkEvents.push(event);
    if (chunkEvents.length > MAX_CHUNK_EVENTS) {
      chunkEvents.shift();
    }
    notifyChunkStats();
  }

  function notifyChunkStats() {
    if (chunkStatsListeners.size === 0) return;
    const stats = getChunkStats();
    for (const listener of chunkStatsListeners) {
      try {
        listener(stats);
      } catch (e) {
        console.error(`[${name}] chunkStatsListener error`, e);
      }
    }
  }

  function getChunkStats() {
    const currentKey = getFilterKey(automat?.state);
    const activeEntry = filterCaches.get(currentKey);

    const total = activeEntry?.total ?? automat?.state?.total ?? 0;
    const activeLoaded = activeEntry?.loadedChunks ?? new Set();
    const count = total > 0 ? Math.ceil(total / chunkSize) : 0;

    const activeInflight = [];
    for (const key of inflightChunks.keys()) {
      const info = parseLruKey(key);
      if (info.filterKey === currentKey) {
        activeInflight.push(info.chunkIndex);
      }
    }

    const items = activeEntry?.items ?? automat?.state?.items ?? null;
    const loadedItemsCount = countNonNullItems(items);

    return {
      chunkSize,
      maxLruChunks,
      lruChunksCount: lruChunks.size,
      total,
      unfilteredTotal: activeEntry?.unfilteredTotal ?? automat?.state?.unfilteredTotal ?? total,
      chunkCount: count,
      loadedChunks: Array.from(activeLoaded).sort((a, b) => a - b),
      inflightChunks: activeInflight.sort((a, b) => a - b),
      pendingChunks: Array.from(pendingTargetChunks).sort((a, b) => a - b),
      loadedItemsCount,
      status: automat?.state?.status ?? 'idle',
      queryEpoch,
      filter: automat?.state?.filter ?? '',
      negativeSeekMonths: automat?.state?.negativeSeekMonths ?? 0,
      items,
      activeFilterKey: currentKey,
      activeFilterLabel: formatFilterLabel(currentKey),
      events: [...chunkEvents],
    };
  }

  function subscribeChunkStats(listener) {
    chunkStatsListeners.add(listener);
    try {
      listener(getChunkStats());
    } catch (e) {
      console.error(e);
    }
    return () => {
      chunkStatsListeners.delete(listener);
    };
  }

  function clearChunkDebounce() {
    if (chunkDebounceTimer) {
      clearTimeout(chunkDebounceTimer);
      chunkDebounceTimer = null;
    }
    if (pendingTargetChunks.size > 0) {
      pendingTargetChunks.clear();
      notifyChunkStats();
    }
    pendingChunkPromise = null;
    pendingChunkResolve = null;
    pendingChunkReject = null;
  }

  function _executeRequiredChunks(
    chunks,
    targetEpoch,
    prefetch = true,
    targetFilterKey = getFilterKey(automat.state)
  ) {
    if (targetEpoch !== queryEpoch) {
      return Promise.resolve(automat.state.items);
    }

    const chunkList = Array.from(chunks).sort((a, b) => a - b);
    if (chunkList.length === 0) {
      return Promise.resolve(automat.state.items);
    }

    recordChunkEvent({
      type: 'execute',
      chunks: chunkList,
      filterKey: targetFilterKey,
      message: `Lade Chunks [${chunkList.join(', ')}] für "${formatFilterLabel(targetFilterKey)}" (Epoch ${targetEpoch})`,
    });

    const promises = [];
    for (const c of chunkList) {
      promises.push(actions.loadChunk(c, targetEpoch, targetFilterKey));
    }

    return Promise.all(promises).then(() => {
      if (targetEpoch !== queryEpoch) return automat.state.items;
      if (prefetch) {
        const maxChunk = chunkList[chunkList.length - 1];
        const entry = filterCaches.get(targetFilterKey);
        const total = entry?.total || automat.state.total || 0;
        for (let c = maxChunk + 1; c <= maxChunk + PREFETCH_CHUNKS; c++) {
          if (total > 0 && c * chunkSize >= total) {
            break;
          }
          recordChunkEvent({
            type: 'prefetch',
            chunkIndex: c,
            filterKey: targetFilterKey,
            message: `Prefetch Chunk #${c} für "${formatFilterLabel(targetFilterKey)}"`,
          });
          void actions.loadChunk(c, targetEpoch, targetFilterKey);
        }
      }
      return automat.state.items;
    });
  }

  function buildQueryParamsFor(filterParams, offset = 0, limit = chunkSize) {
    const params = { offset, limit };
    const trimmed = String(filterParams.filter ?? '').trim();
    if (trimmed) params.search = trimmed;
    if (filterParams.negativeSeekMonths != null && Number(filterParams.negativeSeekMonths) < 0) {
      params.seekMonths = Number(filterParams.negativeSeekMonths);
    }
    return params;
  }

  async function fetchRecordsPageFor(filterParams, offset = 0, limit = chunkSize) {
    const params = buildQueryParamsFor(filterParams, offset, limit);
    const res = await fetchPage(params);
    const records = Array.isArray(res?.items)
      ? res.items
      : Array.isArray(res?.history)
        ? res.history
        : Array.isArray(res?.ledger)
          ? res.ledger
          : Array.isArray(res?.rows)
            ? res.rows
            : Array.isArray(res?.entries)
              ? res.entries
              : Array.isArray(res)
                ? res
                : [];
    const total = Number(res?.total ?? res?.totalRows ?? res?.totalCount ?? records.length);
    const unfilteredTotal = res?.unfilteredTotal != null ? Number(res.unfilteredTotal) : total;
    return { records, total, unfilteredTotal };
  }

  function onFilterChange(immediate = false) {
    if (filterDebounceTimer) {
      clearTimeout(filterDebounceTimer);
      filterDebounceTimer = null;
    }
    if (immediate) {
      applyFilterReload();
    } else {
      filterDebounceTimer = setTimeout(() => {
        filterDebounceTimer = null;
        applyFilterReload();
      }, 200);
    }
  }

  function applyFilterReload() {
    queryEpoch++;
    clearChunkDebounce();

    const currentKey = getFilterKey(automat.state);
    const cached = filterCaches.get(currentKey);

    if (cached && cached.items !== null) {
      cached.lastAccessed = Date.now();
      for (const c of cached.loadedChunks) {
        touchChunkLRU(currentKey, c);
      }

      automat.setState({
        items: cached.items,
        total: cached.total,
        unfilteredTotal: cached.unfilteredTotal ?? automat.state.unfilteredTotal ?? 0,
        status: cached.status || 'ready',
        error: cached.error || null,
      });

      recordChunkEvent({
        type: 'filter_hit',
        epoch: queryEpoch,
        filterKey: currentKey,
        message: `Filter gewechselt: "${cached.label}" (Cache-Hit: ${cached.loadedChunks.size} Chunks / ${countNonNullItems(cached.items)} Einträge im RAM)`,
      });
      notifyChunkStats();

      if (!cached.loadedChunks.has(0)) {
        void actions.loadChunk(0, queryEpoch, currentKey);
      }
    } else {
      const entry = getOrCreateFilterCache(currentKey, automat.state);
      entry.lastAccessed = Date.now();

      automat.setState({
        items: null,
        total: 0,
        unfilteredTotal: automat.state.unfilteredTotal ?? 0,
        status: 'loading',
        error: null,
      });

      recordChunkEvent({
        type: 'filter_miss',
        epoch: queryEpoch,
        filterKey: currentKey,
        message: `Filter gewechselt: "${entry.label}" (Cache-Miss: Lade Chunk #0)`,
      });
      notifyChunkStats();

      void actions.loadChunk(0, queryEpoch, currentKey);
    }
  }

  const actions = {
    getItems() {
      if (automat.state.items === null) {
        void actions.requireChunk(0, 0, { prefetch: false, immediate: true });
        return null;
      }
      return automat.state.items;
    },

    requireChunk(chunkIndex, endOrOptions = chunkIndex, maybeOptions = {}) {
      let start;
      let end;
      let options = {};

      if (Array.isArray(chunkIndex)) {
        start = chunkIndex[0] ?? 0;
        end = chunkIndex[chunkIndex.length - 1] ?? start;
        if (typeof endOrOptions === 'object' && endOrOptions !== null) {
          options = endOrOptions;
        }
      } else {
        start = Number(chunkIndex) || 0;
        if (typeof endOrOptions === 'object' && endOrOptions !== null) {
          end = start;
          options = endOrOptions;
        } else {
          end = Number(endOrOptions ?? start) || start;
          if (typeof maybeOptions === 'object' && maybeOptions !== null) {
            options = maybeOptions;
          }
        }
      }

      start = Math.max(0, Math.floor(start));
      end = Math.max(start, Math.floor(end));
      const prefetch = options.prefetch !== false;
      const currentKey = getFilterKey(automat.state);

      if (options.immediate || automat.state.items === null) {
        clearChunkDebounce();
        const chunks = new Set();
        for (let c = start; c <= end; c++) chunks.add(c);
        recordChunkEvent({
          type: 'require_immediate',
          chunks: Array.from(chunks),
          filterKey: currentKey,
          message: `Sofortige Anforderung: Chunks ${start}..${end} (${formatFilterLabel(currentKey)})`,
        });
        return _executeRequiredChunks(chunks, queryEpoch, prefetch, currentKey);
      }

      if (lastRequireChunkTick !== currentEventTick) {
        pendingTargetChunks.clear();
        lastRequireChunkTick = currentEventTick;
        if (typeof queueMicrotask === 'function') {
          queueMicrotask(() => {
            currentEventTick++;
          });
        } else {
          Promise.resolve().then(() => {
            currentEventTick++;
          });
        }
      }

      for (let c = start; c <= end; c++) {
        pendingTargetChunks.add(c);
      }
      recordChunkEvent({
        type: 'pending',
        chunks: Array.from(pendingTargetChunks),
        filterKey: currentKey,
        message: `Debounce vorgemerkt (${CHUNK_DEBOUNCE_MS}ms): Chunks [${Array.from(pendingTargetChunks).join(', ')}]`,
      });
      notifyChunkStats();

      if (chunkDebounceTimer) {
        clearTimeout(chunkDebounceTimer);
        chunkDebounceTimer = null;
      }

      if (!pendingChunkPromise) {
        pendingChunkPromise = new Promise((resolve, reject) => {
          pendingChunkResolve = resolve;
          pendingChunkReject = reject;
        });
      }

      const captureEpoch = queryEpoch;
      chunkDebounceTimer = setTimeout(() => {
        chunkDebounceTimer = null;
        const chunksToLoad = new Set(pendingTargetChunks);
        pendingTargetChunks.clear();
        notifyChunkStats();

        const resolve = pendingChunkResolve;
        const reject = pendingChunkReject;
        pendingChunkPromise = null;
        pendingChunkResolve = null;
        pendingChunkReject = null;

        recordChunkEvent({
          type: 'debounce_fire',
          chunks: Array.from(chunksToLoad),
          filterKey: currentKey,
          message: `Debounce abgelaufen: Starte Chunks [${Array.from(chunksToLoad).join(', ')}]`,
        });

        _executeRequiredChunks(chunksToLoad, captureEpoch, true, currentKey)
          .then((res) => resolve?.(res))
          .catch((err) => reject?.(err));
      }, CHUNK_DEBOUNCE_MS);

      return pendingChunkPromise;
    },

    loadChunk(chunkIndex, targetEpoch = queryEpoch, targetFilterKey = getFilterKey(automat.state)) {
      const index = Math.max(0, Number(chunkIndex) || 0);
      const entry = getOrCreateFilterCache(targetFilterKey, automat.state);

      if (targetEpoch !== queryEpoch && targetFilterKey !== getFilterKey(automat.state)) {
        return Promise.resolve(entry.items);
      }

      if (entry.loadedChunks.has(index)) {
        touchChunkLRU(targetFilterKey, index);
        recordChunkEvent({
          type: 'hit',
          chunkIndex: index,
          filterKey: targetFilterKey,
          message: `Cache-Hit: Chunk #${index} für Filter "${entry.label}" bereits im Speicher`,
        });
        return Promise.resolve(
          targetFilterKey === getFilterKey(automat.state) ? automat.state.items : entry.items
        );
      }

      const inflightKey = makeLruKey(targetFilterKey, index);
      if (inflightChunks.has(inflightKey)) {
        recordChunkEvent({
          type: 'inflight_hit',
          chunkIndex: index,
          filterKey: targetFilterKey,
          message: `Inflight-Hit: Chunk #${index} für Filter "${entry.label}" lädt bereits`,
        });
        return inflightChunks.get(inflightKey);
      }

      const offset = index * chunkSize;
      const limit = chunkSize;
      const isActiveFilter = targetFilterKey === getFilterKey(automat.state);

      if (index === 0 && (entry.items === null || (isActiveFilter && automat.state.items === null))) {
        entry.status = 'loading';
        entry.error = null;
        if (isActiveFilter) {
          automat.setState({ status: 'loading', error: null });
        }
      }

      const startTime = Date.now();
      recordChunkEvent({
        type: 'start',
        chunkIndex: index,
        filterKey: targetFilterKey,
        message: `Netzwerk-Request: Lade Chunk #${index} (Offset ${offset}..${offset + limit - 1}) für "${entry.label}"`,
      });

      const filterParams = entry.params || getFilterParams(automat.state);
      const promise = fetchRecordsPageFor(filterParams, offset, limit)
        .then(({ records, total, unfilteredTotal }) => {
          const currentTotal = total > 0 ? total : 0;
          entry.total = currentTotal;
          entry.unfilteredTotal = unfilteredTotal;

          if (entry.items === null || entry.items.length !== currentTotal) {
            entry.items = new Array(currentTotal).fill(null);
          } else {
            entry.items = [...entry.items];
          }

          for (let i = 0; i < records.length; i++) {
            const idx = offset + i;
            if (idx < entry.items.length) {
              entry.items[idx] = records[i];
            }
          }

          entry.loadedChunks.add(index);
          entry.status = 'ready';
          entry.error = null;
          entry.lastAccessed = Date.now();

          registerChunkLRU(targetFilterKey, index, records.length);

          const currentActive = targetFilterKey === getFilterKey(automat.state);
          if (currentActive) {
            automat.setState({
              items: entry.items,
              total: currentTotal,
              unfilteredTotal,
              status: 'ready',
              error: null,
            });
          }

          const duration = Date.now() - startTime;
          recordChunkEvent({
            type: 'loaded',
            chunkIndex: index,
            filterKey: targetFilterKey,
            count: records.length,
            duration,
            message: `Chunk #${index} geladen (${records.length} Einträge in ${duration}ms) für "${entry.label}"`,
          });

          return currentActive ? automat.state.items : entry.items;
        })
        .catch((err) => {
          entry.status = 'failed';
          entry.error = err;
          const currentActive = targetFilterKey === getFilterKey(automat.state);
          if (currentActive) {
            if (index === 0 && automat.state.items === null) {
              automat.setState({ status: 'failed', error: err });
            }
          }
          const duration = Date.now() - startTime;
          console.error(`[${name}] loadChunk(${index}, ${targetFilterKey}) error:`, err);
          recordChunkEvent({
            type: 'error',
            chunkIndex: index,
            filterKey: targetFilterKey,
            duration,
            error: err?.message || String(err),
            message: `Fehler bei Chunk #${index} ("${entry.label}"): ${err?.message || err}`,
          });
          throw err;
        })
        .finally(() => {
          inflightChunks.delete(inflightKey);
          notifyChunkStats();
        });

      inflightChunks.set(inflightKey, promise);
      notifyChunkStats();
      return promise;
    },

    filter(query) {
      automat.setState({ filter: String(query ?? '') });
      onFilterChange(false);
    },

    addSeekMonth() {
      const seekMonths = (automat.state.seekMonths ?? 0) + 1;
      const seekYears = automat.state.seekYears ?? 0;
      const totalMonths = -(seekMonths + seekYears * 12);
      automat.setState({ seekMonths, negativeSeekMonths: totalMonths });
      onFilterChange(true);
    },

    addSeekYear() {
      const seekMonths = automat.state.seekMonths ?? 0;
      const seekYears = (automat.state.seekYears ?? 0) + 1;
      const totalMonths = -(seekMonths + seekYears * 12);
      automat.setState({ seekYears, negativeSeekMonths: totalMonths });
      onFilterChange(true);
    },

    addNegativeSeek(months) {
      if (months === -12) {
        actions.addSeekYear();
      } else if (months === -1) {
        actions.addSeekMonth();
      } else {
        const current = Math.min(0, Number(automat.state.negativeSeekMonths ?? 0));
        const next = current + months;
        automat.setState({ negativeSeekMonths: Math.min(0, next) });
        onFilterChange(true);
      }
    },

    resetNegativeSeek() {
      automat.setState({ seekMonths: 0, seekYears: 0, negativeSeekMonths: 0 });
      onFilterChange(true);
    },

    resetFilters() {
      automat.setState({
        filter: '',
        seekMonths: 0,
        seekYears: 0,
        negativeSeekMonths: 0,
      });
      onFilterChange(true);
    },

    load() {
      return actions.loadChunk(0, queryEpoch, getFilterKey(automat.state));
    },

    ensureLoaded() {
      if (automat.state.items !== null) {
        return Promise.resolve(automat.state.items);
      }
      return actions.loadChunk(0, queryEpoch, getFilterKey(automat.state));
    },

    async reload(onlyCurrent = false) {
      queryEpoch++;
      clearChunkDebounce();

      if (onlyCurrent) {
        const currentKey = getFilterKey(automat.state);
        actions.clearFilterCache(currentKey);
      } else {
        actions.clearCache();
      }

      await actions.loadChunk(0, queryEpoch, getFilterKey(automat.state));
      return automat.state.items;
    },

    replace(items) {
      clearChunkDebounce();
      const currentKey = getFilterKey(automat.state);
      actions.clearFilterCache(currentKey);

      const count = Array.isArray(items) ? items.length : 0;
      const entry = getOrCreateFilterCache(currentKey, automat.state);
      entry.items = items;
      entry.total = count;
      entry.status = 'ready';
      entry.error = null;

      const chunkCount = count > 0 ? Math.ceil(count / chunkSize) : 0;
      for (let c = 0; c < chunkCount; c++) {
        entry.loadedChunks.add(c);
        registerChunkLRU(currentKey, c, Math.min(chunkSize, count - c * chunkSize));
      }

      automat.setState({
        items,
        total: count,
        unfilteredTotal: count,
        status: 'ready',
        error: null,
      });
      notifyChunkStats();
    },

    clearFilterCache(filterKey) {
      const entry = filterCaches.get(filterKey);
      if (entry) {
        for (const c of entry.loadedChunks) {
          lruChunks.delete(makeLruKey(filterKey, c));
        }
        entry.items = null;
        entry.loadedChunks.clear();
        entry.status = 'idle';
        entry.error = null;

        if (filterKey === getFilterKey(automat.state)) {
          automat.setState({ items: null, status: 'idle', error: null });
        }

        recordChunkEvent({
          type: 'clear_filter',
          filterKey,
          message: `Filter-Cache "${entry.label}" geleert`,
        });
        notifyChunkStats();
      }
    },

    clearCache() {
      clearChunkDebounce();
      lruChunks.clear();
      inflightChunks.clear();

      for (const entry of filterCaches.values()) {
        entry.items = null;
        entry.loadedChunks.clear();
        entry.status = 'idle';
        entry.error = null;
      }

      recordChunkEvent({
        type: 'clear_all',
        message: `Gesamter ${name}-Chunk-Cache geleert`,
      });
      notifyChunkStats();

      automat.setState({
        items: null,
        status: 'idle',
        error: null,
      });
    },

    reset() {
      if (filterDebounceTimer) {
        clearTimeout(filterDebounceTimer);
        filterDebounceTimer = null;
      }
      clearChunkDebounce();
      filterCaches.clear();
      lruChunks.clear();
      inflightChunks.clear();

      recordChunkEvent({
        type: 'reset',
        message: `${name}-Automat und sämtliche Caches zurückgesetzt`,
      });
      notifyChunkStats();
      automat.setState(initialState);
    },
  };

  automat = new Automat(initialState, actions, { name });

  automat.getItems = actions.getItems;
  automat.requireChunk = actions.requireChunk;
  automat.CHUNK_SIZE = chunkSize;
  automat.MAX_LRU_CHUNKS = maxLruChunks;
  automat.getChunkStats = getChunkStats;
  automat.subscribeChunkStats = subscribeChunkStats;
  automat.getFilterKey = getFilterKey;
  automat.formatFilterLabel = formatFilterLabel;

  // Reset on logout or company change
  let lastCompanyId = null;
  authAutomat.subscribe((auth) => {
    const companyId = auth.user?.selectedCompanyId ?? null;
    if (auth.status === 'anon') {
      actions.reset();
      lastCompanyId = null;
      return;
    }
    if (lastCompanyId !== null && companyId !== lastCompanyId) {
      actions.reset();
    }
    if (auth.status === 'authed' && companyId != null) {
      lastCompanyId = companyId;
    }
  });

  return automat;
}