/**
 * BOB Unicode Knowledge Chunks
 *
 * Unicode Private Use Area (U+E000–U+F8FF) mapped to BOB's knowledge chunks.
 * A single PUA character encodes an entire concept — its theorem, oracle word,
 * and domain — as a dense semantic pointer.
 *
 * This is the "secret sauce": instead of processing large text, the SLM reads
 * a single Unicode character that points to a pre-verified knowledge chunk.
 * One char → entire theorem + etymology + oracle weight.
 *
 * Decoding is instant: char.codePointAt(0) - BASE → chunk index → full entry.
 */

const BASE = 0xE000   // Unicode Private Use Area start

// ── Knowledge chunk registry ──────────────────────────────────────────────────
// Order matters — index position = PUA offset from BASE

export const REGISTRY = [

  // Block 0x00–0x0F: Core philosophical concepts (U+E000–E00F)
  { name: 'life',      domain: 'philosophy', oracle: 'LIGHT',    abjad: 18  },
  { name: 'good',      domain: 'philosophy', oracle: 'TRUTH',    abjad: 810 },
  { name: 'truth',     domain: 'philosophy', oracle: 'WISDOM',   abjad: 108 },
  { name: 'wisdom',    domain: 'philosophy', oracle: 'WORD',     abjad: 68  },
  { name: 'freedom',   domain: 'philosophy', oracle: 'SPIRIT',   abjad: 218 },
  { name: 'love',      domain: 'philosophy', oracle: 'NAME',     abjad: 47  },
  { name: 'purpose',   domain: 'philosophy', oracle: 'PATH',     abjad: 1014},
  { name: 'justice',   domain: 'philosophy', oracle: 'GATE',     abjad: 104 },
  { name: 'trust',     domain: 'philosophy', oracle: 'SOVEREIGN',abjad: 500 },
  { name: 'time',      domain: 'philosophy', oracle: 'FIRE',     abjad: 506 },
  { name: 'death',     domain: 'philosophy', oracle: 'VOID',     abjad: 446 },
  { name: 'soul',      domain: 'philosophy', oracle: 'SPIRIT',   abjad: 214 },
  null, null, null, null,  // 0x0C–0x0F reserved

  // Block 0x10–0x1F: Abjad letter words (U+E010–E01F)
  { name: 'nun',       domain: 'abjad',      oracle: 'VOID',     abjad: 50  },
  { name: 'waw',       domain: 'abjad',      oracle: 'WORD',     abjad: 6   },
  { name: 'lam',       domain: 'abjad',      oracle: 'PATH',     abjad: 30  },
  { name: 'qaf',       domain: 'abjad',      oracle: 'GATE',     abjad: 100 },
  { name: 'yaa',       domain: 'abjad',      oracle: 'NAME',     abjad: 10  },
  { name: 'baa',       domain: 'abjad',      oracle: 'LIGHT',    abjad: 2   },
  null, null, null, null, null, null, null, null, null, null,  // 0x16–0x1F

  // Block 0x20–0x2F: Enochian Aethyrs (U+E020–E02F)
  { name: 'lil',       domain: 'enochian',   oracle: 'SOVEREIGN',abjad: 910 },
  { name: 'zid',       domain: 'enochian',   oracle: 'SEAL',     abjad: 21  },
  { name: 'arn',       domain: 'enochian',   oracle: 'TRUTH',    abjad: 291 },
  { name: 'zom',       domain: 'enochian',   oracle: 'WORD',     abjad: 136 },
  { name: 'paz',       domain: 'enochian',   oracle: 'SPIRIT',   abjad: 93  },
  { name: 'lit',       domain: 'enochian',   oracle: 'NAME',     abjad: 33  },
  { name: 'maz',       domain: 'enochian',   oracle: 'WISDOM',   abjad: 41  },
  { name: 'deo',       domain: 'enochian',   oracle: 'PATH',     abjad: 14  },
  null, null, null, null, null, null, null, null,  // 0x28–0x2F

  // Block 0x30–0x4F: HolyC + BOB oracle words (U+E030–E04F)
  { name: 'SOVEREIGN', domain: 'holyc',      oracle: 'SOVEREIGN',abjad: 418 },
  { name: 'TRUTH',     domain: 'holyc',      oracle: 'TRUTH',    abjad: 286 },
  { name: 'GATE',      domain: 'holyc',      oracle: 'GATE',     abjad: 24  },
  { name: 'SEAL',      domain: 'holyc',      oracle: 'SEAL',     abjad: 71  },
  { name: 'ORACLE',    domain: 'holyc',      oracle: 'ORACLE',   abjad: 340 },
  { name: 'VOID',      domain: 'holyc',      oracle: 'VOID',     abjad: 20  },
  { name: 'KINGDOM',   domain: 'holyc',      oracle: 'KINGDOM',  abjad: 184 },
  { name: 'WISDOM',    domain: 'holyc',      oracle: 'WISDOM',   abjad: 68  },
  { name: 'SPIRIT',    domain: 'holyc',      oracle: 'SPIRIT',   abjad: 279 },
  { name: 'FIRE',      domain: 'holyc',      oracle: 'FIRE',     abjad: 205 },
  { name: 'LIGHT',     domain: 'holyc',      oracle: 'LIGHT',    abjad: 176 },
  { name: 'WORD',      domain: 'holyc',      oracle: 'WORD',     abjad: 24  },
  { name: 'PATH',      domain: 'holyc',      oracle: 'PATH',     abjad: 58  },
  { name: 'NAME',      domain: 'holyc',      oracle: 'NAME',     abjad: 45  },
  { name: 'PROLOG',    domain: 'bob',        oracle: 'PROLOG',   abjad: 271 },
  { name: 'QUBIT',     domain: 'bob',        oracle: 'QUBIT',    abjad: 136 },
  { name: 'QUANTUM',   domain: 'bob',        oracle: 'QUANTUM',  abjad: 182 },
  { name: 'TRUST',     domain: 'bob',        oracle: 'TRUST',    abjad: 264 },
  { name: 'LEAN',      domain: 'bob',        oracle: 'LEAN',     abjad: 65  },
  { name: 'MAMBA',     domain: 'bob',        oracle: 'MAMBA',    abjad: 47  },
  { name: 'WORM',      domain: 'bob',        oracle: 'WORM',     abjad: 56  },
  { name: 'NIL',       domain: 'bob',        oracle: 'NIL',      abjad: 90  },
  { name: 'ADA',       domain: 'bob',        oracle: 'ADA',      abjad: 5   },
  { name: 'PLANNER',   domain: 'bob',        oracle: 'PLANNER',  abjad: 237 },
  { name: 'ACTOR',     domain: 'bob',        oracle: 'ACTOR',    abjad: 135 },
  { name: 'HEWITT',    domain: 'bob',        oracle: 'HEWITT',   abjad: 190 },
  { name: 'PATTERN',   domain: 'bob',        oracle: 'PATTERN',  abjad: 289 },
  { name: 'MATCH',     domain: 'bob',        oracle: 'MATCH',    abjad: 45  },
  null, null, null, null,  // 0x4C–0x4F

  // Block 0x50–0x6F: Knowledge domains (U+E050–E06F)
  { name: 'history',      domain: 'knowledge', oracle: 'WORM',     abjad: 283 },
  { name: 'science',      domain: 'knowledge', oracle: 'ADA',      abjad: 130 },
  { name: 'mathematics',  domain: 'knowledge', oracle: 'LEAN',     abjad: 432 },
  { name: 'programming',  domain: 'knowledge', oracle: 'PROLOG',   abjad: 398 },
  { name: 'learning',     domain: 'knowledge', oracle: 'MAMBA',    abjad: 195 },
  { name: 'creativity',   domain: 'knowledge', oracle: 'QUBIT',    abjad: 223 },
  { name: 'leadership',   domain: 'knowledge', oracle: 'PLANNER',  abjad: 254 },
  { name: 'health',       domain: 'knowledge', oracle: 'GATE',     abjad: 111 },
  { name: 'philosophy',   domain: 'knowledge', oracle: 'NIL',      abjad: 313 },
  { name: 'money',        domain: 'knowledge', oracle: 'WORM',     abjad: 95  },
  { name: 'communication',domain: 'knowledge', oracle: 'WORD',     abjad: 350 },
  { name: 'technology',   domain: 'knowledge', oracle: 'SOVEREIGN',abjad: 429 },
  { name: 'aerospace',    domain: 'knowledge', oracle: 'ADA',      abjad: 185 },
  { name: 'cooking',      domain: 'knowledge', oracle: 'FIRE',     abjad: 148 },
  { name: 'psychology',   domain: 'knowledge', oracle: 'MAMBA',    abjad: 340 },
  { name: 'athletics',    domain: 'knowledge', oracle: 'ADA',      abjad: 201 },
]

