/**
 * @file orderAutomat.js
 * @description Manages cached and chunk-paginated company sales orders (`GET /api/order`).
 *
 * Implements a multi-filter chunk cache:
 * - Each filter combination has its own isolated cache entry (total, items array, loadedChunks).
 * - Total chunk capacity across all filter combinations is bounded by a global LRU (Least Recently Used) limit of 50 chunks.
 * - When filter settings change, previously loaded chunks remain cached in memory up to the 50-chunk limit.
 * - Switching back to a previously used filter is instant with zero network requests if its chunks are in RAM.
 * - Real-time stats and events can be observed via `subscribeChunkStats` or the dev ChunkCacheMonitor.
 *
 * Upstream Triggers:
 * - `authAutomat`: Triggers `actions.reset()` on `'anon'` or when `selectedCompanyId` changes.
 * - UI / Routes: Calls `getItems()`, `requireChunk(chunkIndex)`, `loadChunk(chunkIndex)`, or `reload()`.
 */

import { Automat } from 'react-automat';
import { order as orderApi } from '../api';
import authAutomat from './authAutomat';

/**
 * @typedef {Object} OrderLine
 * @property {number} id
 * @property {string|null} sku
 * @property {string|null} name
 * @property {number} pu
 * @property {number} amount
 * @property {number} net
 * @property {number} rebate
 * @property {number} taxrate
 * @property {string|null} comment
 */

/**
 * @typedef {Object} Order
 * @property {number} id Order id.
 * @property {string} number Order number.
 * @property {'order'} type Always `'order'`.
 * @property {number|null} entityId Customer id.
 * @property {string|null} externalNumber External reference.
 * @property {string} date Delivery date (ISO).
 * @property {string} createdAt Creation timestamp (ISO).
 * @property {OrderLine[]} lines Order line items.
 */

/**
 * @typedef {Object} OrderAutomatState
 * @property {Order[]|null} items Pre-filled array of orders/nulls, initially null.
 * @property {number} total Total unpaged count for pagination calculation.
 * @property {string} filter Search term.
 * @property {boolean} onlyUnpaid Unpaid orders only.
 * @property {boolean} onlyUndelivered Undelivered orders only.
 * @property {number} seekMonths Seek month count.
 * @property {number} seekYears Seek year count.
 * @property {number} negativeSeekMonths Negative seek months offset.
 * @property {'idle'|'loading'|'ready'|'failed'} status Load lifecycle state.
 * @property {Error|string|null} error Last load error.
 */

export const CHUNK_SIZE = 50;
export const MAX_LRU_CHUNKS = 50;
const PREFETCH_CHUNKS = 1;
const CHUNK_DEBOUNCE_MS = 130;

const initialState = {
  items: null,
  total: 0,
  unfilteredTotal: 0,
  filter: '',
  onlyUnpaid: false,
  onlyUndelivered: false,
  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
// filterCaches: Map<filterKey, FilterCacheEntry>
const filterCaches = new Map();
// lruChunks: Map<lruKey, { filterKey, chunkIndex, loadedAt, accessedAt, orderCount }>
// In JS, Map keys iteration preserves insertion order. Oldest (LRU) is lruChunks.keys().next().value.
const lruChunks = new Map();
// inflightChunks: Map<inflightKey, Promise>
const inflightChunks = new Map();

// Dev / Observability: Chunk event history and subscriber registry
const MAX_CHUNK_EVENTS = 150;
let nextEventId = 0;
const chunkEvents = [];
const chunkStatsListeners = new Set();

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

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

// MARK: pure filter helpers
export function getFilterParams(state = automat?.state || initialState) {
  const filter = String(state.filter ?? '').trim();
  const onlyUnpaid = Boolean(state.onlyUnpaid);
  const onlyUndelivered = Boolean(state.onlyUndelivered);
  const negativeSeekMonths = (state.negativeSeekMonths != null && Number(state.negativeSeekMonths) < 0)
    ? Number(state.negativeSeekMonths)
    : 0;
  return { filter, onlyUnpaid, onlyUndelivered, negativeSeekMonths };
}

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

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

  const parts = [];
  if (f) parts.push(`Suche: „${f}“`);
  if (u) parts.push('Nur unbezahlt');
  if (d) parts.push('Nur ungeliefert');
  if (s < 0) parts.push(`Seek: ${formatNegativeSeek(s)}`);
  if (parts.length === 0) return 'Standard (Alle Aufträ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;
}

