hypercore-kb / opencog-kb / language-learning / mvp / test-lg-timing.scm

; test-lg-timing.scm - Test if LgDictNode caching causes issues
;
; Hypothesis: The LgDictNode is created/cached before data is loaded,
; and lg_config_atomspace isn't being called at the right time.

(use-modules (opencog) (opencog exec) (opencog lg))
(use-modules (opencog persist) (opencog persist-rocks))
(use-modules (opencog matrix) (opencog learn))
(use-modules (srfi srfi-1))

(display "=== LG Timing Debug Test ===\n\n")

; Type aliases
(define (ParseNode name) (Anchor (string-append "parse:" name)))
(define (SentenceNode name) (Anchor (string-append "sentence:" name)))
(module-define! (resolve-module '(opencog lg)) 'ParseNode ParseNode)
(module-define! (resolve-module '(opencog lg)) 'SentenceNode SentenceNode)

; === Test 1: Check if LgDict exists before we do anything ===
(display "Test 1: Check pre-existing LgDict atoms\n")
(define pre-existing-dicts (cog-get-atoms 'LgDictNode))
(format #t "  Pre-existing LgDictNodes: ~a\n\n" pre-existing-dicts)

; === Load data FIRST ===
(display "Loading data from RocksDB...\n")
(define rsn (RocksStorageNode "rocks://data/pairs.rdb"))
(cog-open rsn)

(define ala (make-any-link-api))
(define aca (add-count-api ala))
(define pair-stars (add-pair-stars aca))
(pair-stars 'fetch-pairs)

(format #t "Loaded: ~a edges, AtomSpace: ~a\n\n"
        (cog-count-atoms 'Edge)
        (cog-atomspace))

; === Test 2: Create LgDict AFTER loading data ===
(display "Test 2: Create LgDict after data is loaded\n")
(define dict-atom (LgDict "dict-pair"))
(format #t "  Created: ~a\n" dict-atom)
(format #t "  Handle: ~a\n\n" (cog-handle dict-atom))

; === Test 3: Create LgParseLink and check its structure ===
(display "Test 3: Create LgParseLink\n")
(define parse-link
  (LgParseLink
    (Phrase "the cat")
    dict-atom
    (Number 3)
    (cog-atomspace)
    rsn))
(format #t "  Parse link: ~a\n\n" parse-link)

; === Test 4: Execute the parse ===
(display "Test 4: Execute parse\n")
(define result (cog-execute! parse-link))
(format #t "  Result: ~a\n" result)
(format #t "  Result type: ~a\n" (cog-type result))
(if (cog-value? result)
    (format #t "  Value contents: ~a\n" (cog-value->list result))
    (display "  (not a value)\n"))

; === Test 5: Try with fresh dict name ===
(display "\nTest 5: Try with unique dict name\n")
(define unique-name (string-append "dict-pair-" (number->string (current-time))))
(format #t "  Using dict name: ~a\n" unique-name)

; We can't create a new dictionary easily, but let's check if dict-pair
; was ever used before in this session
(define all-dicts (cog-get-atoms 'LgDictNode))
(format #t "  All LgDictNodes now: ~a\n\n" all-dicts)

; === Test 6: Check if external AS is being passed ===
(display "Test 6: Verify AtomSpace passed to LgParseLink\n")
(define parse-outgoing (cog-outgoing-set parse-link))
(format #t "  Outgoing set:\n")
(for-each
  (lambda (atom)
    (format #t "    ~a : ~a\n" (cog-type atom) atom))
  parse-outgoing)

(cog-close rsn)
(display "\n=== Done ===\n")