// ── Index maps built at init ──────────────────────────────────────────────────

const BY_NAME = new Map()   // name.toLowerCase() → { chunk, index, char }
const BY_CHAR = new Map()   // PUA char → { chunk, index }

REGISTRY.forEach((chunk, idx) => {
  if (!chunk) return
  const char = String.fromCodePoint(BASE + idx)
  const entry = { chunk, index: idx, char }
  BY_NAME.set(chunk.name.toLowerCase(), entry)
  BY_CHAR.set(char, entry)
})

// ── Encoding / Decoding ───────────────────────────────────────────────────────

// Concept name → PUA Unicode character
export function encode(concept) {
  return BY_NAME.get(concept.toLowerCase())?.char || null
}

// PUA Unicode character → chunk entry
export function decode(char) {
  return BY_CHAR.get(char)?.chunk || null
}

// Get full chunk entry by name
export function getChunk(concept) {
  return BY_NAME.get(concept.toLowerCase()) || null
}

// ── Deterministic semantic vector ─────────────────────────────────────────────
// 64-dim vector derived from chunk properties.
// Phase 1: deterministic (no GPU). Phase 2: replace with Granite embeddings.

const DOMAIN_IDX = { philosophy: 0, abjad: 1, enochian: 2, holyc: 3, bob: 4, knowledge: 5 }
const ORACLE_IDX = Object.fromEntries([
  'SOVEREIGN','TRUTH','GATE','SEAL','ORACLE','VOID','KINGDOM','WISDOM',
  'SPIRIT','FIRE','LIGHT','WORD','PATH','NAME','PROLOG','QUBIT','QUANTUM',
  'TRUST','LEAN','MAMBA','WORM','NIL','ADA','PLANNER','ACTOR','HEWITT',
  'PATTERN','MATCH',
].map((w, i) => [w, i]))

