// Generated, do not edit. sha256:45a1e1f166c06347eecc16618109c15256ed61caf29cc462a558b68275a28363
import { fieldClass } from './policy.js';
import { createAliasRegistry, isSchijnwaarde } from './aliases.js';
import { bucketLabel } from './buckets.js';

const SCHIJN_SOORT = Object.freeze({
  address: 'address',
  externalAddress: 'address',
  automaticLabel: 'address',
  txid: 'txid',
  transactionHash: 'txid',
});

const HANDLE_SOORT = Object.freeze({
  assetId: 'asset',
  accountId: 'account',
  fromAccountId: 'account',
  toAccountId: 'account',
  productId: 'product',
  providerId: 'provider',
  connectionId: 'connection',
  sourceId: 'walletSource',
  labelId: 'label',
  eventId: 'event',
  scheduleId: 'schedule',
  profileId: 'profile',
  walletTransactionId: 'walletTransaction',
  resolvedEventId: 'event',
  createdEventId: 'event',
  createdAccountId: 'account',
  createdValuationId: 'valuation',
  principalAssetId: 'asset',
  payoutAssetId: 'asset',
});

export function createTranslator({ secret, precision } = {}) {
  const stand = Object.freeze({ rawValues: false, ...(precision ?? {}) });
  const raw = stand.rawValues === true;
  const registry = createAliasRegistry({ secret });
  const gedeeld = new Set();

  const uitgaand = new Map();

  function onthoudUit(uit, echt) {
    uitgaand.set(uit, echt);
    return uit;
  }

  function veld(naam, waarde, entiteit, tabel, rol) {
    const klasse = fieldClass(naam, tabel);

    const logNaam = (tabel != null && klasse !== fieldClass(naam)) ? `${tabel}.${naam}` : naam;

    if (klasse === null || klasse === 'drop') return undefined;

    if (waarde === null || waarde === undefined) {
      gedeeld.add(logNaam);
      return null;
    }

    switch (klasse) {
      case 'plain':
      case 'rate':
        gedeeld.add(logNaam);
        return waarde;

      case 'quantity':
      case 'quantityFiat': {
        if (raw) { gedeeld.add(logNaam); return waarde; }
        const emmeren = klasse === 'quantity'
          ? stand.bucketQuantities !== false
          : (rol === 'total' ? stand.bucketTotals !== false : stand.bucketAmounts !== false);
        if (!emmeren) { gedeeld.add(logNaam); return waarde; }
        const label = bucketLabel(Number(waarde), klasse === 'quantityFiat' ? 'FINE' : 'COARSE');
        if (label === null) return undefined;
        gedeeld.add(logNaam);
        return label;
      }

      case 'chain': {
        const soort = SCHIJN_SOORT[naam];
        if (!soort) return undefined;
        gedeeld.add(logNaam);
        if (raw) return waarde;
        return onthoudUit(registry.alias(soort, String(waarde)), String(waarde));
      }

      case 'handle': {
        if (raw) { gedeeld.add(logNaam); return waarde; }
        const soort = naam === 'id' ? (entiteit || 'record') : (HANDLE_SOORT[naam] || 'text');
        gedeeld.add(logNaam);
        return onthoudUit(registry.handle(soort, String(waarde)), String(waarde));
      }

      default:
        throw new Error(`no handling for class '${klasse}' (field '${naam}')`);
    }
  }

  function toAi(waarde, opties = {}) {
    const entiteit = opties.entity || null;
    const tabel = opties.table || null;
    const rol = opties.role || 'row';
    if (Array.isArray(waarde)) return waarde.map(v => toAi(v, opties));
    if (waarde === null || typeof waarde !== 'object') return waarde;

    const uit = {};
    for (const [naam, v] of Object.entries(waarde)) {
      const vertaald = (v !== null && typeof v === 'object')
        ? (fieldClass(naam, tabel) === null ? undefined : toAi(v, {}))
        : veld(naam, v, entiteit, tabel, rol);
      if (vertaald !== undefined) uit[naam] = vertaald;
    }
    return uit;
  }

  function fromAi(tekst) {
    if (typeof tekst !== 'string') return { text: tekst, unresolved: [] };
    let uit = tekst;

    const sleutels = [...uitgaand.keys()].sort((a, b) => b.length - a.length);
    for (const s of sleutels) uit = uit.split(s).join(uitgaand.get(s));

    const unresolved = [];
    for (const m of uit.matchAll(/\b(?:bc1q[0-9a-z]{38}|xpub[0-9A-Za-z]{107}|[0-9a-z]{64})\b/g)) {
      if (isSchijnwaarde(m[0])) unresolved.push(m[0]);
    }
    return { text: uit, unresolved };
  }

  return {
    toAi,
    fromAi,
    beginCall() { gedeeld.clear(); },
    fieldsShared: () => [...gedeeld].sort(),
    resolve: uit => registry.resolve(uit),
    precision: stand,
  };
}