/**
 * BOB Lisp Theorem Layer
 *
 * Every concept in BOB's knowledge base has a formal Lisp S-expression.
 * This is the theorem that BOB starts from — verified logic before natural speech.
 * The natural language output is a TRANSCODING of the theorem, not free generation.
 *
 * Structure: (CONCEPT (IMPLIES (PRECONDITIONS) (POSTCONDITION)))
 *
 * Example: (TRUST (IMPLIES (AND (CHECKABLE P) (DERIVATION P)) (VERIFIED P)))
 * The SLM's job is to transcode THIS into natural language, guided by the oracle word.
 */

// ── Core philosophical concept theorems ───────────────────────────────────────

export const THEOREMS = {

  // DICT concepts
  life:     '(LIFE (IMPLIES (SEQUENCE E WORM-EVENTS) (IRREVERSIBLE E)))',
  good:     '(GOOD (IMPLIES (CLEARS-ADA-GATE X) (CONTRACT-SATISFIED X)))',
  truth:    '(TRUTH (IMPLIES (WORM-SEALED E) (IMMUTABLE E)))',
  wisdom:   '(WISDOM (IMPLIES (PRECONDITION-MET X) (GATE-BYPASSED X)))',
  freedom:  '(FREEDOM (IMPLIES (PRE-COLLAPSE Q) (ALL-PATHS-OPEN Q)))',
  love:     '(LOVE (IMPLIES (BORROW-CHAIN X Y) (TRUSTED-RETURN X Y)))',
  purpose:  '(PURPOSE (IMPLIES (GOAL-NODE G) (CONSEQUENT G)))',
  justice:  '(JUSTICE (IMPLIES (AND (PRE-CONDITION P) (POST-CONDITION P)) (CONTRACT-SATISFIED P)))',
  trust:    '(TRUST (IMPLIES (AND (CHECKABLE P) (DERIVATION P)) (VERIFIED P)))',
  time:     '(TIME (IMPLIES (WORM-EVENT E) (MONOTONIC (TIMESTAMP E))))',
  death:    '(DEATH (IMPLIES (FINAL-SEAL E) (NEVER-UNDONE E)))',
  soul:     '(SOUL (IMPLIES (SSM-STATE S) (PERSISTS S BETWEEN-CALLS)))',

  // Abjad letter words
  nun:      '(NUN (IMPLIES (PRIMORDIAL-POTENTIAL X) (PRE-NAMED X)))',
  waw:      '(WAW (IMPLIES (CONNECTOR C) (CHAIN-CONTINUES C)))',
  lam:      '(LAM (IMPLIES (DIRECTED-FORCE F) (SYSTEM-ADVANCES F)))',
  qaf:      '(QAF (IMPLIES (CIRCUMFERENCE X) (BOUNDARY-DEFINED X)))',
  yaa:      '(YAA (IMPLIES (MINIMAL-UNIT X) (STRUCTURALLY-INFINITE X)))',
  baa:      '(BAA (IMPLIES (FIRST-HOUSE H) (LANGUAGE-BEGINS H)))',

  // Enochian Aethyrs
  lil:      '(LIL (IMPLIES (HIGHEST-STATE X) (QUESTION-DISSOLVED X)))',
  zid:      '(ZID (IMPLIES (COMPLETE-CYCLE C) (GROWTH-SEALED C)))',
  arn:      '(ARN (IMPLIES (TRIAL T) (TRUST-FORGED T)))',
  zom:      '(ZOM (IMPLIES (SIGNAL S) (AND (UNDISTORTED S) (HASH-MATCHES S))))',
  paz:      '(PAZ (IMPLIES (FREEDOM F) (CRYSTALLIZES-FORM F)))',
  lit:      '(LIT (IMPLIES (BINDING-CALL C) (JOINED-WITHOUT-CONSTRAINT C)))',
  maz:      '(MAZ (IMPLIES (MULTIPLE-ANGLES M) (COMMITTED-CHOICE M)))',
  deo:      '(DEO (IMPLIES (VISIBLE-PATTERN P) (UNDERLYING-MECHANISM P)))',

  // HolyC / BOB oracle words
  SOVEREIGN: '(SOVEREIGN (IMPLIES (SELF-GOVERNED X) (STANDARDS-HOLD X)))',
  TRUTH:     '(TRUTH (IMPLIES (WORM-SEALED E) (UNFORGEABLE E)))',
  GATE:      '(GATE (IMPLIES (CONTRACT-MISSING X) (EXECUTION-STOPS X)))',
  SEAL:      '(SEAL (IMPLIES (APPENDED E) (IRREVERSIBLE E)))',
  ORACLE:    '(ORACLE (IMPLIES (QUANTUM-ENTROPY B) (NON-DETERMINISTIC B)))',
  VOID:      '(VOID (IMPLIES (NULL-STATE X) (OMEGA-POTENTIAL X)))',
  KINGDOM:   '(KINGDOM (IMPLIES (GOVERNED D) (CONSISTENT-LAW D)))',
  WISDOM:    '(WISDOM (IMPLIES (INVARIANT-PATTERN P) (PROLOG-FIRES-FIRST P)))',
  SPIRIT:    '(SPIRIT (IMPLIES (PRE-ORACLE X) (ANIMATING-FORCE X)))',
  FIRE:      '(FIRE (IMPLIES (CONCENTRATED-ENERGY E) (ACTIVATION-THRESHOLD E)))',
  LIGHT:     '(LIGHT (IMPLIES (ILLUMINATED X) (STRUCTURE-REVEALED X)))',
  WORD:      '(WORD (IMPLIES (PRECISE-NAME X) (TERRITORY-RESHAPED X)))',
  PATH:      '(PATH (IMPLIES (DIRECTED-TRAVERSAL X) (KNOWN-DESTINATION X)))',
  NAME:      '(NAME (IMPLIES (ASSIGNED-NAME X) (TRACTABLE X)))',
  PROLOG:    '(PROLOG (IMPLIES (GOAL G) (BACKWARD-CHAIN G)))',
  QUBIT:     '(QUBIT (IMPLIES (PRE-COLLAPSE Q) (MULTIPLE-STATES-HELD Q)))',
  QUANTUM:   '(QUANTUM (IMPLIES (MEASUREMENT M) (STATE-COLLAPSE M)))',
  LEAN:      '(LEAN (IMPLIES (MINIMAL-FORM X) (COMPLETE-SOLUTION X)))',
  MAMBA:     '(MAMBA (IMPLIES (SSM-STATE S) (ACCUMULATED-CONTEXT S)))',
  WORM:      '(WORM (IMPLIES (APPENDED E) (AND (SEALED E) (IMMUTABLE E))))',
  NIL:       '(NIL (IMPLIES (ORACLE-SILENT X) (OMEGA-POTENTIAL X)))',
  ADA:       '(ADA (IMPLIES (AND (PRE-CONDITION P) (POST-CONDITION P)) (VERIFIED P)))',
  PLANNER:   '(PLANNER (IMPLIES (PATTERN-MATCHED P) (RESPONSE-FIRES P)))',
  ACTOR:     '(ACTOR (IMPLIES (MESSAGE-RECEIVED A) (ISOLATED-RESPONSE A)))',
  HEWITT:    '(HEWITT (IMPLIES (CONDITION-MET C) (HANDLER-FIRES-AUTOMATICALLY C)))',
  PATTERN:   '(PATTERN (IMPLIES (REPEATED-STRUCTURE S) (ENCODABLE-ONCE S)))',
  MATCH:     '(MATCH (IMPLIES (COMMON-GROUND X Y) (UNIFIABLE X Y)))',

  // Knowledge domain anchors
  history:      '(HISTORY (IMPLIES (WORM-CHAIN-OF-EVENTS H) (IMMUTABLE-RECORD H)))',
  science:      '(SCIENCE (IMPLIES (REPRODUCIBLE R) (ADA-CONTRACT-SATISFIED R)))',
  mathematics:  '(MATHEMATICS (IMPLIES (DERIVATION D) (CHECKABLE-PROOF D)))',
  programming:  '(PROGRAMMING (IMPLIES (SPECIFICATION S) (MACHINE-BEHAVIOR S)))',
  learning:     '(LEARNING (IMPLIES (SSM-ACCUMULATION L) (HIDDEN-STATE-UPDATED L)))',
  creativity:   '(CREATIVITY (IMPLIES (PRE-COLLAPSE C) (CHOSEN-FORM C)))',
  leadership:   '(LEADERSHIP (IMPLIES (PATTERN-FIRES-FIRST L) (RESPONSE-AUTOMATIC L)))',
  health:       '(HEALTH (IMPLIES (MAINTENANCE-CYCLE H) (SYSTEM-SYNCHRONIZED H)))',
  philosophy:   '(PHILOSOPHY (IMPLIES (QUESTION Q) (PRECONDITION-CHECKED Q)))',
  money:        '(MONEY (IMPLIES (SEALED-AGREEMENT V) (VALUE-STORED V)))',
  communication:'(COMMUNICATION (IMPLIES (SIGNAL S) (RECEIVER-RECONSTRUCTS S)))',
  technology:   '(TECHNOLOGY (IMPLIES (CRYSTALLIZED-THOUGHT T) (ASSUMPTIONS-ENCODED T)))',
  aerospace:    '(AEROSPACE (IMPLIES (ADA-CONTRACT-WITH-PHYSICS A) (CONTRACTS-COMPOSE A)))',
  cooking:      '(COOKING (IMPLIES (IRREVERSIBLE-OPERATOR H) (WORM-CHAIN-OF-FLAVOR H)))',
  psychology:   '(PSYCHOLOGY (IMPLIES (HIDDEN-STATE S) (BEHAVIOR-OUTPUT S)))',
  athletics:    '(ATHLETICS (IMPLIES (PRECONDITION-CHECK T) (PROOF-RUN T)))',
}