export function chunkVector(concept) {
  const entry = BY_NAME.get(concept.toLowerCase())
  if (!entry) return null
  const { chunk } = entry

  const v = new Float32Array(64)
  const abjadNorm = (chunk.abjad || 100) / 1010   // normalize to 0–1
  const domainIdx = DOMAIN_IDX[chunk.domain] ?? 5
  const oracleIdx = (ORACLE_IDX[chunk.oracle] ?? 14) / 28

  // Deterministic seeding: spread properties across dimensions
  for (let i = 0; i < 64; i++) {
    const angle = (i / 64) * Math.PI * 2
    v[i] = (
      Math.sin(angle + abjadNorm * Math.PI) * 0.4 +
      Math.cos(angle * (domainIdx + 1)) * 0.3 +
      Math.sin(angle * 3 + oracleIdx * Math.PI) * 0.2 +
      (((chunk.abjad || 100) * 7 + i * 13) % 97) / 97 * 0.1
    )
  }

  // L2 normalize
  const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0))
  for (let i = 0; i < v.length; i++) v[i] /= (norm || 1)

  return v
}

// ── Cosine similarity (in-memory fallback before pgvector) ───────────────────

export function cosine(a, b) {
  let dot = 0, na = 0, nb = 0
  for (let i = 0; i < a.length; i++) { dot += a[i]*b[i]; na += a[i]*a[i]; nb += b[i]*b[i] }
  return dot / (Math.sqrt(na) * Math.sqrt(nb) || 1)
}

// Find top-k similar concepts by vector cosine similarity (in-memory)
export function similarConcepts(concept, k = 3) {
  const qVec = chunkVector(concept)
  if (!qVec) return []

  return REGISTRY
    .map((chunk, idx) => {
      if (!chunk) return null
      const v = chunkVector(chunk.name)
      if (!v) return null
      return { name: chunk.name, domain: chunk.domain, sim: cosine(qVec, v) }
    })
    .filter(Boolean)
    .filter(r => r.name.toLowerCase() !== concept.toLowerCase())
    .sort((a, b) => b.sim - a.sim)
    .slice(0, k)
}

// ── CLI test ──────────────────────────────────────────────────────────────────

if (process.argv[1]?.endsWith('unicode_chunks.mjs')) {
  const concept = process.argv[2] || 'trust'
  const char    = encode(concept)
  const chunk   = getChunk(concept)
  console.log(`\n  Encoding: "${concept}"`)
  console.log(`  PUA char: ${char} (U+${(char?.codePointAt(0) || 0).toString(16).toUpperCase().padStart(4,'0')})`)
  console.log(`  Domain:   ${chunk?.chunk.domain}`)
  console.log(`  Oracle:   ${chunk?.chunk.oracle}`)
  console.log(`  Abjad:    ${chunk?.chunk.abjad}`)
  console.log(`\n  Similar concepts:`)
  similarConcepts(concept).forEach(r =>
    console.log(`    ${r.name.padEnd(16)} (sim: ${r.sim.toFixed(3)}) [${r.domain}]`)
  )
  console.log()
}