import type { AutomationSnapshot } from './automation-module.js';
import type { CallFeatureStatus, CallsSnapshot } from './calls-module.js';
import type { CellularSnapshot } from './cellular-module.js';
import type { DeviceNetworkSnapshot } from './device-network-module.js';
import type { EsimSafeLabel, EsimSnapshot } from './esim-module.js';
import type { NotificationsSnapshot } from './notifications-module.js';
import type { OtaSnapshot } from './ota-module.js';
import type { OverviewFieldValue, OverviewSnapshot } from './overview-system.js';

/**
 * Bridge between the control-plane instance module proxy and the device panel modules.
 *
 * The API reads the device's own read-only endpoints, classifies each probe, and hands back a
 * flat list of sections. This file is the single place that knows how those device sections map
 * onto the console's presentation contracts, so every module renders live data instead of an
 * empty shell.
 */

export type InstanceModuleState = 'ok' | 'empty' | 'auth-required' | 'unsupported' | 'failed';

export interface InstanceModuleSection {
  readonly key: string;
  readonly path: string;
  readonly state: InstanceModuleState;
  readonly status: number;
  readonly data: unknown;
}

export interface InstanceModuleSnapshot {
  readonly instanceId: string;
  readonly module: string;
  readonly observedAt: string;
  readonly authenticated: boolean;
  readonly sections: readonly InstanceModuleSection[];
}

export interface InstanceModuleReader {
  read(instanceId: string, module: string, signal?: AbortSignal): Promise<InstanceModuleSnapshot>;
}

const MAX_ENTRIES = 40;
const MAX_STRING_LENGTH = 240;

function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
  return typeof value === 'object' && value !== null && !Array.isArray(value);
}

function parseSnapshot(value: unknown, instanceId: string, module: string): InstanceModuleSnapshot {
  if (
    !isRecord(value) ||
    typeof value.instanceId !== 'string' ||
    value.instanceId !== instanceId ||
    typeof value.module !== 'string' ||
    typeof value.observedAt !== 'string' ||
    typeof value.authenticated !== 'boolean' ||
    !Array.isArray(value.sections)
  )
    throw new Error('服务端返回的模块快照无效。');
  const sections = value.sections.slice(0, 64).flatMap((entry): InstanceModuleSection[] => {
    if (!isRecord(entry) || typeof entry.key !== 'string' || typeof entry.path !== 'string')
      return [];
    const state = entry.state;
    return [
      {
        key: entry.key.slice(0, 64),
        path: entry.path.slice(0, 256),
        state:
          state === 'ok' ||
          state === 'empty' ||
          state === 'auth-required' ||
          state === 'unsupported' ||
          state === 'failed'
            ? state
            : 'failed',
        status:
          typeof entry.status === 'number' && Number.isFinite(entry.status) ? entry.status : 0,
        data: entry.data,
      },
    ];
  });
  return {
    instanceId: value.instanceId,
    module: value.module || module,
    observedAt: value.observedAt,
    authenticated: value.authenticated,
    sections,
  };
}

export function createInstanceModuleApiReader(fetcher: typeof fetch = fetch): InstanceModuleReader {
  return {
    async read(instanceId, module, signal) {
      const url = `/api/v1/instances/${encodeURIComponent(instanceId)}/modules/${encodeURIComponent(
        module,
      )}`;
      const response = await fetcher(url, {
        method: 'GET',
        credentials: 'same-origin',
        headers: { accept: 'application/json' },
        ...(signal ? { signal } : {}),
      });
      if (!response.ok) throw new Error(`请求失败 (${response.status})`);
      return parseSnapshot(await response.json(), instanceId, module);
    },
  };
}

function section(snapshot: InstanceModuleSnapshot, key: string): InstanceModuleSection | undefined {
  return snapshot.sections.find((candidate) => candidate.key === key);
}

function sectionRecord(
  snapshot: InstanceModuleSnapshot,
  key: string,
): Readonly<Record<string, unknown>> {
  const entry = section(snapshot, key);
  if (!entry) return {};
  if (isRecord(entry.data)) return entry.data;
  if (Array.isArray(entry.data)) return { items: entry.data };
  return {};
}

