const { GraphDB, getVersion } = require('rust-kgdb')

console.log(`rust-kgdb v${getVersion()}`)

// Create database with base URI
const db = new GraphDB('http://example.org/my-app')

// Load RDF data (N-Triples format)
db.loadTtl(`
  <http://example.org/alice> <http://xmlns.com/foaf/0.1/name> "Alice" .
  <http://example.org/alice> <http://xmlns.com/foaf/0.1/age> "28"^^<http://www.w3.org/2001/XMLSchema#integer> .
  <http://example.org/bob> <http://xmlns.com/foaf/0.1/name> "Bob" .
  <http://example.org/alice> <http://xmlns.com/foaf/0.1/knows> <http://example.org/bob> .
`, null)

// SPARQL SELECT query
const results = db.querySelect('SELECT ?name WHERE { ?person <http://xmlns.com/foaf/0.1/name> ?name }')
console.log('Names:', results.map(r => r.bindings.name))

// SPARQL ASK query
const hasAlice = db.queryAsk('ASK { <http://example.org/alice> ?p ?o }')
console.log('Has Alice:', hasAlice)  // true

// SPARQL CONSTRUCT query
const graph = db.queryConstruct('CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }')
console.log('Graph:', graph)

// Count triples
console.log('Triple count:', db.countTriples())

// Named graphs
db.loadTtl('<http://x> <http://y> <http://z> .', 'http://example.org/graph1')

const {
  GraphFrame,
  friendsGraph,
  completeGraph,
  chainGraph,
  starGraph,
  cycleGraph,
  binaryTreeGraph,
  bipartiteGraph
} = require('rust-kgdb')

// Create graph from vertices and edges
const graph = new GraphFrame(
  JSON.stringify([{id: "alice"}, {id: "bob"}, {id: "carol"}, {id: "dave"}]),
  JSON.stringify([
    {src: "alice", dst: "bob"},
    {src: "bob", dst: "carol"},
    {src: "carol", dst: "dave"},
    {src: "dave", dst: "alice"}
  ])
)

// Graph statistics
console.log('Vertices:', graph.vertexCount())  // 4
console.log('Edges:', graph.edgeCount())       // 4

// === PageRank Algorithm ===
const ranks = JSON.parse(graph.pageRank(0.15, 20))  // damping=0.15, iterations=20
console.log('PageRank:', ranks)
// { ranks: { alice: 0.25, bob: 0.25, carol: 0.25, dave: 0.25 } }

// === Connected Components ===
const components = JSON.parse(graph.connectedComponents())
console.log('Components:', components)

// === Triangle Counting (WCOJ Optimized) ===
const k4 = completeGraph(4)  // K4 has exactly 4 triangles
console.log('Triangles in K4:', k4.triangleCount())  // 4

const k5 = completeGraph(5)  // K5 has exactly 10 triangles (C(5,3))
console.log('Triangles in K5:', k5.triangleCount())  // 10

// === Motif Pattern Matching ===
const chain = chainGraph(4)  // v0 -> v1 -> v2 -> v3

// Find single edges
const edges = JSON.parse(chain.find("(a)-[]->(b)"))
console.log('Edge patterns:', edges.length)  // 3

// Find two-hop paths
const twoHop = JSON.parse(chain.find("(a)-[]->(b); (b)-[]->(c)"))
console.log('Two-hop patterns:', twoHop.length)  // 2 (v0->v1->v2, v1->v2->v3)

// === Factory Functions ===
const friends = friendsGraph()        // Social network with 6 vertices
const star = starGraph(5)             // Hub with 5 spokes (6 vertices, 5 edges)
const complete = completeGraph(4)     // K4 complete graph
const cycle = cycleGraph(5)           // Pentagon cycle (5 vertices, 5 edges)
const tree = binaryTreeGraph(3)       // Binary tree depth 3
const bipartite = bipartiteGraph(3, 4) // 3 left + 4 right vertices

console.log('Star graph:', star.vertexCount(), 'vertices,', star.edgeCount(), 'edges')
console.log('Cycle graph:', cycle.vertexCount(), 'vertices,', cycle.edgeCount(), 'edges')