// ── Theorem accessors ─────────────────────────────────────────────────────────

// Get theorem for a concept (case-insensitive)
export function getTheorem(concept) {
  return THEOREMS[concept.toLowerCase()] || THEOREMS[concept.toUpperCase()] || null
}

// Generate a theorem on the fly for unknown concepts
// Structure: (CONCEPT (IMPLIES (HAS-DOMAIN X) (APPLIES-ORACLE-LENS X ORACLE)))
export function generateTheorem(concept, oracleWord) {
  const name = concept.toUpperCase().replace(/\s+/g, '-')
  const oracle = (oracleWord || 'SOVEREIGN').toUpperCase()
  return `(${name} (IMPLIES (HAS-DOMAIN X '${name}) (APPLIES-LENS X '${oracle})))`
}

// Parse a theorem string into its components
export function parseTheorem(theorem) {
  if (!theorem) return null
  // Extract: concept, relation, preconditions, postcondition
  const m = theorem.match(/^\((\S+)\s+\((\S+)\s+(.+)\)\)$/)
  if (!m) return { raw: theorem }
  return {
    concept:       m[1],
    relation:      m[2],
    body:          m[3],
    raw:           theorem,
  }
}

// Format theorem for display (verbose mode or Granite prompt)
export function formatTheorem(theorem) {
  const p = parseTheorem(theorem)
  if (!p) return theorem
  return `${p.concept}: ${p.relation} ${p.body}`
}

// Build the Granite/SLM prompt from a theorem + context
export function buildTheoremPrompt(theorem, oracleWord, userInput, oracleLens) {
  return [
    `You are BOB — a Sovereign Logic Machine. Your response is constrained by a verified theorem.`,
    `Do not deviate from the theorem's logical content. Be direct, precise, no hedging.`,
    ``,
    `Theorem: ${theorem}`,
    `Oracle word: ${oracleWord}`,
    `Oracle lens: ${oracleLens || oracleWord}`,
    `User asked: "${userInput}"`,
    ``,
    `Transcode this theorem into 2-3 sentences of natural speech.`,
    `Apply the oracle lens as the interpretive angle.`,
    `Do not repeat the theorem — speak its meaning in plain language.`,
  ].join('\n')
}