/** First present value among candidate device field names; device payloads are not uniform. */
function pick(source: Readonly<Record<string, unknown>>, keys: readonly string[]): unknown {
  for (const key of keys) {
    const value = source[key];
    if (value !== undefined && value !== null) return value;
  }
  return undefined;
}

function text(value: unknown): string | undefined {
  if (typeof value === 'string')
    return value.length > MAX_STRING_LENGTH ? `${value.slice(0, MAX_STRING_LENGTH)}…` : value;
  if (typeof value === 'number' && Number.isFinite(value)) return String(value);
  if (typeof value === 'boolean') return value ? 'true' : 'false';
  return undefined;
}

function flag(value: unknown): boolean | undefined {
  if (typeof value === 'boolean') return value;
  if (typeof value === 'number') return value !== 0;
  if (typeof value === 'string') {
    const lowered = value.toLocaleLowerCase();
    if (['true', 'yes', 'on', 'enabled', '1'].includes(lowered)) return true;
    if (['false', 'no', 'off', 'disabled', '0'].includes(lowered)) return false;
  }
  return undefined;
}

function count(value: unknown): number | undefined {
  if (typeof value === 'number' && Number.isFinite(value)) return value;
  if (typeof value === 'string') {
    const parsed = Number(value);
    if (Number.isFinite(parsed)) return parsed;
  }
  return undefined;
}

/** Keep only display-safe primitives, preserving device key names for the label table. */
function primitives(source: Readonly<Record<string, unknown>>): Record<string, OverviewFieldValue> {
  const result: Record<string, OverviewFieldValue> = {};
  for (const [key, value] of Object.entries(source)) {
    if (Object.keys(result).length >= MAX_ENTRIES) break;
    if (typeof value === 'string') {
      result[key] = text(value) ?? null;
    } else if (typeof value === 'number') {
      result[key] = Number.isFinite(value) ? value : null;
    } else if (typeof value === 'boolean') {
      result[key] = value;
    } else if (Array.isArray(value)) {
      const entries = value
        .slice(0, 6)
        .map((item) => (isRecord(item) ? text(pick(item, ['name', 'label', 'value'])) : text(item)))
        .filter((item): item is string => item !== undefined);
      result[key] = entries.length ? entries.join('、') : null;
    } else {
      result[key] = null;
    }
  }
  return result;
}

function arrayFrom(
  source: Readonly<Record<string, unknown>>,
  keys: readonly string[],
): readonly unknown[] {
  for (const key of keys) {
    const value = source[key];
    if (Array.isArray(value)) return value.slice(0, MAX_ENTRIES);
  }
  return [];
}

function tally(items: readonly unknown[], predicate: (item: unknown) => boolean): number {
  return items.reduce<number>((total, item) => (predicate(item) ? total + 1 : total), 0);
}

function statusOf(items: readonly unknown[]): 'healthy' | 'degraded' | 'failed' | 'idle' {
  if (items.length === 0) return 'idle';
  const failed = tally(items, (item) => {
    const record = isRecord(item) ? item : {};
    const value = text(pick(record, ['status', 'state', 'result']))?.toLocaleLowerCase();
    return value === 'failed' || value === 'error';
  });
  if (failed === 0) return 'healthy';
  return failed >= items.length ? 'failed' : 'degraded';
}

function observed(snapshot: InstanceModuleSnapshot): { readonly observedAt: string } {
  return { observedAt: snapshot.observedAt };
}

