app/app/api/calculate-graph/route.ts

import { NextRequest, NextResponse } from 'next/server';
import { cookies } from 'next/headers';
import { UMAP } from 'umap-js';

/**
 * POST /api/calculate-graph
 *
 * Calculates 3D coordinates for all nodes using UMAP dimensionality reduction.
 * This route:
 * 1. Fetches all nodes with embeddings but no 3D coordinates
 * 2. Runs UMAP to reduce embeddings from 768-D to 3-D
 * 3. Updates each node with its calculated 3D coordinates
 */
export async function POST(request: NextRequest) {
  const cookieStore = await cookies();
  const surrealJwt = cookieStore.get('ponderants-auth')?.value;

  if (!surrealJwt) {
    return NextResponse.json({ error: 'Not authenticated' }, { status: 401 });
  }

  try {
    // NOTE: For the hackathon, we use root credentials instead of JWT auth for simplicity.
    // In production, this should use user-scoped authentication with proper SCOPE configuration.
    const db = new (await import('surrealdb')).default();
    await db.connect(process.env.SURREALDB_URL!);
    await db.signin({
      username: process.env.SURREALDB_USER!,
      password: process.env.SURREALDB_PASS!,
    });
    await db.use({
      namespace: process.env.SURREALDB_NS!,
      database: process.env.SURREALDB_DB!,
    });

    // Get the user's DID from the JWT to filter nodes
    const jwt = require('jsonwebtoken');
    const decoded = jwt.decode(surrealJwt) as { did: string };
    const userDid = decoded?.did;

    if (!userDid) {
      return NextResponse.json({ error: 'Invalid authentication token' }, { status: 401 });
    }

    // 1. Fetch all nodes that have an embedding but no coords_3d (filtered by user_did)
    const query = `SELECT id, embedding FROM node WHERE user_did = $userDid AND embedding != NONE AND coords_3d = NONE`;
    const results = await db.query<[Array<{ id: string; embedding: number[] }>]>(query, { userDid });

    const nodes = results[0] || [];

    if (nodes.length < 3) {
      // UMAP needs at least 3 points to work well
      return NextResponse.json(
        { message: 'Not enough nodes to map. Create at least 3 nodes with content.' },
        { status: 200 }
      );
    }

    console.log(`[Calculate Graph] Processing ${nodes.length} nodes for UMAP projection`);

    // 2. Prepare data for UMAP
    const embeddings = nodes.map((n) => n.embedding);

    // 3. Run UMAP to reduce 768-D (or 1536-D) to 3-D
    const umap = new UMAP({
      nComponents: 3,
      nNeighbors: Math.min(15, nodes.length - 1), // nNeighbors must be < sample size
      minDist: 0.1,
      spread: 1.0,
    });

    console.log('[Calculate Graph] Running UMAP dimensionality reduction...');
    const coords_3d_array = await umap.fitAsync(embeddings);
    console.log('[Calculate Graph] ✓ UMAP projection complete');

    // 4. Update nodes in SurrealDB with their new 3D coords
    for (let i = 0; i < nodes.length; i++) {
      const node = nodes[i];
      const coords = coords_3d_array[i];

      await db.merge(node.id, {
        coords_3d: [coords[0], coords[1], coords[2]],
      });
    }

    console.log(`[Calculate Graph] ✓ Updated ${nodes.length} nodes with 3D coordinates`);

    return NextResponse.json({
      success: true,
      nodes_mapped: nodes.length,
    });
  } catch (error) {
    console.error('[Calculate Graph] Error:', error);
    return NextResponse.json(
      { error: 'Failed to calculate graph' },
      { status: 500 }
    );
  }
}