// Touch an existing chunk in the global LRU cache to mark it as Most Recently Used
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() });
  }
}

// Register a newly loaded chunk into the LRU cache and evict the oldest if limit exceeded
function registerChunkLRU(filterKey, chunkIndex, orderCount = 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,
    orderCount,
  });

  // Enforce global MAX_LRU_CHUNKS limit across all filter caches
  while (lruChunks.size > MAX_LRU_CHUNKS) {
    const oldestKey = lruChunks.keys().next().value;
    const oldestInfo = lruChunks.get(oldestKey);
    lruChunks.delete(oldestKey);
    if (oldestInfo) {
      evictChunkFromMemory(oldestInfo.filterKey, oldestInfo.chunkIndex, 'lru');
    }
  }
}

// Evicts a chunk from memory: sets items back to null in the filter cache and removes from loadedChunks
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 * CHUNK_SIZE;
      for (let i = offset; i < offset + CHUNK_SIZE && i < entry.items.length; i++) {
        entry.items[i] = null;
      }
    }

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

    const eventType = reason === 'lru' ? 'lru_evict' : 'evict';
    const msg = reason === 'lru'
      ? `LRU-Eviction: Chunk #${chunkIndex} von Filter "${entry.label}" verworfen (${lruChunks.size}/${MAX_LRU_CHUNKS} im Cache)`
      : `Chunk #${chunkIndex} von Filter "${entry.label}" verworfen`;

    recordChunkEvent({
      type: eventType,
      chunkIndex,
      filterKey,
      message: msg,
    });
    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('[orderAutomat] chunkStatsListener error', e);
    }
  }
}

export 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 chunkCount = total > 0 ? Math.ceil(total / CHUNK_SIZE) : (activeLoaded.size > 0 ? Math.max(...activeLoaded) + 1 : 0);
  const items = activeEntry?.items ?? automat?.state?.items;
  const loadedItemsCount = countNonNullItems(items);

  // Summarize all cached filter combinations
  const cachedFiltersSummary = Array.from(filterCaches.values()).map((entry) => ({
    key: entry.key,
    label: entry.label,
    params: entry.params,
    total: entry.total,
    loadedChunksCount: entry.loadedChunks.size,
    loadedChunks: Array.from(entry.loadedChunks).sort((a, b) => a - b),
    chunkCount: entry.total > 0 ? Math.ceil(entry.total / CHUNK_SIZE) : (entry.loadedChunks.size > 0 ? Math.max(...entry.loadedChunks) + 1 : 0),
    loadedItemsCount: countNonNullItems(entry.items),
    lastAccessed: entry.lastAccessed,
    isActive: entry.key === currentKey,
    status: entry.status,
    items: entry.items,
  }));

  // LRU queue list from oldest (1) to newest (50)
  const lruEntries = Array.from(lruChunks.entries()).map(([key, info], idx) => ({
    lruKey: key,
    filterKey: info.filterKey,
    filterLabel: filterCaches.get(info.filterKey)?.label || info.filterKey,
    chunkIndex: info.chunkIndex,
    loadedAt: info.loadedAt,
    accessedAt: info.accessedAt,
    orderCount: info.orderCount,
    lruRank: idx + 1,
  }));

  // Active filter's inflight chunks
  const activeInflight = [];
  for (const key of inflightChunks.keys()) {
    if (key.startsWith(`${currentKey}:::`)) {
      const parsed = parseLruKey(key);
      activeInflight.push(parsed.chunkIndex);
    }
  }

  return {
    automatName: 'order',
    chunkSize: CHUNK_SIZE,
    maxLruChunks: MAX_LRU_CHUNKS,
    lruChunksCount: lruChunks.size,
    total,
    chunkCount,
    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 ?? '',
    onlyUnpaid: automat?.state?.onlyUnpaid ?? false,
    onlyUndelivered: automat?.state?.onlyUndelivered ?? false,
    negativeSeekMonths: automat?.state?.negativeSeekMonths ?? 0,
    items,
    activeFilterKey: currentKey,
    activeFilterLabel: formatFilterLabel(currentKey),
    filterCaches: cachedFiltersSummary,
    lruEntries,
    events: [...chunkEvents],
  };
}

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