export function mapOverview(snapshot: InstanceModuleSnapshot): OverviewSnapshot {
  const stats = sectionRecord(snapshot, 'stats');
  // Anchored on word boundaries: "download_bytes" contains "load" but is throughput, not a load average.
  const cpuKeys = Object.keys(stats).filter((key) =>
    /(^|_)(cpu|memory|mem|temp|thermal|load)(_|$)/u.test(key),
  );
  const cpu: Record<string, OverviewFieldValue> = {};
  const rest: Record<string, OverviewFieldValue> = {};
  for (const [key, value] of Object.entries(primitives(stats))) {
    if (cpuKeys.includes(key)) cpu[key] = value;
    else rest[key] = value;
  }
  // /stats/cpu is a separate probe; its core summary belongs beside the load averages.
  Object.assign(cpu, primitives(sectionRecord(snapshot, 'cpu')));
  // Message counters read better beside the traffic totals than in their own card.
  Object.assign(rest, primitives(sectionRecord(snapshot, 'smsStats')));
  return {
    ...observed(snapshot),
    device: primitives(sectionRecord(snapshot, 'device')),
    sim: primitives(sectionRecord(snapshot, 'sim')),
    network: {
      ...primitives(sectionRecord(snapshot, 'network')),
      ...primitives(sectionRecord(snapshot, 'data')),
    },
    stats: rest,
    cpu,
    connectivity: primitives(sectionRecord(snapshot, 'connectivity')),
  };
}

export function mapCellular(snapshot: InstanceModuleSnapshot): CellularSnapshot {
  const network = sectionRecord(snapshot, 'network');
  const signal = sectionRecord(snapshot, 'signalStrength');
  const cells = isRecord(sectionRecord(snapshot, 'cells').cells)
    ? (sectionRecord(snapshot, 'cells').cells as Readonly<Record<string, unknown>>)
    : sectionRecord(snapshot, 'cells');
  const location = sectionRecord(snapshot, 'cellLocation');
  const operators = sectionRecord(snapshot, 'operators');
  const available = arrayFrom(operators, ['operators', 'available', 'items', 'list']).flatMap(
    (item): string[] => {
      const name = isRecord(item) ? text(pick(item, ['name', 'long_name', 'alpha'])) : text(item);
      return name ? [name] : [];
    },
  );
  const roaming = flag(pick(network, ['roaming', 'is_roaming', 'roaming_active']))
    ? 'roaming'
    : text(pick(sectionRecord(snapshot, 'roaming'), ['state', 'status', 'roaming']));
  return {
    ...observed(snapshot),
    networkRegistration: {
      state: text(pick(network, ['registration_state', 'register_state', 'state', 'status'])),
      mode: text(pick(network, ['radio_mode', 'mode', 'network_mode', 'preferred_mode'])),
      operator: text(pick(network, ['operator_name', 'operator', 'carrier', 'name'])),
      roaming,
    },
    signal: {
      rssi: text(pick(signal, ['rssi', 'signal_dbm', 'dbm', 'strength'])),
      rsrp: text(pick(signal, ['rsrp', 'lte_rsrp', 'nr_rsrp'])),
      rsrq: text(pick(signal, ['rsrq', 'lte_rsrq'])),
      sinr: text(pick(signal, ['sinr', 'lte_sinr', 'nr_sinr'])),
      quality: text(pick(signal, ['signal_percent', 'level', 'quality', 'asu'])),
    },
    cellsLocation: {
      cell: text(pick(cells, ['cell_id', 'cellId', 'eci', 'cid', 'nr_cell_id'])),
      area: text(pick(cells, ['tac', 'tracking_area', 'area_code', 'rac'])),
      technology: text(
        pick(cells, ['network_type', 'technology', 'rat']) ??
          pick(network, ['network_type', 'technology', 'rat']),
      ),
      latitude: text(pick(location, ['latitude', 'lat'])),
      longitude: text(pick(location, ['longitude', 'lng', 'lon'])),
      mcc: text(pick(location, ['mcc']) ?? pick(cells, ['mcc'])),
      mnc: text(pick(location, ['mnc']) ?? pick(cells, ['mnc'])),
      pci: text(pick(location, ['pci']) ?? pick(cells, ['pci', 'phys_cell_id'])),
      arfcn: text(
        pick(location, ['earfcn', 'arfcn', 'nr_arfcn']) ??
          pick(cells, ['earfcn', 'arfcn', 'nr_arfcn']),
      ),
    },
    operators: {
      current: text(pick(network, ['operator_name', 'operator', 'carrier'])),
      available: available.length ? available.slice(0, 12).join('、') : undefined,
    },
  };
}