const { GraphFrame, completeGraph, chainGraph, cycleGraph, friendsGraph } = require('rust-kgdb')

// === Basic Motif Syntax ===
// (a)-[]->(b)              Single edge from a to b
// (a)-[e]->(b)             Named edge 'e' from a to b
// (a)-[]->(b); (b)-[]->(c) Two-hop path (chain pattern)
// !(a)-[]->(b)             Negation (edge does NOT exist)

// === Find Single Edges ===
const chain = chainGraph(5)  // v0 -> v1 -> v2 -> v3 -> v4
const edges = JSON.parse(chain.find("(a)-[]->(b)"))
console.log('All edges:', edges.length)  // 4

// === Two-Hop Paths (Friend-of-Friend Pattern) ===
const twoHop = JSON.parse(chain.find("(a)-[]->(b); (b)-[]->(c)"))
console.log('Two-hop paths:', twoHop.length)  // 3
// v0->v1->v2, v1->v2->v3, v2->v3->v4

// === Three-Hop Paths ===
const threeHop = JSON.parse(chain.find("(a)-[]->(b); (b)-[]->(c); (c)-[]->(d)"))
console.log('Three-hop paths:', threeHop.length)  // 2

// === Triangle Pattern (Cycle of Length 3) ===
const k4 = completeGraph(4)  // K4 has triangles
const triangles = JSON.parse(k4.find("(a)-[]->(b); (b)-[]->(c); (c)-[]->(a)"))
// Filter to avoid counting same triangle multiple times
const uniqueTriangles = triangles.filter(t => t.a < t.b && t.b < t.c)
console.log('Triangles in K4:', uniqueTriangles.length)  // 4

// === Star Pattern (Hub with Multiple Spokes) ===
const social = new GraphFrame(
  JSON.stringify([
    {id: "influencer"},
    {id: "follower1"}, {id: "follower2"}, {id: "follower3"}
  ]),
  JSON.stringify([
    {src: "influencer", dst: "follower1"},
    {src: "influencer", dst: "follower2"},
    {src: "influencer", dst: "follower3"}
  ])
)
// Find hub pattern: someone with 2+ outgoing edges
const hubPattern = JSON.parse(social.find("(hub)-[]->(f1); (hub)-[]->(f2)"))
console.log('Hub patterns (2+ followers):', hubPattern.length)

// === Reciprocal Relationship (Mutual Friends) ===
const mutual = new GraphFrame(
  JSON.stringify([{id: "alice"}, {id: "bob"}, {id: "carol"}]),
  JSON.stringify([
    {src: "alice", dst: "bob"},
    {src: "bob", dst: "alice"},  // Reciprocal
    {src: "bob", dst: "carol"}   // One-way
  ])
)
const reciprocal = JSON.parse(mutual.find("(a)-[]->(b); (b)-[]->(a)"))
console.log('Mutual relationships:', reciprocal.length)  // 2 (alice<->bob counted twice)

// === Diamond Pattern (Common in Fraud Detection) ===
// A -> B, A -> C, B -> D, C -> D (convergence point D)
const diamond = new GraphFrame(
  JSON.stringify([{id: "A"}, {id: "B"}, {id: "C"}, {id: "D"}]),
  JSON.stringify([
    {src: "A", dst: "B"},
    {src: "A", dst: "C"},
    {src: "B", dst: "D"},
    {src: "C", dst: "D"}
  ])
)
const diamondPattern = JSON.parse(diamond.find(
  "(a)-[]->(b); (a)-[]->(c); (b)-[]->(d); (c)-[]->(d)"
))
console.log('Diamond patterns:', diamondPattern.length)  // 1

