import { NextRequest, NextResponse } from 'next/server';
import { Pinecone } from '@pinecone-database/pinecone';

import { prisma } from '@/lib/prisma';

export async function GET(request: NextRequest) {
  try {
    // Get Pinecone settings from database
    const panelSettings = await prisma.panelSetting.findFirst();
    
    if (!panelSettings?.pineconeIndexName || !panelSettings?.pineconeHost || !panelSettings?.pineconeNamespace) {
      return NextResponse.json({ 
        error: 'Pinecone settings not configured in database' 
      }, { status: 400 });
    }

    // Initialize Pinecone client
    const pc = new Pinecone({
      apiKey: process.env.PINECONE_API_KEY || '',
    });

    const INDEX_NAME = panelSettings.pineconeIndexName;
    const INDEX_HOST = panelSettings.pineconeHost;
    const NAMESPACE = panelSettings.pineconeNamespace;

    const index = pc.index(INDEX_NAME, INDEX_HOST);
    const namespace = index.namespace(NAMESPACE);
    
    const stats = await index.describeIndexStats();
    const existingNamespaces = stats.namespaces ? Object.keys(stats.namespaces) : [];
    
    if (existingNamespaces.includes(NAMESPACE)) {
      // Proceed to delete all vectors in the namespace
      await index.namespace(NAMESPACE).deleteAll();
      console.log(`✅ Deleted all vectors in namespace "${NAMESPACE}"`);
    } else {
      console.log(`⚠️ Namespace "${NAMESPACE}" does not exist. Skipping deletion.`);
    }
    
    // Fetch data from your documents API
    const response = await fetch(`${request.nextUrl.origin}/api/rag/document?pinecone=true`);
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    console.log(`✅ Fetched ${data.length} records`);
    
    if (data.length === 0) {
      return NextResponse.json({ message: '⚠️ No data to upsert.' }, { status: 200 });
    }
    
    // Process data in batches
    const batches = chunkArray(data, 100);
    let totalUpserted = 0;
    
    for (const batch of batches) {
      const records = batch.map((item: any) => ({
        _id: item._id,
        chunk_text: item.chunk_text,
        categories: item.categories,
        keywords: item.keywords,
        type: item.type,
      }));
      
      await namespace.upsertRecords(records);
      totalUpserted += records.length;
      console.log(`✅ Upserted batch of ${records.length} records`);
    }
    
    return NextResponse.json({
      message: '🎉 All data upserted successfully!',
      stats: {
        totalUpserted,
        batches: batches.length
      }
    }, { status: 200 });
    
  } catch (error) {
    console.error('Error processing Pinecone update:', error);
    return NextResponse.json(
      { error: 'Failed to update Pinecone database', details: error instanceof Error ? error.message : 'Unknown error' },
      { status: 500 }
    );
  } finally {
    // Close Prisma connection
    await prisma.$disconnect();
  }
}

// Helper function to chunk array into smaller arrays
function chunkArray(array: any[], size = 100) {
  const result = [];
  for (let i = 0; i < array.length; i += size) {
    result.push(array.slice(i, i + size));
  }
  return result;
}