export function mapDeviceNetwork(snapshot: InstanceModuleSnapshot): DeviceNetworkSnapshot {
  const wlanStatus = sectionRecord(snapshot, 'wlanStatus');
  const wlanProfiles = sectionRecord(snapshot, 'wlanProfiles');
  const interfaces = sectionRecord(snapshot, 'interfaces');
  const addresses = sectionRecord(snapshot, 'addresses');
  const ddnsStatus = sectionRecord(snapshot, 'ddnsStatus');
  const ddnsConfig = sectionRecord(snapshot, 'ddnsConfig');
  const ddnsLogs = sectionRecord(snapshot, 'ddnsLogs');
  const profileItems = arrayFrom(wlanProfiles, ['profiles', 'items', 'list', 'networks']);
  const interfaceItems = arrayFrom(interfaces, ['interfaces', 'items', 'list']);
  const logItems = arrayFrom(ddnsLogs, ['logs', 'entries', 'items']);
  const addressList = (keys: readonly string[]): readonly string[] =>
    arrayFrom(addresses, keys)
      .map((item) => text(item))
      .filter((item): item is string => item !== undefined)
      .slice(0, 8);
  const ipv4 = addressList(['ipv4', 'ipv4_addresses', 'v4']);
  const ipv6 = addressList(['ipv6', 'ipv6_addresses', 'v6']);
  return {
    ...observed(snapshot),
    connectionAddresses: { ipv4, ipv6 },
    wlan: {
      status: {
        enabled: flag(pick(wlanStatus, ['enabled', 'wlan_enabled', 'is_enabled'])),
        radioState: text(pick(wlanStatus, ['radio_state', 'radioState', 'state'])),
        connectionState: text(
          pick(wlanStatus, ['connection_state', 'connectionState', 'status', 'state']),
        ),
        activeProfile: text(pick(wlanStatus, ['active_profile', 'activeProfile', 'profile'])),
        ssid: text(pick(wlanStatus, ['ssid', 'network_name'])),
      },
      profiles: profileItems.flatMap((item) =>
        isRecord(item)
          ? [
              {
                name: text(pick(item, ['name', 'profile_name'])),
                ssid: text(pick(item, ['ssid'])),
                security: text(pick(item, ['security', 'key_management', 'encryption'])),
                enabled: flag(pick(item, ['enabled', 'active'])),
                priority: count(pick(item, ['priority', 'order'])),
              },
            ]
          : [],
      ),
    },
    interfaces: interfaceItems.flatMap((item) =>
      isRecord(item)
        ? [
            {
              name: text(pick(item, ['name', 'interface', 'ifname'])),
              kind: text(pick(item, ['kind', 'type', 'driver'])),
              state: text(pick(item, ['state', 'status', 'operstate'])),
              macAddress: text(pick(item, ['mac_address', 'macAddress', 'mac'])),
              mtu: count(pick(item, ['mtu'])),
              addresses: arrayFrom(item, ['addresses', 'ips']).flatMap((address) =>
                isRecord(address)
                  ? [
                      {
                        family: text(pick(address, ['family', 'scope'])),
                        address: text(pick(address, ['address', 'ip', 'value'])),
                        prefixLength: count(pick(address, ['prefix_length', 'prefix', 'cidr'])),
                        scope: text(pick(address, ['scope'])),
                      },
                    ]
                  : typeof address === 'string'
                    ? [{ address, family: undefined, prefixLength: undefined, scope: undefined }]
                    : [],
              ),
            },
          ]
        : [],
    ),
    ddns: {
      status: {
        enabled: flag(pick(ddnsStatus, ['enabled', 'configured'])),
        state: text(pick(ddnsStatus, ['state', 'status', 'last_result'])),
        lastUpdateAt: text(pick(ddnsStatus, ['last_update_at', 'lastUpdateAt', 'updated_at'])),
      },
      config: {
        provider: text(pick(ddnsConfig, ['provider', 'service'])),
        hostname: text(pick(ddnsConfig, ['hostname', 'domain'])),
        updateIntervalSeconds: count(
          pick(ddnsConfig, ['update_interval_seconds', 'interval_seconds', 'interval']),
        ),
      },
      logSummary: {
        totalEntries: count(pick(ddnsLogs, ['total', 'total_entries', 'count'])) ?? logItems.length,
        successfulUpdates:
          count(pick(ddnsLogs, ['successful', 'success', 'successful_updates'])) ??
          tally(logItems, (item) => {
            const value = text(
              pick(isRecord(item) ? item : {}, ['status', 'result', 'state']),
            )?.toLocaleLowerCase();
            return value === 'success' || value === 'ok' || value === 'updated';
          }),
        failedUpdates:
          count(pick(ddnsLogs, ['failed', 'failures', 'failed_updates'])) ??
          tally(logItems, (item) => {
            const value = text(
              pick(isRecord(item) ? item : {}, ['status', 'result', 'state']),
            )?.toLocaleLowerCase();
            return value === 'failed' || value === 'error';
          }),
        lastEventAt: text(pick(ddnsLogs, ['last_event_at', 'latest', 'last_at'])),
      },
    },
  };
}