// === Use Case: Fraud Ring Detection ===
// Find circular money transfers: A -> B -> C -> A
const transactions = new GraphFrame(
  JSON.stringify([
    {id: "acc001"}, {id: "acc002"}, {id: "acc003"}, {id: "acc004"}
  ]),
  JSON.stringify([
    {src: "acc001", dst: "acc002", amount: 10000},
    {src: "acc002", dst: "acc003", amount: 9900},
    {src: "acc003", dst: "acc001", amount: 9800},  // Suspicious cycle!
    {src: "acc003", dst: "acc004", amount: 5000}   // Normal transfer
  ])
)
const cycles = JSON.parse(transactions.find(
  "(a)-[]->(b); (b)-[]->(c); (c)-[]->(a)"
))
console.log('Circular transfer patterns:', cycles.length)  // Found fraud ring!

// === Use Case: Recommendation (Friends-of-Friends not yet connected) ===
const network = friendsGraph()
const fofPattern = JSON.parse(network.find("(a)-[]->(b); (b)-[]->(c)"))
// Filter: a != c and no direct edge a->c (potential recommendation)
console.log('Friend-of-friend patterns for recommendations:', fofPattern.length)

const { EmbeddingService } = require('rust-kgdb')

const service = new EmbeddingService()

// === Store Vector Embeddings (384 dimensions) ===
service.storeVector('entity1', new Array(384).fill(0.1))
service.storeVector('entity2', new Array(384).fill(0.15))
service.storeVector('entity3', new Array(384).fill(0.9))

// Retrieve stored vector
const vec = service.getVector('entity1')
console.log('Vector dimension:', vec.length)  // 384

// Count stored vectors
console.log('Total vectors:', service.countVectors())  // 3

// === Similarity Search ===
// Find top 10 entities similar to 'entity1' with threshold 0.0
const similar = JSON.parse(service.findSimilar('entity1', 10, 0.0))
console.log('Similar entities:', similar)
// Returns entities sorted by cosine similarity

// === Multi-Provider Composite Embeddings ===
// Store embeddings from multiple providers (OpenAI, Voyage, Cohere)
service.storeComposite('product_123', JSON.stringify({
  openai: new Array(384).fill(0.1),
  voyage: new Array(384).fill(0.2),
  cohere: new Array(384).fill(0.3)
}))

// Retrieve composite embedding
const composite = service.getComposite('product_123')
console.log('Composite embedding:', composite ? 'stored' : 'not found')

// Count composite embeddings
console.log('Total composites:', service.countComposites())

// === Composite Similarity Search (RRF Aggregation) ===
// Find similar using Reciprocal Rank Fusion across multiple providers
const compositeSimilar = JSON.parse(service.findSimilarComposite('product_123', 10, 0.5, 'rrf'))
console.log('Similar (composite RRF):', compositeSimilar)

// === Use Case: Semantic Product Search ===
// Store product embeddings
const products = ['laptop', 'phone', 'tablet', 'keyboard', 'mouse']
products.forEach((product, i) => {
  // In production, use actual embeddings from OpenAI/Cohere/etc
  const embedding = new Array(384).fill(0).map((_, j) => Math.sin(i * 0.1 + j * 0.01))
  service.storeVector(product, embedding)
})

// Find similar products
const relatedToLaptop = JSON.parse(service.findSimilar('laptop', 5, 0.0))
console.log('Products similar to laptop:', relatedToLaptop)

// Triggers automatically generate embeddings when data changes
// Configure triggers to fire on INSERT/UPDATE/DELETE events

// Example: Auto-embed new entities on insert
const triggerConfig = {
  name: 'auto_embed_on_insert',
  event: 'AfterInsert',
  action: {
    type: 'GenerateEmbedding',
    source: 'Subject',       // Embed the subject of the triple
    provider: 'openai'       // Use OpenAI provider
  }
}

// Multiple triggers for different providers
const triggers = [
  { name: 'embed_openai', provider: 'openai' },
  { name: 'embed_voyage', provider: 'voyage' },
  { name: 'embed_cohere', provider: 'cohere' }
]

// Each trigger fires independently, creating composite embeddings

