/**
 * Example usage of the privacy-preserving audit logging system
 */

import { 
  initializePrivacyAudit, 
  logPrivacyAuditEvent,
  logPHIAccess,
  generateHIPAAComplianceReport,
  usePrivacyAuditLog
} from '@/lib/audit';

// 1. Initialize the system (do this once on app startup)
export async function setupAuditSystem() {
  await initializePrivacyAudit();
  console.log('Privacy-preserving audit system initialized');
}

// 2. Basic event logging with PHI
export async function logPatientAccess(
  userId: string,
  patient: {
    id: string;
    name: string;
    email: string;
    diagnosis?: string;
  }
) {
  // Log the access with PHI data automatically obfuscated
  const eventId = await logPrivacyAuditEvent('patient_record_viewed', {
    userId,
    resourceType: 'patient_record',
    resourceId: patient.id,
    phi: {
      patientName: patient.name,
      patientEmail: patient.email,
      diagnosis: patient.diagnosis
    },
    metadata: {
      viewContext: 'patient_dashboard',
      timestamp: new Date().toISOString()
    }
  });
  
  console.log(`Audit event logged: ${eventId}`);
  return eventId;
}

// 3. Log PHI updates with severity
export async function logPatientUpdate(
  userId: string,
  patientId: string,
  updates: Record<string, any>
) {
  const eventId = await logPHIAccess(
    userId,
    patientId,
    'update',
    updates
  );
  
  return eventId;
}

// 4. React component example
export function PatientRecordComponent() {
  const { logEvent, logPHIAccess, logError } = usePrivacyAuditLog({
    defaultMetadata: {
      component: 'PatientRecord',
      version: '1.0.0'
    }
  });
  
  const handleViewRecord = async (patient: any) => {
    try {
      // Log PHI access
      await logPHIAccess(patient.id, 'view', {
        patientName: patient.name,
        patientEmail: patient.email
      });
      
      // Load and display patient data...
    } catch (error) {
      // Log errors with context
      await logError('patient_view_failed', error as Error, {
        resourceType: 'patient',
        resourceId: patient.id
      });
    }
  };
  
  const handleExportData = async (patientIds: string[]) => {
    // Log batch operation
    await logEvent('patient_data_export', {
      resourceType: 'patient_batch',
      metadata: {
        count: patientIds.length,
        format: 'csv',
        exportedFields: ['name', 'email', 'diagnosis']
      },
      severity: 'medium'
    });
  };
  
  // Component implementation...
}

// 5. Generate compliance reports
export async function generateMonthlyComplianceReport() {
  const startDate = new Date();
  startDate.setMonth(startDate.getMonth() - 1);
  const endDate = new Date();
  
  // Report without PHI (for general analytics)
  const summaryReport = await generateHIPAAComplianceReport(
    startDate,
    endDate
  );
  
  console.log('Monthly Summary:', {
    totalEvents: summaryReport.report.summary.total_events,
    uniqueUsers: summaryReport.report.summary.unique_actors,
    failedEvents: summaryReport.report.summary.failed_events
  });
  
  // Report with PHI (requires special permissions)
  const detailedReport = await generateHIPAAComplianceReport(
    startDate,
    endDate,
    {
      includePHI: true,
      resourceType: 'patient'
    }
  );
  
  // Process detailed events with reconstructed PHI
  detailedReport.report.events.forEach((event: any) => {
    if (event.phi) {
      console.log(`User ${event.actor.id} accessed patient: ${event.phi.patientName}`);
    }
  });
  
  return { summaryReport, detailedReport };
}

// 6. Direct ClickHouse queries for analytics
import { clickhouseService } from '@/lib/audit';

export async function getAccessPatterns() {
  const query = `
    SELECT 
      toHour(timestamp) as hour,
      action,
      COUNT(*) as access_count,
      COUNT(DISTINCT actor_id) as unique_users
    FROM audit_logs.audit_events
    WHERE 
      date >= today() - 7
      AND action LIKE 'phi_%'
    GROUP BY hour, action
    ORDER BY hour, access_count DESC
  `;
  
  const results = await clickhouseService.queryEvents(query);
  return results;
}

// 7. Track specific PHI field access
import { usePHIFieldTracking } from '@/lib/audit/hooks/usePrivacyAuditLog';

export function SensitiveDataForm({ patientId, patientData }: any) {
  const { createTrackedField } = usePHIFieldTracking(patientId);
  
  // Create tracked fields
  const ssnField = createTrackedField('ssn');
  const diagnosisField = createTrackedField('diagnosis');
  
  const handleSubmit = (formData: any) => {
    // Access is automatically logged
    const currentSSN = ssnField.get(patientData.ssn);
    
    // Update is automatically logged
    ssnField.set(formData.ssn);
    diagnosisField.set(formData.diagnosis);
  };
  
  // Form implementation...
}