export function mapEsim(snapshot: InstanceModuleSnapshot): EsimSnapshot {
  const profiles = sectionRecord(snapshot, 'profiles');
  const euicc = sectionRecord(snapshot, 'euicc');
  const lpac = sectionRecord(snapshot, 'lpacStatus');
  const items = arrayFrom(profiles, ['profiles', 'list', 'items', 'data']).flatMap((item) =>
    isRecord(item) ? [item] : [],
  );
  const enabled = tally(items, (item) => {
    const record = isRecord(item) ? item : {};
    return (
      flag(pick(record, ['enabled', 'is_enabled'])) === true ||
      text(pick(record, ['status', 'state']))?.toLocaleLowerCase() === 'enabled'
    );
  });
  const lpacValue = text(
    pick(lpac, ['status', 'state', 'available']) ?? pick(euicc, ['lpac_status', 'status']),
  )?.toLocaleLowerCase();
  const workModeValue = text(pick(euicc, ['work_mode', 'workMode']))?.toLocaleLowerCase();
  const labels: EsimSafeLabel[] = [];
  for (const item of items.slice(0, 8)) {
    const record = isRecord(item) ? item : {};
    const enabled = flag(pick(record, ['enabled', 'is_enabled']));
    const itemStatus = text(pick(record, ['status', 'state']))?.toLocaleLowerCase();
    const label: EsimSafeLabel =
      itemStatus === 'error' || itemStatus === 'failed'
        ? 'Error'
        : itemStatus === 'pending' || itemStatus === 'downloading'
          ? 'Pending'
          : enabled === true || itemStatus === 'enabled'
            ? 'Enabled'
            : enabled === false || itemStatus === 'disabled'
              ? 'Disabled'
              : 'Provisioned';
    if (!labels.includes(label)) labels.push(label);
  }
  return {
    profileCount: items.length,
    enabledProfileCount: enabled,
    lpacStatus:
      lpacValue === 'available' || lpacValue === 'unavailable' || lpacValue === 'degraded'
        ? lpacValue
        : lpacValue === 'true' || flag(pick(lpac, ['available', 'supported'])) === true
          ? 'available'
          : 'unknown',
    workMode:
      workModeValue === 'idle' || workModeValue === 'working' || workModeValue === 'disabled'
        ? workModeValue
        : 'unknown',
    labels,
  };
}

/** Call capabilities the Hub surfaces as separate panels; each maps to one probe. */
const CALL_FEATURE_PROBES: readonly { readonly key: string; readonly name: string }[] = [
  { key: 'forwarding', name: '呼叫转移' },
  { key: 'volume', name: '通话音量' },
  { key: 'voicemail', name: '语音信箱' },
  { key: 'ims', name: 'IMS 语音' },
];