// rust-kgdb supports multiple embedding providers:
//
// Built-in Providers:
// - 'openai'    → text-embedding-3-small (1536 or 384 dim)
// - 'voyage'    → voyage-2, voyage-lite-02-instruct
// - 'cohere'    → embed-v3
// - 'anthropic' → Via Voyage partnership
// - 'mistral'   → mistral-embed
// - 'jina'      → jina-embeddings-v2
// - 'ollama'    → Local models (llama, mistral, etc.)
// - 'hf-tei'    → HuggingFace Text Embedding Inference
//
// Provider Configuration (Rust-side):

const providerConfig = {
  providers: {
    openai: {
      api_key: process.env.OPENAI_API_KEY,
      model: 'text-embedding-3-small',
      dimensions: 384
    },
    voyage: {
      api_key: process.env.VOYAGE_API_KEY,
      model: 'voyage-2',
      dimensions: 1024
    },
    cohere: {
      api_key: process.env.COHERE_API_KEY,
      model: 'embed-english-v3.0',
      dimensions: 384
    },
    ollama: {
      base_url: 'http://localhost:11434',
      model: 'nomic-embed-text',
      dimensions: 768
    }
  },
  default_provider: 'openai'
}

// Why Multi-Provider?
// Google Research (arxiv.org/abs/2508.21038) shows single embeddings hit
// a "recall ceiling" - different providers capture different semantic aspects:
// - OpenAI: General semantic understanding
// - Voyage: Domain-specific (legal, financial, code)
// - Cohere: Multilingual support
// - Ollama: Privacy-preserving local inference

// Aggregation Strategies for composite search:
// - 'rrf'     → Reciprocal Rank Fusion (recommended)
// - 'max'     → Maximum score across providers
// - 'avg'     → Weighted average
// - 'voting'  → Consensus (entity must appear in N providers)

const { DatalogProgram, evaluateDatalog, queryDatalog } = require('rust-kgdb')

const program = new DatalogProgram()

// === Add Facts ===
program.addFact(JSON.stringify({predicate: 'parent', terms: ['alice', 'bob']}))
program.addFact(JSON.stringify({predicate: 'parent', terms: ['bob', 'charlie']}))
program.addFact(JSON.stringify({predicate: 'parent', terms: ['charlie', 'dave']}))

console.log('Facts:', program.factCount())  // 3

// === Add Rules ===
// Rule 1: grandparent(X, Z) :- parent(X, Y), parent(Y, Z)
program.addRule(JSON.stringify({
  head: {predicate: 'grandparent', terms: ['?X', '?Z']},
  body: [
    {predicate: 'parent', terms: ['?X', '?Y']},
    {predicate: 'parent', terms: ['?Y', '?Z']}
  ]
}))

// Rule 2: ancestor(X, Y) :- parent(X, Y)
program.addRule(JSON.stringify({
  head: {predicate: 'ancestor', terms: ['?X', '?Y']},
  body: [
    {predicate: 'parent', terms: ['?X', '?Y']}
  ]
}))

// Rule 3: ancestor(X, Z) :- parent(X, Y), ancestor(Y, Z) (transitive closure)
program.addRule(JSON.stringify({
  head: {predicate: 'ancestor', terms: ['?X', '?Z']},
  body: [
    {predicate: 'parent', terms: ['?X', '?Y']},
    {predicate: 'ancestor', terms: ['?Y', '?Z']}
  ]
}))

console.log('Rules:', program.ruleCount())  // 3

// === Evaluate Program ===
const result = evaluateDatalog(program)
console.log('Evaluation result:', result)

// === Query Derived Facts ===
const grandparents = JSON.parse(queryDatalog(program, 'grandparent'))
console.log('Grandparent relations:', grandparents)
// alice is grandparent of charlie
// bob is grandparent of dave

const ancestors = JSON.parse(queryDatalog(program, 'ancestor'))
console.log('Ancestor relations:', ancestors)
// alice->bob, alice->charlie, alice->dave
// bob->charlie, bob->dave
// charlie->dave

const {
  chainGraph,
  starGraph,
  cycleGraph,
  pregelShortestPaths
} = require('rust-kgdb')

// === Shortest Paths in Chain Graph ===
const chain = chainGraph(10)  // v0 -> v1 -> v2 -> ... -> v9