// Clears pending debounced chunk requests
function clearChunkDebounce() {
  if (chunkDebounceTimer) {
    clearTimeout(chunkDebounceTimer);
    chunkDebounceTimer = null;
  }
  if (pendingTargetChunks.size > 0) {
    pendingTargetChunks.clear();
    notifyChunkStats();
  }
  pendingChunkPromise = null;
  pendingChunkResolve = null;
  pendingChunkReject = null;
}

// Executes chunk loading for the standstill target and prefetches lookahead chunks
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));
  }

  // Once active chunks finish loading, prefetch the next lookahead chunk in the background
  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 * CHUNK_SIZE >= 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;
  });
}

// MARK: pure order helpers
export function isOrderPaid(order) {
  if (!order) return false;
  return Boolean(order.paid ?? order.payed ?? order.isPaid ?? order.is_paid ?? order.paidAt);
}

export function isOrderDelivered(order) {
  if (!order) return false;
  return Boolean(order.shipped ?? order.delivered ?? order.isDelivered ?? order.is_delivered ?? order.deliveredAt);
}

export function getOrderDate(order) {
  if (!order) return null;
  const raw = order.date || order.createdAt;
  if (!raw) return null;
  const d = new Date(raw);
  return Number.isNaN(d.getTime()) ? null : d;
}

/**
 * Calculates cutoff date for negative seek.
 * @param {number} months Negative integer (e.g. -1 for 1 month ago, -12 for 1 year ago)
 * @returns {Date|null}
 */
export function getNegativeSeekCutoff(months) {
  if (!months || months >= 0) return null;
  const d = new Date();
  d.setMonth(d.getMonth() + months);
  d.setHours(23, 59, 59, 999);
  return d;
}