export function mapCalls(snapshot: InstanceModuleSnapshot): CallsSnapshot {
  const calls = sectionRecord(snapshot, 'calls');
  const history = sectionRecord(snapshot, 'history');
  const settings = sectionRecord(snapshot, 'settings');
  const active =
    count(pick(calls, ['active', 'active_calls', 'current'])) ??
    tally(arrayFrom(calls, ['calls', 'items', 'data', 'list']), (item) => {
      const value = text(
        pick(isRecord(item) ? item : {}, ['state', 'status']),
      )?.toLocaleLowerCase();
      return value === 'active' || value === 'dialing' || value === 'ringing';
    });
  const historyItems = arrayFrom(history, ['calls', 'items', 'history', 'list', 'data']);
  return {
    ...observed(snapshot),
    calls: {
      state: text(pick(calls, ['state', 'status', 'call_status'])),
      total: count(pick(calls, ['total', 'count'])) ?? historyItems.length,
      active,
      ringing: count(pick(calls, ['ringing', 'incoming'])),
      held: count(pick(calls, ['held', 'hold'])),
      failed: count(pick(calls, ['failed', 'error_count'])),
    },
    devices: {
      state: text(pick(settings, ['state', 'status'])) ?? text(pick(calls, ['state', 'status'])),
      total: count(pick(settings, ['total', 'line_count', 'slots'])),
      online: count(pick(settings, ['online'])),
      offline: count(pick(settings, ['offline'])),
      busy: active && active > 0 ? active : count(pick(settings, ['busy'])),
    },
    features: CALL_FEATURE_PROBES.flatMap(({ key, name }): CallFeatureStatus[] => {
      const entry = section(snapshot, key);
      // A probe the firmware never answered is unknown; one that answered is a live verdict.
      if (!entry || entry.state === 'failed') return [];
      if (entry.state === 'unsupported' || entry.state === 'auth-required')
        return [{ name, state: 'unavailable' as const }];
      const message = isRecord(entry.data) ? text(entry.data['message']) : undefined;
      return [{ name, state: 'available' as const, ...(message ? { detail: message } : {}) }];
    }),
  };
}

