import Raptor from '@raptor-data/ts-sdk';

const raptor = new Raptor({ apiKey: process.env.RAPTOR_API_KEY });

// Process a document
const result = await raptor.process('document.pdf');

console.log(`Document ID: ${result.documentId}`);
console.log(`Chunks: ${result.chunks.length}`);
console.log(`Version: ${result.versionNumber}`);

raptor.process(source, options?)

interface ProcessResult {
  documentId: string;
  chunks: string[];
  metadata: ChunkMetadata[];

  // Version control
  versionId: string;
  versionNumber: number;
  isNewDocument: boolean;
  isNewVersion: boolean;
  isNewVariant: boolean;

  // Auto-linking
  autoLinked?: boolean;
  autoLinkConfidence?: number;
  autoLinkExplanation?: string[];
  autoLinkMethod?: 'metadata' | 'metadata_and_content' | 'none';
  parentDocumentId?: string;

  // Deduplication
  deduplicationAvailable: boolean;
  isDuplicate?: boolean;
  canonicalDocumentId?: string;
  processingSkipped?: boolean;
  costSaved?: number;
}

const result = await raptor.process('contract.pdf');

console.log(`Processed ${result.chunks.length} chunks`);
result.chunks.forEach((chunk, i) => {
  console.log(`Chunk ${i}: ${chunk.substring(0, 100)}...`);
});

const result = await raptor.process('document.pdf', {
  chunkSize: 1024,        // Larger chunks
  chunkOverlap: 100,      // More overlap
  strategy: 'semantic'    // Content-aware
});

const result = await raptor.process('legal-contract.pdf', {
  extractSectionNumbers: true,     // Extract section numbers
  calculateQualityScores: true,    // Calculate quality
  minChunkQuality: 0.5,            // Filter low-quality chunks
  processImages: true,             // Include images
  tableExtraction: true,           // Extract tables
  tableContextGeneration: true     // Generate table context
});

// Check chunk quality
result.metadata.forEach(chunk => {
  if (chunk.qualityScore) {
    console.log(`Chunk ${chunk.chunkIndex}: Quality ${chunk.qualityScore.toFixed(2)}`);
  }
});

// In a browser with file input
function handleFileUpload(file: File) {
  const result = await raptor.process(file, {
    wait: true,
    chunkSize: 512
  });

  console.log(`Uploaded ${file.name}`);
  console.log(`Got ${result.chunks.length} chunks`);
}

// app/api/upload/route.ts
import Raptor from '@raptor-data/ts-sdk';

export async function POST(request: Request) {
  const formData = await request.formData();
  const file = formData.get('file') as File;

  const raptor = new Raptor({ apiKey: process.env.RAPTOR_API_KEY });

  const result = await raptor.process(file, {
    wait: true,
    versionLabel: formData.get('versionLabel') as string
  });

  return Response.json({
    documentId: result.documentId,
    chunks: result.chunks.length,
    versionNumber: result.versionNumber
  });
}

// Start processing (don't wait)
const result = await raptor.process('large-document.pdf', {
  wait: false
});

console.log(`Processing started: ${result.documentId}`);

// Poll for completion
while (true) {
  const variant = await raptor.getVariant(result.variantId);

  if (variant.status === 'completed') {
    console.log(`Completed! ${variant.chunksCount} chunks`);
    break;
  } else if (variant.status === 'failed') {
    console.error(`Failed: ${variant.error}`);
    break;
  }

  console.log(`Status: ${variant.status}`);
  await new Promise(resolve => setTimeout(resolve, 2000));
}

for await (const progress of raptor.processStream('document.pdf')) {
  console.log(`${progress.stage}: ${progress.percent}%`);
}

// Output:
// upload: 0%
// upload: 100%
// processing: 25%
// processing: 50%
// processing: 75%
// complete: 100%

interface ChunkMetadata {
  id: string;
  pageNumber: number | null;
  pageRange: number[];
  sectionHierarchy: string[];
  tokens: number;
  chunkIndex: number;
  metadata: Record<string, any>;

  // Advanced fields
  chunkType: string | null;
  containsTable: boolean;
  tableMetadata: Record<string, any> | null;
  chunkingStrategy: string | null;
  sectionNumber: string | null;
  qualityScore: number | null;
  syntheticContext: string | null;
  parentChunkId: string | null;
  boundingBox: Record<string, any> | null;

  // Deduplication metadata
  dedupStrategy?: string | null;
  dedupConfidence?: number | null;
  isReused?: boolean;
  totalSentences?: number | null;
  reusedSentencesCount?: number | null;
  newSentencesCount?: number | null;
  contentReuseRatio?: number | null;
  embeddingRecommendation?: string | null;
}

const result = await raptor.process('document.pdf');

result.metadata.forEach(chunk => {
  console.log(`Chunk ${chunk.chunkIndex}:`);
  console.log(`  Page: ${chunk.pageNumber}`);
  console.log(`  Tokens: ${chunk.tokens}`);
  console.log(`  Section: ${chunk.sectionHierarchy.join(' > ')}`);

  if (chunk.containsTable) {
    console.log('  Contains table');
  }

  if (chunk.qualityScore) {
    console.log(`  Quality: ${chunk.qualityScore.toFixed(2)}`);
  }
});