/**
 * Formats negative seek duration in human readable German.
 * @param {number} months
 * @returns {string}
 */
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(' ')}`;
}

// Builds server query parameters from filter params
function buildQueryParamsFor(filterParams, offset = 0, limit = CHUNK_SIZE) {
  const params = { offset, limit };
  const trimmed = String(filterParams.filter ?? '').trim();
  if (trimmed) params.search = trimmed;
  if (filterParams.onlyUnpaid) params.onlyUnpaid = true;
  if (filterParams.onlyUndelivered) params.onlyUndelivered = true;
  if (filterParams.negativeSeekMonths != null && Number(filterParams.negativeSeekMonths) < 0) {
    params.seekMonths = Number(filterParams.negativeSeekMonths);
  }
  return params;
}

// Fetches a single chunk from GET /api/order with server-side filters
async function fetchOrdersPageFor(filterParams, offset = 0, limit = CHUNK_SIZE) {
  const params = buildQueryParamsFor(filterParams, offset, limit);
  const res = await orderApi.list(params);
  const orders = Array.isArray(res?.orders) ? res.orders : [];
  const total = Number(res?.total ?? orders.length);
  const unfilteredTotal = res?.unfilteredTotal != null ? Number(res.unfilteredTotal) : total;
  return { orders, total, unfilteredTotal };
}

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

// Invoked when active filters change: switches to the matching filter cache without wiping!
function applyFilterReload() {
  queryEpoch++;
  clearChunkDebounce();

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

  if (cached && cached.items !== null) {
    // CACHE HIT FOR THIS FILTER COMBINATION: restore instantly from RAM!
    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)} Aufträge im RAM)`,
    });
    notifyChunkStats();

    // If chunk 0 was evicted or not yet loaded in this filter, fetch chunk 0
    if (!cached.loadedChunks.has(0)) {
      void actions.loadChunk(0, queryEpoch, currentKey);
    }
  } else {
    // CACHE MISS: initialize fresh filter entry and load chunk 0
    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 = {
  // MARK: returns current items and triggers chunk 0 if not loaded (no prefetch on entry)
  getItems() {
    if (automat.state.items === null) {
      void actions.requireChunk(0, 0, { prefetch: false, immediate: true });
      return null;
    }
    return automat.state.items;
  },

  // MARK: ensures chunkIndex and lookahead chunks are loaded/loading (debounced)
  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 initial items are null or immediate requested, bypass debounce and load immediately
    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);
    }

    // New event tick (drag mousemove / pagination click) replaces previous target position
    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;
  },

  // MARK: fetches a single chunk and populates the filter cache and prefilled array
  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 * CHUNK_SIZE;
    const limit = CHUNK_SIZE;
    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 = fetchOrdersPageFor(filterParams, offset, limit)
      .then(({ orders, 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];
        }

        // Fill in real received items for this chunk
        for (let i = 0; i < orders.length; i++) {
          const idx = offset + i;
          if (idx < entry.items.length) {
            entry.items[idx] = orders[i];
          }
        }

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

        // Register chunk in global LRU (evicts oldest chunk if > MAX_LRU_CHUNKS)
        registerChunkLRU(targetFilterKey, index, orders.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: orders.length,
          duration,
          message: `Chunk #${index} geladen (${orders.length} Aufträ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(`[orderAutomat] 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;
  },

  // MARK: server-side filter actions
  filter(query) {
    automat.setState({ filter: String(query ?? '') });
    onFilterChange(false);
  },

  setOnlyUnpaid(onlyUnpaid) {
    automat.setState({ onlyUnpaid: Boolean(onlyUnpaid) });
    onFilterChange(true);
  },

  setOnlyUndelivered(onlyUndelivered) {
    automat.setState({ onlyUndelivered: Boolean(onlyUndelivered) });
    onFilterChange(true);
  },

  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: '',
      onlyUnpaid: false,
      onlyUndelivered: false,
      seekMonths: 0,
      seekYears: 0,
      negativeSeekMonths: 0,
    });
    onFilterChange(true);
  },

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

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

  // MARK: reload active filter or invalidate all
  async reload(onlyCurrent = false) {
    queryEpoch++;
    clearChunkDebounce();

    if (onlyCurrent) {
      // Invalidate only current filter's cached chunks
      const currentKey = getFilterKey(automat.state);
      actions.clearFilterCache(currentKey);
    } else {
      // Full reload (e.g. after SSE mutation or document deletion): clear all cached data
      actions.clearCache();
    }

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

  // MARK: replace items directly
  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;

    recordChunkEvent({
      type: 'replace',
      filterKey: currentKey,
      message: `Items ersetzt (${count} Einträge)`,
    });
    notifyChunkStats();
    automat.setState({
      items,
      total: count,
      status: 'ready',
      error: null,
    });
    return items;
  },

  // MARK: evicts a specific chunk from cache (optional filterKey, defaults to active)
  evictChunk(chunkIndex, filterKey = getFilterKey(automat.state)) {
    const index = Math.max(0, Number(chunkIndex) || 0);
    const key = makeLruKey(filterKey, index);
    if (lruChunks.has(key)) {
      lruChunks.delete(key);
    }
    evictChunkFromMemory(filterKey, index, 'manual');
    return automat.state.items;
  },

  // MARK: clears a specific filter cache and removes its chunks from LRU
  clearFilterCache(filterKey = getFilterKey(automat.state)) {
    // Remove all chunks of this filter from LRU
    for (const [lruKey, info] of Array.from(lruChunks.entries())) {
      if (info.filterKey === filterKey) {
        lruChunks.delete(lruKey);
      }
    }

    const entry = filterCaches.get(filterKey);
    if (entry) {
      entry.loadedChunks.clear();
      entry.items = null;
      entry.total = 0;
      entry.status = 'idle';
      entry.error = null;
    }

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

    recordChunkEvent({
      type: 'clear_filter',
      filterKey,
      message: `Filter-Cache für "${formatFilterLabel(filterKey)}" geleert`,
    });
    notifyChunkStats();
    return automat.state.items;
  },

  // MARK: clears all loaded chunks and filter caches from RAM
  clearCache() {
    clearChunkDebounce();
    lruChunks.clear();
    inflightChunks.clear();

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

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

    recordChunkEvent({
      type: 'clear',
      message: 'Gesamter LRU-Cache und alle Filter-Caches geleert',
    });
    notifyChunkStats();
    return automat.state.items;
  },

  // MARK: prefetches all remaining chunks for a filter (bounded by MAX_LRU_CHUNKS)
  prefetchAllChunks(filterKey = getFilterKey(automat.state)) {
    const entry = getOrCreateFilterCache(filterKey, automat.state);
    const total = entry.total || automat.state.total || 0;
    const chunkCount = Math.ceil(total / CHUNK_SIZE);

    recordChunkEvent({
      type: 'prefetch_all',
      filterKey,
      message: `Starte Prefetch aller ${chunkCount} Chunks für "${entry.label}"`,
    });

    for (let c = 0; c < chunkCount; c++) {
      const inflightKey = makeLruKey(filterKey, c);
      if (!entry.loadedChunks.has(c) && !inflightChunks.has(inflightKey)) {
        void actions.loadChunk(c, queryEpoch, filterKey);
      }
    }
    notifyChunkStats();
  },

  // MARK: patches an order locally across all filter caches
  patchOrder(id, patch) {
    let changed = false;
    for (const entry of filterCaches.values()) {
      if (Array.isArray(entry.items)) {
        entry.items = entry.items.map((o) => {
          if (o && o.id === id) {
            changed = true;
            return { ...o, ...patch };
          }
          return o;
        });
      }
    }

    if (Array.isArray(automat.state.items)) {
      const items = automat.state.items.map((o) => {
        if (o && o.id === id) {
          changed = true;
          return { ...o, ...patch };
        }
        return o;
      });
      if (changed) {
        automat.setState({ items });
      }
    }
    return automat.state.items;
  },

  // MARK: resets state and all caches completely (e.g. on logout / company switch)
  reset() {
    queryEpoch++;
    if (filterDebounceTimer) {
      clearTimeout(filterDebounceTimer);
      filterDebounceTimer = null;
    }
    clearChunkDebounce();
    filterCaches.clear();
    lruChunks.clear();
    inflightChunks.clear();

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

export const orderAutomat = new Automat(initialState, actions, { name: 'order' });
automat = orderAutomat;

// MARK: exported methods for direct invocation
export function getItems() {
  return actions.getItems();
}

export function requireChunk(chunkIndex, endOrOptions, maybeOptions) {
  return actions.requireChunk(chunkIndex, endOrOptions, maybeOptions);
}

orderAutomat.getItems = getItems;
orderAutomat.requireChunk = requireChunk;
orderAutomat.CHUNK_SIZE = CHUNK_SIZE;
orderAutomat.MAX_LRU_CHUNKS = MAX_LRU_CHUNKS;
orderAutomat.getChunkStats = getChunkStats;
orderAutomat.subscribeChunkStats = subscribeChunkStats;
orderAutomat.evictChunk = actions.evictChunk;
orderAutomat.clearFilterCache = actions.clearFilterCache;
orderAutomat.clearCache = actions.clearCache;
orderAutomat.prefetchAllChunks = actions.prefetchAllChunks;
orderAutomat.getFilterKey = getFilterKey;
orderAutomat.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;
  }
});