export function mapNotifications(snapshot: InstanceModuleSnapshot): NotificationsSnapshot {
  const config = sectionRecord(snapshot, 'config');
  const queue = sectionRecord(snapshot, 'queue');
  const logs = sectionRecord(snapshot, 'logs');
  const channels = arrayFrom(config, ['channels', 'items', 'list', 'webhooks']);
  const queueItems = arrayFrom(queue, ['items', 'jobs', 'queue', 'notifications', 'data']);
  const logItems = arrayFrom(logs, ['items', 'logs', 'entries', 'data']);
  const enabledChannels = tally(channels, (item) => {
    const record = isRecord(item) ? item : {};
    return flag(pick(record, ['enabled', 'active'])) !== false;
  });
  return {
    ...observed(snapshot),
    channels: {
      status:
        flag(pick(config, ['enabled'])) === false
          ? 'unavailable'
          : enabledChannels === 0 && channels.length > 0
            ? 'unavailable'
            : enabledChannels < channels.length
              ? 'degraded'
              : statusOf(channels),
      total: count(pick(config, ['total', 'count'])) ?? channels.length,
      enabled: enabledChannels,
      disabled: Math.max(
        0,
        (count(pick(config, ['total', 'count'])) ?? channels.length) - enabledChannels,
      ),
    },
    queue: {
      status: statusOf(queueItems),
      total: count(pick(queue, ['total', 'count'])) ?? queueItems.length,
      pending:
        count(pick(queue, ['pending', 'queued'])) ??
        tally(queueItems, (item) => {
          const value = text(pick(isRecord(item) ? item : {}, ['status', 'state']))
            ?.toLocaleLowerCase()
            .trim();
          return value === 'pending' || value === 'queued';
        }),
      processing:
        count(pick(queue, ['processing', 'in_progress'])) ??
        tally(queueItems, (item) => {
          const value = text(pick(isRecord(item) ? item : {}, ['status', 'state']))
            ?.toLocaleLowerCase()
            .trim();
          return value === 'processing' || value === 'sending';
        }),
      delivered:
        count(pick(queue, ['delivered', 'sent', 'succeeded'])) ??
        tally(queueItems, (item) => {
          const value = text(pick(isRecord(item) ? item : {}, ['status', 'state']))
            ?.toLocaleLowerCase()
            .trim();
          return value === 'delivered' || value === 'sent' || value === 'success';
        }),
      failed:
        count(pick(queue, ['failed', 'errors'])) ??
        tally(queueItems, (item) => {
          const value = text(pick(isRecord(item) ? item : {}, ['status', 'state']))
            ?.toLocaleLowerCase()
            .trim();
          return value === 'failed' || value === 'error';
        }),
    },
    logs: {
      status: statusOf(logItems),
      total: count(pick(logs, ['total', 'count'])) ?? logItems.length,
      info: tally(logItems, (item) => {
        const value = text(pick(isRecord(item) ? item : {}, ['level']))?.toLocaleLowerCase();
        return value === 'info' || value === 'debug';
      }),
      warning: tally(logItems, (item) => {
        const value = text(pick(isRecord(item) ? item : {}, ['level']))?.toLocaleLowerCase();
        return value === 'warn' || value === 'warning';
      }),
      error: tally(logItems, (item) => {
        const value = text(pick(isRecord(item) ? item : {}, ['level']))?.toLocaleLowerCase();
        return value === 'error' || value === 'fatal';
      }),
    },
  };
}

export function mapAutomation(snapshot: InstanceModuleSnapshot): AutomationSnapshot {
  const config = sectionRecord(snapshot, 'config');
  const logs = sectionRecord(snapshot, 'logs');
  const rules = arrayFrom(config, ['rules', 'tasks', 'items', 'list', 'jobs']);
  const logItems = arrayFrom(logs, ['items', 'executions', 'logs', 'entries']);
  const enabledRules = tally(
    rules,
    (item) => flag(pick(isRecord(item) ? item : {}, ['enabled'])) !== false,
  );
  const failedRuns = tally(logItems, (item) => {
    const value = text(
      pick(isRecord(item) ? item : {}, ['status', 'result', 'state']),
    )?.toLocaleLowerCase();
    return value === 'failed' || value === 'error';
  });
  const scheduler = text(pick(config, ['scheduler', 'scheduler_state']))?.toLocaleLowerCase();
  return {
    ...observed(snapshot),
    status: {
      state:
        flag(pick(config, ['enabled'])) === false
          ? 'disabled'
          : failedRuns > 0
            ? 'degraded'
            : logItems.length || rules.length
              ? 'healthy'
              : 'unknown',
      scheduler:
        scheduler === 'active' ||
        scheduler === 'idle' ||
        scheduler === 'paused' ||
        scheduler === 'disabled' ||
        scheduler === 'unavailable'
          ? scheduler
          : flag(pick(config, ['enabled'])) === false
            ? 'disabled'
            : rules.length
              ? 'active'
              : 'idle',
      workers:
        flag(pick(config, ['enabled'])) === false
          ? 'disabled'
          : failedRuns > 0
            ? 'degraded'
            : logItems.length
              ? 'available'
              : 'unavailable',
    },
    tasks: {
      total: count(pick(config, ['total', 'count'])) ?? rules.length,
      enabled: enabledRules,
      disabled: Math.max(
        0,
        (count(pick(config, ['total', 'count'])) ?? rules.length) - enabledRules,
      ),
      running: count(pick(config, ['running'])),
      queued: count(pick(config, ['queued'])),
      succeeded: tally(logItems, (item) => {
        const value = text(
          pick(isRecord(item) ? item : {}, ['status', 'result', 'state']),
        )?.toLocaleLowerCase();
        return value === 'success' || value === 'ok' || value === 'completed';
      }),
      failed: failedRuns,
    },
  };
}

