import OpenAI from 'openai'

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
})

export async function generateEmbedding(text: string): Promise<number[]> {
  // Validate input
  if (!text || text.trim().length === 0) {
    throw new Error('Embedding text cannot be empty')
  }

  // Truncate to 8191 tokens (model limit)
  const truncated = text.slice(0, 32000) // ~8k tokens approx

  // Generate embedding
  const response = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: truncated,
    encoding_format: 'float',
  })

  if (response.data.length === 0) {
    throw new Error('OpenAI returned empty embedding')
  }

  return response.data[0].embedding
}

import { generateEmbedding } from '@/lib/ai/embeddings'

// Generate embedding for custom metric
const metricDescription = `
  Project Delivery Time: Average days from project kickoff to completion.
  Target: 30 days. Current: 42 days.
  Industry: Construction. Department: Operations.
`

const embedding = await generateEmbedding(metricDescription)
// Returns: Float32Array of 1536 values

import prisma from '@/lib/prisma'
import { generateEmbedding } from '@/lib/ai/embeddings'

async function createCustomMetricWithEmbedding(data: {
  clientKPIId: string
  metricName: string
  metricValue: number
  unit: string
  recordDate: Date
  description: string // For embedding generation
}) {
  // Generate embedding from description
  const embedding = await generateEmbedding(
    `${data.metricName}: ${data.description}. Value: ${data.metricValue} ${data.unit}`
  )

  // Convert embedding to PostgreSQL vector format
  const vectorString = `[${embedding.join(',')}]`

  // Insert with raw SQL (Prisma limitation)
  await prisma.$executeRawUnsafe(
    `
    INSERT INTO custom_metrics (
      id, client_kpi_id, metric_name, metric_value, unit, record_date, embedding, created_at
    ) VALUES (
      $1, $2, $3, $4, $5, $6, $7::vector, $8
    )
    `,
    crypto.randomUUID(), // id (manual cuid generation)
    data.clientKPIId,
    data.metricName,
    data.metricValue,
    data.unit,
    data.recordDate,
    vectorString, // Cast to vector type
    new Date()
  )
}

async function addEmbeddingToExistingMetric(metricId: string, description: string) {
  const embedding = await generateEmbedding(description)
  const vectorString = `[${embedding.join(',')}]`

  await prisma.$executeRawUnsafe(
    `UPDATE custom_metrics SET embedding = $1::vector WHERE id = $2`,
    vectorString,
    metricId
  )
}

async function findSimilarMetrics(query: string, topK: number = 5) {
  // Generate embedding for query
  const queryEmbedding = await generateEmbedding(query)
  const vectorString = `[${queryEmbedding.join(',')}]`

  // Execute similarity search
  const results = await prisma.$queryRawUnsafe<
    Array<{
      id: string
      metric_name: string
      metric_value: number
      similarity: number
    }>
  >(
    `
    SELECT
      id,
      metric_name,
      metric_value,
      (1 - (embedding <=> $1::vector)) AS similarity
    FROM custom_metrics
    WHERE embedding IS NOT NULL
    ORDER BY embedding <=> $1::vector  -- Cosine distance
    LIMIT $2
    `,
    vectorString,
    topK
  )

  return results
}

// User query: "Show me metrics related to customer satisfaction"
const similar = await findSimilarMetrics('customer satisfaction scores and NPS', 5)

// Results (ordered by similarity):
// [
//   { metric_name: 'Net Promoter Score', metric_value: 72, similarity: 0.89 },
//   { metric_name: 'Customer Satisfaction (CSAT)', metric_value: 4.2, similarity: 0.85 },
//   { metric_name: 'Support Ticket Resolution Time', metric_value: 18, similarity: 0.67 },
//   ...
// ]

async function findSimilarMetricsForTenant(query: string, tenantId: string, topK: number = 5) {
  const queryEmbedding = await generateEmbedding(query)
  const vectorString = `[${queryEmbedding.join(',')}]`

  // Set tenant context for RLS
  await prisma.$executeRawUnsafe(`SET LOCAL app.tenant_id = $1`, tenantId)

  const results = await prisma.$queryRawUnsafe<
    Array<{
      id: string
      metric_name: string
      similarity: number
    }>
  >(
    `
    SELECT
      cm.id,
      cm.metric_name,
      (1 - (cm.embedding <=> $1::vector)) AS similarity
    FROM custom_metrics cm
    INNER JOIN client_kpis ck ON cm.client_kpi_id = ck.id
    WHERE cm.embedding IS NOT NULL
      AND ck.tenant_id = $2
    ORDER BY cm.embedding <=> $1::vector
    LIMIT $3
    `,
    vectorString,
    tenantId,
    topK
  )

  return results
}

// app/api/ai/query/route.ts
import { NextRequest, NextResponse } from 'next/server'
import { generateEmbedding } from '@/lib/ai/embeddings'
import { findSimilarMetricsForTenant } from '@/lib/ai/vector-search'
import OpenAI from 'openai'

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY })

export async function POST(request: NextRequest) {
  const { query } = await request.json()
  const tenantId = request.headers.get('x-tenant-id')!

  // Step 1: Find relevant metrics via vector search
  const relevantMetrics = await findSimilarMetricsForTenant(query, tenantId, 5)

  // Step 2: Construct augmented prompt
  const context = relevantMetrics
    .map((m) => `- ${m.metric_name}: ${m.metric_value} (similarity: ${m.similarity.toFixed(2)})`)
    .join('\n')

  const prompt = `
    You are a business intelligence assistant for Zixly.

    Based on the following relevant metrics from the customer's data:
    ${context}

    Answer this question: ${query}

    Provide a concise, data-driven response with specific numbers.
  `

  // Step 3: Generate response with GPT-4
  const completion = await openai.chat.completions.create({
    model: 'gpt-4-turbo-preview',
    messages: [{ role: 'user', content: prompt }],
    temperature: 0.3, // Low temperature for factual responses
  })

  return NextResponse.json({
    answer: completion.choices[0].message.content,
    sources: relevantMetrics.map((m) => ({ id: m.id, name: m.metric_name })),
  })
}