// Run Pregel shortest paths from v0
const chainResult = JSON.parse(pregelShortestPaths(chain, 'v0', 20))
console.log('Chain shortest paths from v0:', chainResult)
// Expected: { v0: 0, v1: 1, v2: 2, v3: 3, ..., v9: 9 }

// === Shortest Paths in Star Graph ===
const star = starGraph(5)  // hub connected to spoke0...spoke4

// Run Pregel from hub (center vertex)
const starResult = JSON.parse(pregelShortestPaths(star, 'hub', 10))
console.log('Star shortest paths from hub:', starResult)
// Expected: hub=0, all spokes=1

// === Shortest Paths in Cycle Graph ===
const cycle = cycleGraph(6)  // v0 -> v1 -> v2 -> v3 -> v4 -> v5 -> v0

const cycleResult = JSON.parse(pregelShortestPaths(cycle, 'v0', 20))
console.log('Cycle shortest paths from v0:', cycleResult)
// In directed cycle: v0=0, v1=1, v2=2, v3=3, v4=4, v5=5

// === Custom Graph for Pregel ===
const customGraph = new (require('rust-kgdb').GraphFrame)(
  JSON.stringify([
    {id: "server1"},
    {id: "server2"},
    {id: "server3"},
    {id: "client"}
  ]),
  JSON.stringify([
    {src: "client", dst: "server1"},
    {src: "client", dst: "server2"},
    {src: "server1", dst: "server3"},
    {src: "server2", dst: "server3"}
  ])
)

const networkResult = JSON.parse(pregelShortestPaths(customGraph, 'client', 10))
console.log('Network shortest paths from client:', networkResult)
// client=0, server1=1, server2=1, server3=2

const {
  friendsGraph,
  chainGraph,
  starGraph,
  completeGraph,
  cycleGraph,
  binaryTreeGraph,
  bipartiteGraph,
} = require('rust-kgdb')

// === friendsGraph() - Social Network ===
// Pre-built social network for testing
const friends = friendsGraph()
console.log('Friends graph:', friends.vertexCount(), 'people')

// === chainGraph(n) - Linear Path ===
// v0 -> v1 -> v2 -> ... -> v(n-1)
const chain5 = chainGraph(5)
console.log('Chain(5):', chain5.vertexCount(), 'vertices,', chain5.edgeCount(), 'edges')
// 5 vertices, 4 edges

// === starGraph(spokes) - Hub-Spoke ===
// hub -> spoke0, hub -> spoke1, ..., hub -> spoke(n-1)
const star6 = starGraph(6)
console.log('Star(6):', star6.vertexCount(), 'vertices,', star6.edgeCount(), 'edges')
// 7 vertices (1 hub + 6 spokes), 6 edges

// === completeGraph(n) - K_n Complete Graph ===
// Every vertex connected to every other vertex
const k4 = completeGraph(4)
console.log('K4:', k4.vertexCount(), 'vertices,', k4.edgeCount(), 'edges')
// 4 vertices, 6 edges (bidirectional = 12)
console.log('K4 triangles:', k4.triangleCount())  // 4 triangles

// === cycleGraph(n) - Circular ===
// v0 -> v1 -> v2 -> ... -> v(n-1) -> v0
const cycle5 = cycleGraph(5)
console.log('Cycle(5):', cycle5.vertexCount(), 'vertices,', cycle5.edgeCount(), 'edges')
// 5 vertices, 5 edges

// === binaryTreeGraph(depth) - Binary Tree ===
// Complete binary tree with given depth
const tree3 = binaryTreeGraph(3)
console.log('BinaryTree(3):', tree3.vertexCount(), 'vertices')
// 2^4 - 1 = 15 vertices for depth 3

// === bipartiteGraph(left, right) - Two Sets ===
// All left vertices connected to all right vertices
const bp34 = bipartiteGraph(3, 4)
console.log('Bipartite(3,4):', bp34.vertexCount(), 'vertices,', bp34.edgeCount(), 'edges')
// 7 vertices, 12 edges (3 * 4)