export function mapOta(snapshot: InstanceModuleSnapshot): OtaSnapshot {
  const status = sectionRecord(snapshot, 'status');
  const state = text(pick(status, ['status', 'state', 'phase']))?.toLocaleLowerCase();
  const progress = count(pick(status, ['progress_percent', 'progressPercent', 'progress']));
  const available = flag(pick(status, ['update_available', 'updateAvailable', 'available']));
  return {
    currentVersion: text(pick(status, ['current_version', 'currentVersion', 'version'])),
    status:
      state === 'idle' ||
      state === 'checking' ||
      state === 'up-to-date' ||
      state === 'available' ||
      state === 'downloading' ||
      state === 'verifying' ||
      state === 'installing' ||
      state === 'rebooting' ||
      state === 'completed' ||
      state === 'failed'
        ? state
        : 'unknown',
    progressPercent: progress === undefined ? undefined : Math.max(0, Math.min(100, progress)),
    updateAvailable: available ?? state === 'available',
  };
}

export interface InstanceModuleDataSources {
  readonly overview: { load(instanceId: string, signal: AbortSignal): Promise<OverviewSnapshot> };
  readonly cellular: { load(instanceId: string, signal: AbortSignal): Promise<CellularSnapshot> };
  readonly deviceNetwork: {
    load(instanceId: string, signal: AbortSignal): Promise<DeviceNetworkSnapshot>;
  };
  readonly esim: { load(instanceId: string, signal: AbortSignal): Promise<unknown> };
  readonly calls: { load(instanceId: string, signal: AbortSignal): Promise<CallsSnapshot> };
  readonly notifications: {
    load(instanceId: string, signal: AbortSignal): Promise<unknown>;
  };
  readonly automation: { load(instanceId: string, signal: AbortSignal): Promise<unknown> };
  readonly ota: { load(instanceId: string, signal: AbortSignal): Promise<unknown> };
}

/**
 * One reader, one in-flight cache per module, eight module contracts. The device panel and the
 * fleet drill-down share this so a tab switch never re-probes a device that was just read.
 */
export function createInstanceModuleDataSources(
  reader: InstanceModuleReader = createInstanceModuleApiReader(),
  ttlMs = 15_000,
): InstanceModuleDataSources {
  const cache = new Map<string, { at: number; value: InstanceModuleSnapshot }>();
  const inflight = new Map<string, Promise<InstanceModuleSnapshot>>();
  const read = (module: string) => (instanceId: string, signal: AbortSignal) => {
    const key = `${instanceId}:${module}`;
    const cached = cache.get(key);
    if (cached && Date.now() - cached.at < ttlMs) return Promise.resolve(cached.value);
    const pending = inflight.get(key);
    if (pending) return pending;
    const next = reader.read(instanceId, module, signal).then(
      (value) => {
        cache.set(key, { at: Date.now(), value });
        inflight.delete(key);
        return value;
      },
      (error: unknown) => {
        inflight.delete(key);
        throw error;
      },
    );
    inflight.set(key, next);
    return next;
  };
  return {
    overview: { load: async (id, signal) => mapOverview(await read('overview')(id, signal)) },
    cellular: { load: async (id, signal) => mapCellular(await read('cellular')(id, signal)) },
    deviceNetwork: {
      load: async (id, signal) => mapDeviceNetwork(await read('device-network')(id, signal)),
    },
    esim: { load: async (id, signal) => mapEsim(await read('esim')(id, signal)) },
    calls: { load: async (id, signal) => mapCalls(await read('calls')(id, signal)) },
    notifications: {
      load: async (id, signal) => mapNotifications(await read('notifications')(id, signal)),
    },
    automation: {
      load: async (id, signal) => mapAutomation(await read('automation')(id, signal)),
    },
    ota: { load: async (id, signal) => mapOta(await read('ota')(id, signal)) },
  };
}