/** Selects current orders */
export function selectOrders(state = automat.state) {
  return state.items;
}

/** Selects total unpaged count */
export function selectOrderTotal(state = automat.state) {
  return state.total;
}

/** Selects unfiltered total count */
export function selectOrderUnfilteredTotal(state = automat.state) {
  return state.unfilteredTotal ?? 0;
}

/** Selects unpaid filter */
export function selectOnlyUnpaid(state = automat.state) {
  return state.onlyUnpaid;
}

/** Selects undelivered filter */
export function selectOnlyUndelivered(state = automat.state) {
  return state.onlyUndelivered;
}

/** Selects negative seek offset in months */
export function selectNegativeSeekMonths(state = automat.state) {
  return state.negativeSeekMonths;
}

/** Selects seek month count */
export function selectSeekMonths(state = automat.state) {
  return state.seekMonths ?? 0;
}

/** Selects seek year count */
export function selectSeekYears(state = automat.state) {
  return state.seekYears ?? 0;
}

/**
 * Calculates client pagination metadata.
 */
export function selectOrderPagination(state = automat.state) {
  const total = state.total ?? 0;
  return {
    total,
    offset: 0,
    limit: CHUNK_SIZE,
    currentPage: 1,
    pageCount: Math.max(1, Math.ceil(total / CHUNK_SIZE)),
  };
}

export default orderAutomat;