Stirling-PDF/frontend/src/services/signatureDetectionService.ts

/**
 * Service for detecting signatures in PDF files using PDF.js
 * This provides a quick client-side check to determine if a PDF contains signatures
 * without needing to make API calls
 */

// PDF.js types (simplified)
declare global {
  interface Window {
    pdfjsLib?: any;
  }
}

export interface SignatureDetectionResult {
  hasSignatures: boolean;
  signatureCount?: number;
  error?: string;
}

export interface FileSignatureStatus {
  file: File;
  result: SignatureDetectionResult;
}

/**
 * Detect signatures in a single PDF file using PDF.js
 */
const detectSignaturesInFile = async (file: File): Promise<SignatureDetectionResult> => {
  try {
    // Ensure PDF.js is available
    if (!window.pdfjsLib) {
      return {
        hasSignatures: false,
        error: 'PDF.js not available'
      };
    }

    // Convert file to ArrayBuffer
    const arrayBuffer = await file.arrayBuffer();
    
    // Load the PDF document
    const pdf = await window.pdfjsLib.getDocument({ data: arrayBuffer }).promise;
    
    let totalSignatures = 0;
    
    // Check each page for signature annotations
    for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {
      const page = await pdf.getPage(pageNum);
      const annotations = await page.getAnnotations();
      
      // Count signature annotations (Type: /Sig)
      const signatureAnnotations = annotations.filter((annotation: any) => 
        annotation.subtype === 'Widget' && 
        annotation.fieldType === 'Sig'
      );
      
      totalSignatures += signatureAnnotations.length;
    }
    
    // Also check for document-level signatures in AcroForm
    const metadata = await pdf.getMetadata();
    if (metadata?.info?.Signature || metadata?.metadata?.has('dc:signature')) {
      totalSignatures = Math.max(totalSignatures, 1);
    }
    
    // Clean up PDF.js document
    pdf.destroy();
    
    return {
      hasSignatures: totalSignatures > 0,
      signatureCount: totalSignatures
    };
    
  } catch (error) {
    console.warn('PDF signature detection failed:', error);
    return {
      hasSignatures: false,
      signatureCount: 0,
      error: error instanceof Error ? error.message : 'Detection failed'
    };
  }
};

/**
 * Detect if PDF files contain signatures using PDF.js client-side processing
 */
export const detectSignaturesInFiles = async (files: File[]): Promise<FileSignatureStatus[]> => {
  const results: FileSignatureStatus[] = [];
  
  for (const file of files) {
    const result = await detectSignaturesInFile(file);
    results.push({ file, result });
  }
  
  return results;
};

/**
 * Hook for managing signature detection state
 */
export const useSignatureDetection = () => {
  const [detectionResults, setDetectionResults] = React.useState<FileSignatureStatus[]>([]);
  const [isDetecting, setIsDetecting] = React.useState(false);
  
  const detectSignatures = async (files: File[]) => {
    if (files.length === 0) {
      setDetectionResults([]);
      return;
    }
    
    setIsDetecting(true);
    try {
      const results = await detectSignaturesInFiles(files);
      setDetectionResults(results);
    } finally {
      setIsDetecting(false);
    }
  };
  
  const getFileSignatureStatus = (file: File): SignatureDetectionResult | null => {
    const result = detectionResults.find(r => r.file === file);
    return result ? result.result : null;
  };
  
  const hasAnySignatures = detectionResults.some(r => r.result.hasSignatures);
  const totalSignatures = detectionResults.reduce((sum, r) => sum + (r.result.signatureCount || 0), 0);
  
  return {
    detectionResults,
    isDetecting,
    detectSignatures,
    getFileSignatureStatus,
    hasAnySignatures,
    totalSignatures,
    reset: () => setDetectionResults([])
  };
};

// Import React for the hook
import React from 'react';