GDPR and Image Optimization: Privacy Considerations

// Common GDPR violations in image optimization
const gdprViolations = {
  metadata_collection: {
    violation: "Processing EXIF data containing location, device info, or personal identifiers",
    risk: "High - Location data is sensitive personal data",
    example: "GPS coordinates embedded in user-uploaded photos"
  },

  third_party_processing: {
    violation: "Sending images to external optimization services without explicit consent",
    risk: "Medium - Data transferred outside EU without adequate protection",
    example: "Using Cloudinary, ImageKit, or other CDNs without proper agreements"
  },

  tracking_pixels: {
    violation: "Embedding analytics or tracking in optimized images",
    risk: "High - Behavioral tracking without consent",
    example: "Adding UTM parameters or analytics pixels to image URLs"
  },

  biometric_data: {
    violation: "Processing facial recognition data during optimization",
    risk: "Very High - Biometric data has special protection under GDPR",
    example: "AI-powered cropping that detects and focuses on faces"
  },

  cross_border_transfer: {
    violation: "Processing images on servers outside EU without adequate safeguards",
    risk: "High - International data transfer violations",
    example: "Using US-based optimization APIs without Standard Contractual Clauses"
  }
};

// services/gdpr-image-processor.js
import ExifReader from 'exifreader';
import crypto from 'crypto';

class GDPRImageProcessor {
  constructor(options = {}) {
    this.options = {
      stripSensitiveMetadata: true,
      logProcessing: true,
      consentRequired: true,
      dataRetention: 30, // days
      ...options
    };

    this.sensitiveFields = [
      'GPSLatitude',
      'GPSLongitude', 
      'GPSAltitude',
      'GPSTimeStamp',
      'CameraOwnerName',
      'Artist',
      'Copyright',
      'Software',
      'HostComputer',
      'ImageUniqueID'
    ];
  }

  async processImage(imageBuffer, userConsent = null) {
    // Verify consent before processing
    if (this.options.consentRequired && !this.hasValidConsent(userConsent)) {
      throw new Error('Valid consent required for image processing');
    }

    const processingId = this.generateProcessingId();

    try {
      // Log processing activity for GDPR compliance
      await this.logProcessingActivity(processingId, {
        timestamp: new Date().toISOString(),
        consentId: userConsent?.id,
        purpose: 'image_optimization',
        legalBasis: userConsent?.legalBasis || 'legitimate_interest'
      });

      // Extract and analyze metadata
      const metadata = await this.extractMetadata(imageBuffer);
      const sensitiveData = this.identifySensitiveData(metadata);

      // Handle sensitive data according to GDPR
      const cleanedBuffer = await this.sanitizeImage(imageBuffer, metadata);

      // Store processing record for accountability
      await this.storeProcessingRecord(processingId, {
        sensitiveDataFound: sensitiveData,
        actionsPerformed: this.getActionsPerformed(sensitiveData),
        dataRetentionDate: this.calculateRetentionDate()
      });

      return {
        processedImage: cleanedBuffer,
        processingId,
        sensitiveDataRemoved: sensitiveData.length > 0,
        metadata: this.options.stripSensitiveMetadata ? 
          this.filterSafeMetadata(metadata) : metadata
      };

    } catch (error) {
      await this.logProcessingError(processingId, error);
      throw error;
    }
  }

  extractMetadata(imageBuffer) {
    try {
      return ExifReader.load(imageBuffer, { expanded: true });
    } catch (error) {
      console.warn('Failed to extract metadata:', error);
      return {};
    }
  }

  identifySensitiveData(metadata) {
    const sensitiveData = [];

    for (const field of this.sensitiveFields) {
      if (this.hasNestedProperty(metadata, field)) {
        sensitiveData.push({
          field,
          type: this.classifyDataType(field),
          value: this.getNestedProperty(metadata, field)
        });
      }
    }

    // Check for potential facial recognition data
    if (metadata.faces || metadata.persons) {
      sensitiveData.push({
        field: 'biometric_data',
        type: 'biometric',
        value: 'facial_detection_data'
      });
    }

    return sensitiveData;
  }

  async sanitizeImage(imageBuffer, metadata) {
    const sharp = require('sharp');

    try {
      // Remove all EXIF data while preserving image quality
      return await sharp(imageBuffer)
        .rotate() // Auto-rotate based on EXIF, then strip EXIF
        .withMetadata(false) // Remove all metadata
        .toBuffer();

    } catch (error) {
      console.warn('Failed to sanitize image:', error);
      return imageBuffer;
    }
  }

  hasValidConsent(consent) {
    if (!consent) return false;

    return (
      consent.imageProcessing === true &&
      consent.timestamp &&
      new Date(consent.timestamp) > new Date(Date.now() - 365 * 24 * 60 * 60 * 1000) && // Within 1 year
      consent.version === this.getCurrentConsentVersion()
    );
  }

  classifyDataType(field) {
    const classifications = {
      'GPSLatitude': 'location',
      'GPSLongitude': 'location',
      'GPSAltitude': 'location',
      'CameraOwnerName': 'personal_identifier',
      'Artist': 'personal_identifier',
      'Software': 'device_info',
      'HostComputer': 'device_info'
    };

    return classifications[field] || 'metadata';
  }

  filterSafeMetadata(metadata) {
    const safeFields = [
      'ImageWidth',
      'ImageHeight',
      'Orientation',
      'ColorSpace'
    ];

    const filteredMetadata = {};

    for (const field of safeFields) {
      if (this.hasNestedProperty(metadata, field)) {
        filteredMetadata[field] = this.getNestedProperty(metadata, field);
      }
    }

    return filteredMetadata;
  }

  generateProcessingId() {
    return crypto.randomBytes(16).toString('hex');
  }

  calculateRetentionDate() {
    const retentionDays = this.options.dataRetention;
    const retentionDate = new Date();
    retentionDate.setDate(retentionDate.getDate() + retentionDays);
    return retentionDate.toISOString();
  }

  async logProcessingActivity(processingId, activity) {
    // Store processing logs for GDPR accountability
    const logEntry = {
      id: processingId,
      ...activity,
      processor: 'image_optimization_service',
      dataCategories: ['image_data', 'metadata'],
      retentionPeriod: this.options.dataRetention
    };

    // Store in compliance database
    await this.storeComplianceLog(logEntry);
  }

  getActionsPerformed(sensitiveData) {
    return sensitiveData.map(data => `removed_${data.type}_data`);
  }

  getCurrentConsentVersion() {
    return '1.0';
  }

  // Utility methods
  hasNestedProperty(obj, path) {
    return path.split('.').reduce((current, key) => current && current[key], obj) !== undefined;
  }

  getNestedProperty(obj, path) {
    return path.split('.').reduce((current, key) => current && current[key], obj);
  }

  async storeProcessingRecord(processingId, record) {
    console.log('Storing processing record:', { processingId, ...record });
  }

  async logProcessingError(processingId, error) {
    console.error('Image processing error:', { processingId, error: error.message });
  }

  async storeComplianceLog(logEntry) {
    console.log('Storing compliance log:', logEntry);
  }
}

export default GDPRImageProcessor;

// services/image-consent-manager.js
class ImageConsentManager {
  constructor() {
    this.consentVersion = '2.0';
    this.requiredPurposes = [
      'image_optimization',
      'performance_analytics', 
      'cdn_processing'
    ];
  }

  async requestImageProcessingConsent(options = {}) {
    const {
      purposes = this.requiredPurposes,
      thirdPartyServices = [],
      dataRetention = 30,
      context = 'image_upload'
    } = options;

    const consentRequest = {
      id: this.generateConsentId(),
      version: this.consentVersion,
      timestamp: new Date().toISOString(),
      context,
      purposes,
      thirdPartyServices,
      dataRetention,
      userAgent: navigator.userAgent,
      language: navigator.language
    };

    // Present consent UI to user
    const userResponse = await this.presentConsentUI(consentRequest);

    if (userResponse.granted) {
      await this.storeConsent(userResponse);
      return userResponse;
    }

    throw new Error('Image processing consent not granted');
  }

  async presentConsentUI(consentRequest) {
    return new Promise((resolve) => {
      // Create GDPR-compliant consent modal
      const modal = this.createConsentModal(consentRequest);

      modal.onConfirm = (choices) => {
        resolve({
          ...consentRequest,
          granted: true,
          choices,
          grantedAt: new Date().toISOString()
        });
        modal.remove();
      };

      modal.onReject = () => {
        resolve({
          ...consentRequest,
          granted: false,
          rejectedAt: new Date().toISOString()
        });
        modal.remove();
      };

      document.body.appendChild(modal);
    });
  }

  createConsentModal(consentRequest) {
    const modal = document.createElement('div');
    modal.className = 'gdpr-consent-modal';

    modal.innerHTML = `
      <div class="consent-overlay">
        <div class="consent-content">
          <h2>Image Processing Consent</h2>

          <p>We need your consent to process your images for the following purposes:</p>

          <div class="consent-purposes">
            ${consentRequest.purposes.map(purpose => `
              <label class="consent-purpose">
                <input type="checkbox" name="purpose" value="${purpose}" checked>
                <span>${this.getPurposeDescription(purpose)}</span>
              </label>
            `).join('')}
          </div>

          ${consentRequest.thirdPartyServices.length > 0 ? `
            <div class="third-party-services">
              <h3>Third-Party Services</h3>
              <p>Your images may be processed by:</p>
              <ul>
                ${consentRequest.thirdPartyServices.map(service => `
                  <li>${service.name} - ${service.purpose}</li>
                `).join('')}
              </ul>
            </div>
          ` : ''}

          <div class="data-retention">
            <p><strong>Data Retention:</strong> ${consentRequest.dataRetention} days</p>
          </div>

          <div class="your-rights">
            <h3>Your Rights</h3>
            <ul>
              <li>Access your data at any time</li>
              <li>Request deletion of your data</li>
              <li>Withdraw consent at any time</li>
              <li>Data portability</li>
            </ul>
          </div>

          <div class="consent-actions">
            <button class="btn-reject">Reject</button>
            <button class="btn-confirm">Accept and Continue</button>
          </div>

          <div class="privacy-links">
            <a href="/privacy-policy" target="_blank">Privacy Policy</a>
            <a href="/data-processing" target="_blank">Data Processing Details</a>
          </div>
        </div>
      </div>
    `;

    // Add event listeners
    const confirmBtn = modal.querySelector('.btn-confirm');
    const rejectBtn = modal.querySelector('.btn-reject');

    confirmBtn.onclick = () => {
      const selectedPurposes = Array.from(modal.querySelectorAll('input[name="purpose"]:checked'))
        .map(input => input.value);

      modal.onConfirm(selectedPurposes);
    };

    rejectBtn.onclick = () => modal.onReject();

    return modal;
  }

  getPurposeDescription(purpose) {
    const descriptions = {
      'image_optimization': 'Compress and optimize images for faster loading',
      'performance_analytics': 'Analyze loading performance to improve service',
      'cdn_processing': 'Process images through our content delivery network',
      'face_detection': 'Detect faces for improved cropping (optional)',
      'metadata_analysis': 'Analyze image metadata for optimization'
    };

    return descriptions[purpose] || purpose;
  }

  async storeConsent(consent) {
    // Store consent record securely
    const consentRecord = {
      id: consent.id,
      userId: this.getCurrentUserId(),
      version: consent.version,
      grantedAt: consent.grantedAt,
      purposes: consent.choices,
      thirdPartyServices: consent.thirdPartyServices,
      dataRetention: consent.dataRetention,
      ipAddress: await this.getHashedIP(),
      userAgent: consent.userAgent,
      language: consent.language
    };

    await this.saveToConsentDatabase(consentRecord);
    this.setConsentCookie(consentRecord);

    return consentRecord;
  }

  async withdrawConsent(userId, reason = 'user_request') {
    const withdrawalRecord = {
      userId,
      withdrawnAt: new Date().toISOString(),
      reason,
      version: this.consentVersion
    };

    await this.saveConsentWithdrawal(withdrawalRecord);
    await this.deleteConsentRecord(userId);
    this.clearConsentCookie();

    // Trigger data deletion process
    await this.initiateDataDeletion(userId);

    return withdrawalRecord;
  }

  generateConsentId() {
    return 'consent_' + crypto.randomUUID();
  }

  getCurrentUserId() {
    return 'anonymous_' + this.getSessionId();
  }

  getSessionId() {
    return sessionStorage.getItem('sessionId') || 'unknown';
  }

  async getHashedIP() {
    try {
      const response = await fetch('/api/client-ip-hash');
      return await response.text();
    } catch {
      return 'unknown';
    }
  }

  setConsentCookie(consent) {
    const cookieValue = {
      id: consent.id,
      version: consent.version,
      grantedAt: consent.grantedAt,
      purposes: consent.purposes
    };

    document.cookie = `image_consent=${encodeURIComponent(JSON.stringify(cookieValue))}; Max-Age=${365 * 24 * 60 * 60}; SameSite=Strict; Secure`;
  }

  clearConsentCookie() {
    document.cookie = 'image_consent=; Max-Age=0; SameSite=Strict; Secure';
  }

  // Database methods (implement according to your system)
  async saveToConsentDatabase(record) {
    console.log('Saving consent record:', record);
  }

  async saveConsentWithdrawal(record) {
    console.log('Saving consent withdrawal:', record);
  }

  async deleteConsentRecord(userId) {
    console.log('Deleting consent for user:', userId);
  }

  async initiateDataDeletion(userId) {
    console.log('Initiating data deletion for user:', userId);
  }
}

export default ImageConsentManager;

// services/gdpr-cdn-manager.js
class GDPRCDNManager {
  constructor() {
    this.approvedProviders = new Map();
    this.initializeApprovedProviders();
  }

  initializeApprovedProviders() {
    // Configure GDPR-compliant CDN providers
    this.approvedProviders.set('cloudflare', {
      name: 'Cloudflare',
      region: 'EU',
      dpaStatus: 'signed',
      sccsInPlace: true,
      dataProcessingAgreement: 'https://www.cloudflare.com/dpa/',
      privacyPolicy: 'https://www.cloudflare.com/privacypolicy/',
      certifications: ['ISO27001', 'SOC2'],
      dataRetention: 30,
      supportedRegions: ['EU', 'US'],
      gdprContact: 'privacy@cloudflare.com'
    });

    this.approvedProviders.set('imagekit', {
      name: 'ImageKit',
      region: 'EU',
      dpaStatus: 'signed',
      sccsInPlace: true,
      dataProcessingAgreement: 'https://imagekit.io/dpa/',
      privacyPolicy: 'https://imagekit.io/privacy/',
      certifications: ['ISO27001'],
      dataRetention: 90,
      supportedRegions: ['EU', 'US'],
      gdprContact: 'privacy@imagekit.io'
    });
  }

  async processImageWithGDPRCompliance(imageData, options = {}) {
    const {
      userConsent,
      preferredRegion = 'EU',
      allowThirdParty = false,
      processor = 'local'
    } = options;

    // Verify consent for third-party processing
    if (processor !== 'local' && !this.hasThirdPartyConsent(userConsent)) {
      throw new Error('Third-party processing requires explicit consent');
    }

    // Select appropriate processor
    const selectedProcessor = await this.selectGDPRCompliantProcessor(
      processor, 
      preferredRegion, 
      allowThirdParty
    );

    // Process image with compliance safeguards
    return await this.executeCompliantProcessing(imageData, selectedProcessor, userConsent);
  }

  hasThirdPartyConsent(consent) {
    return consent && 
           consent.thirdPartyProcessing === true &&
           consent.grantedAt &&
           new Date(consent.grantedAt) > new Date(Date.now() - 365 * 24 * 60 * 60 * 1000);
  }

  async selectGDPRCompliantProcessor(requested, region, allowThirdParty) {
    if (requested === 'local') {
      return { type: 'local', name: 'Local Processing' };
    }

    if (!allowThirdParty) {
      return { type: 'local', name: 'Local Processing (Third-party not allowed)' };
    }

    const provider = this.approvedProviders.get(requested);

    if (!provider) {
      throw new Error(`Provider ${requested} not approved for GDPR compliance`);
    }

    // Verify provider supports required region
    if (!provider.supportedRegions.includes(region)) {
      throw new Error(`Provider ${requested} does not support region ${region}`);
    }

    // Verify DPA and SCCs are in place
    if (!provider.dpaStatus === 'signed' || !provider.sccsInPlace) {
      throw new Error(`Provider ${requested} lacks required GDPR safeguards`);
    }

    return { type: 'third-party', provider };
  }

  async executeCompliantProcessing(imageData, processor, consent) {
    const processingRecord = {
      id: this.generateProcessingId(),
      timestamp: new Date().toISOString(),
      processor: processor.name,
      consentId: consent?.id,
      legalBasis: consent?.legalBasis || 'legitimate_interest',
      dataMinimization: true,
      purposeLimitation: true
    };

    try {
      let result;

      if (processor.type === 'local') {
        result = await this.processLocally(imageData, processingRecord);
      } else {
        result = await this.processWithThirdParty(imageData, processor.provider, processingRecord);
      }

      // Log successful processing
      await this.logProcessingActivity(processingRecord, 'success', result);

      return result;

    } catch (error) {
      await this.logProcessingActivity(processingRecord, 'error', { error: error.message });
      throw error;
    }
  }

  async processLocally(imageData, record) {
    const sharp = require('sharp');

    // Process image locally to maintain data control
    const processed = await sharp(imageData)
      .resize(1200, null, { withoutEnlargement: true })
      .webp({ quality: 80 })
      .withMetadata(false) // Remove all metadata for privacy
      .toBuffer();

    return {
      processedImage: processed,
      processingLocation: 'local',
      dataTransferred: false,
      privacyPreserved: true,
      processingId: record.id
    };
  }

  async processWithThirdParty(imageData, provider, record) {
    // Log data transfer
    await this.logDataTransfer(provider, {
      processingId: record.id,
      dataSubject: record.consentId,
      purpose: 'image_optimization',
      retention: provider.dataRetention
    });

    // Simulate API call with GDPR headers
    const processingResult = {
      processedImage: imageData, // In real implementation, this would be the API response
      processingLocation: provider.region,
      dataTransferred: true,
      provider: provider.name,
      processingId: record.id,
      retentionPeriod: provider.dataRetention
    };

    return processingResult;
  }

  async logDataTransfer(provider, payload) {
    const transferLog = {
      id: this.generateTransferId(),
      timestamp: new Date().toISOString(),
      provider: provider.name,
      dataType: 'image_data',
      dataSubject: payload.dataSubject,
      transferMechanism: 'SCCs',
      destinationCountry: provider.region,
      purpose: payload.purpose,
      retention: payload.retention
    };

    await this.storeTransferLog(transferLog);
  }

  async logProcessingActivity(record, status, details) {
    const activity = {
      ...record,
      status,
      details,
      completed: new Date().toISOString()
    };

    await this.storeProcessingLog(activity);
  }

  generateProcessingId() {
    return 'proc_' + crypto.randomUUID();
  }

  generateTransferId() {
    return 'transfer_' + crypto.randomUUID();
  }

  async storeTransferLog(log) {
    console.log('Storing transfer log:', log);
  }

  async storeProcessingLog(log) {
    console.log('Storing processing log:', log);
  }
}

export default GDPRCDNManager;

// services/privacy-analytics.js
class PrivacyPreservingImageAnalytics {
  constructor() {
    this.anonymizationSalt = process.env.ANALYTICS_SALT || 'default-salt';
    this.dataRetention = 90; // days
    this.minDatasetSize = 100; // Minimum for k-anonymity
  }

  async trackImageOptimization(imageData, userContext = {}) {
    // Anonymize user data before tracking
    const anonymizedData = await this.anonymizeTrackingData(imageData, userContext);

    // Apply differential privacy
    const noisyData = this.addDifferentialPrivacyNoise(anonymizedData);

    // Store anonymized analytics
    await this.storeAnalytics(noisyData);

    return {
      tracked: true,
      anonymized: true,
      differentialPrivacy: true,
      retentionDays: this.dataRetention
    };
  }

  async anonymizeTrackingData(imageData, userContext) {
    const anonymized = {
      // Image characteristics (no personal data)
      imageSize: this.categorizeSize(imageData.originalSize),
      optimizationRatio: this.calculateOptimizationRatio(imageData),
      format: imageData.originalFormat,
      targetFormat: imageData.optimizedFormat,

      // Anonymized user context
      sessionHash: await this.hashSessionId(userContext.sessionId),
      userAgent: this.anonymizeUserAgent(userContext.userAgent),
      timestamp: this.roundTimestamp(new Date(), 3600), // Round to nearest hour

      // Geographic data (country-level only)
      country: userContext.country || 'unknown',

      // Technical metrics
      processingTime: imageData.processingTime,
      cacheHit: imageData.fromCache,

      // Privacy metadata
      consentGiven: userContext.hasAnalyticsConsent || false,
      anonymizationVersion: '1.0'
    };

    return anonymized;
  }

  addDifferentialPrivacyNoise(data) {
    // Add Laplace noise for differential privacy
    const epsilon = 1.0; // Privacy budget

    const noisyData = { ...data };

    // Add noise to numeric values
    if (typeof data.processingTime === 'number') {
      noisyData.processingTime = Math.max(0, 
        data.processingTime + this.laplaceNoise(epsilon)
      );
    }

    if (typeof data.optimizationRatio === 'number') {
      noisyData.optimizationRatio = Math.max(0, Math.min(1,
        data.optimizationRatio + this.laplaceNoise(epsilon) * 0.1
      ));
    }

    return noisyData;
  }

  laplaceNoise(epsilon) {
    // Generate Laplace noise for differential privacy
    const u = Math.random() - 0.5;
    const b = 1 / epsilon; // Scale parameter
    return -b * Math.sign(u) * Math.log(1 - 2 * Math.abs(u));
  }

  async hashSessionId(sessionId) {
    if (!sessionId) return 'anonymous';

    const encoder = new TextEncoder();
    const data = encoder.encode(sessionId + this.anonymizationSalt);
    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
    const hashArray = Array.from(new Uint8Array(hashBuffer));
    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('').substring(0, 16);
  }

  anonymizeUserAgent(userAgent) {
    if (!userAgent) return 'unknown';

    // Extract only essential browser/OS info, remove detailed version numbers
    const browser = this.extractBrowser(userAgent);
    const os = this.extractOS(userAgent);

    return `${browser}/${os}`;
  }

  extractBrowser(userAgent) {
    if (userAgent.includes('Chrome')) return 'Chrome';
    if (userAgent.includes('Firefox')) return 'Firefox';
    if (userAgent.includes('Safari')) return 'Safari';
    if (userAgent.includes('Edge')) return 'Edge';
    return 'Other';
  }

  extractOS(userAgent) {
    if (userAgent.includes('Windows')) return 'Windows';
    if (userAgent.includes('Mac')) return 'macOS';
    if (userAgent.includes('Linux')) return 'Linux';
    if (userAgent.includes('Android')) return 'Android';
    if (userAgent.includes('iOS')) return 'iOS';
    return 'Other';
  }

  roundTimestamp(timestamp, intervalSeconds) {
    const intervalMs = intervalSeconds * 1000;
    return new Date(Math.floor(timestamp.getTime() / intervalMs) * intervalMs);
  }

  categorizeSize(sizeInBytes) {
    if (sizeInBytes < 100000) return 'small';    // < 100KB
    if (sizeInBytes < 500000) return 'medium';   // < 500KB
    if (sizeInBytes < 2000000) return 'large';   // < 2MB
    return 'extra-large';
  }

  calculateOptimizationRatio(imageData) {
    if (!imageData.originalSize || !imageData.optimizedSize) return 0;
    return (imageData.originalSize - imageData.optimizedSize) / imageData.originalSize;
  }

  async storeAnalytics(data) {
    // Store with automatic expiration based on retention policy
    const expirationDate = new Date();
    expirationDate.setDate(expirationDate.getDate() + this.dataRetention);

    const record = {
      ...data,
      id: crypto.randomUUID(),
      storedAt: new Date().toISOString(),
      expiresAt: expirationDate.toISOString()
    };

    await this.saveAnalyticsRecord(record);
  }

  async generatePrivacyReport() {
    const analytics = await this.getAnalyticsData();

    // Ensure k-anonymity before reporting
    if (analytics.length < this.minDatasetSize) {
      return {
        error: 'Insufficient data for privacy-preserving analysis',
        minRequired: this.minDatasetSize,
        actual: analytics.length
      };
    }

    return {
      totalRecords: analytics.length,
      timeRange: this.getTimeRange(analytics),
      optimizationStats: this.calculateAggregateStats(analytics),
      formatDistribution: this.getFormatDistribution(analytics),
      privacyCompliant: true,
      kAnonymity: this.minDatasetSize
    };
  }

  calculateAggregateStats(analytics) {
    const ratios = analytics.map(a => a.optimizationRatio).filter(r => r > 0);
    const times = analytics.map(a => a.processingTime).filter(t => t > 0);

    return {
      averageOptimizationRatio: ratios.reduce((a, b) => a + b, 0) / ratios.length,
      averageProcessingTime: times.reduce((a, b) => a + b, 0) / times.length,
      cacheHitRate: analytics.filter(a => a.cacheHit).length / analytics.length
    };
  }

  getFormatDistribution(analytics) {
    const distribution = {};
    analytics.forEach(record => {
      const key = `${record.format}_to_${record.targetFormat}`;
      distribution[key] = (distribution[key] || 0) + 1;
    });
    return distribution;
  }

  getTimeRange(analytics) {
    const timestamps = analytics.map(a => new Date(a.timestamp));
    return {
      start: new Date(Math.min(...timestamps)),
      end: new Date(Math.max(...timestamps))
    };
  }

  async saveAnalyticsRecord(record) {
    console.log('Storing anonymized analytics:', record);
  }

  async getAnalyticsData() {
    // Retrieve anonymized analytics data
    return [];
  }
}

export default PrivacyPreservingImageAnalytics;

// services/data-subject-rights.js
class DataSubjectRightsManager {
  constructor() {
    this.supportedRights = [
      'access',
      'rectification', 
      'erasure',
      'restriction',
      'portability',
      'objection',
      'withdraw_consent'
    ];
  }

  async handleDataSubjectRequest(requestType, dataSubjectId, requestData = {}) {
    // Validate request
    if (!this.supportedRights.includes(requestType)) {
      throw new Error(`Unsupported right: ${requestType}`);
    }

    // Log the request for compliance tracking
    const requestId = await this.logDataSubjectRequest(requestType, dataSubjectId, requestData);

    try {
      let result;

      switch (requestType) {
        case 'access':
          result = await this.handleAccessRequest(dataSubjectId);
          break;
        case 'erasure':
          result = await this.handleErasureRequest(dataSubjectId);
          break;
        case 'portability':
          result = await this.handlePortabilityRequest(dataSubjectId);
          break;
        case 'withdraw_consent':
          result = await this.handleConsentWithdrawal(dataSubjectId);
          break;
        default:
          result = await this.handleGenericRequest(requestType, dataSubjectId, requestData);
      }

      await this.updateRequestStatus(requestId, 'completed', result);
      return { requestId, status: 'completed', result };

    } catch (error) {
      await this.updateRequestStatus(requestId, 'failed', { error: error.message });
      throw error;
    }
  }

  async handleAccessRequest(dataSubjectId) {
    // Gather all personal data associated with the data subject
    const personalData = {
      identity: await this.getIdentityData(dataSubjectId),
      imageProcessing: await this.getImageProcessingData(dataSubjectId),
      consent: await this.getConsentData(dataSubjectId),
      analytics: await this.getAnalyticsData(dataSubjectId),
      processing: await this.getProcessingLogs(dataSubjectId)
    };

    // Generate human-readable report
    const accessReport = {
      dataSubject: dataSubjectId,
      reportGenerated: new Date().toISOString(),
      dataCategories: Object.keys(personalData),
      personalData,
      retentionPeriods: await this.getRetentionPeriods(dataSubjectId),
      yourRights: this.getDataSubjectRights()
    };

    return accessReport;
  }

  async handleErasureRequest(dataSubjectId) {
    // Check if erasure is legally possible
    const erasureCheck = await this.checkErasureEligibility(dataSubjectId);

    if (!erasureCheck.eligible) {
      return {
        status: 'denied',
        reason: erasureCheck.reason,
        legalBasis: erasureCheck.legalBasis
      };
    }

    // Perform erasure across all systems
    const erasureResults = {
      imageData: await this.eraseImageData(dataSubjectId),
      metadata: await this.eraseMetadata(dataSubjectId),
      processingLogs: await this.eraseProcessingLogs(dataSubjectId),
      analyticsData: await this.eraseAnalyticsData(dataSubjectId),
      consentRecords: await this.eraseConsentRecords(dataSubjectId)
    };

    // Verify complete erasure
    const verificationResult = await this.verifyErasure(dataSubjectId);

    return {
      status: 'completed',
      erasureDate: new Date().toISOString(),
      systemsProcessed: Object.keys(erasureResults),
      verificationPassed: verificationResult.complete,
      retentionException: verificationResult.exceptions || []
    };
  }

  async handlePortabilityRequest(dataSubjectId) {
    // Export data in structured, machine-readable format
    const portableData = {
      exportMetadata: {
        dataSubject: dataSubjectId,
        exportDate: new Date().toISOString(),
        format: 'JSON',
        version: '1.0'
      },

      imageProcessingData: {
        processedImages: await this.getProcessedImages(dataSubjectId),
        optimizationSettings: await this.getUserOptimizationSettings(dataSubjectId),
        processingHistory: await this.getProcessingHistory(dataSubjectId)
      },

      consentData: {
        currentConsents: await this.getCurrentConsents(dataSubjectId),
        consentHistory: await this.getConsentHistory(dataSubjectId)
      }
    };

    // Generate downloadable export file
    const exportFile = await this.generateExportFile(portableData);

    return {
      status: 'completed',
      exportFormat: 'JSON',
      downloadUrl: exportFile.url,
      expiresAt: exportFile.expiresAt,
      dataSize: exportFile.size
    };
  }

  async handleConsentWithdrawal(dataSubjectId) {
    // Withdraw all consents
    const withdrawalResult = {
      imageProcessing: await this.withdrawImageProcessingConsent(dataSubjectId),
      analytics: await this.withdrawAnalyticsConsent(dataSubjectId),
      thirdPartySharing: await this.withdrawThirdPartyConsent(dataSubjectId)
    };

    // Stop all processing based on consent
    await this.stopConsentBasedProcessing(dataSubjectId);

    // Schedule data deletion where consent was the only legal basis
    await this.scheduleConsentBasedDataDeletion(dataSubjectId);

    return {
      status: 'completed',
      withdrawalDate: new Date().toISOString(),
      consentsWithdrawn: Object.keys(withdrawalResult).filter(k => withdrawalResult[k]),
      dataScheduledForDeletion: await this.getDataScheduledForDeletion(dataSubjectId)
    };
  }

  async checkErasureEligibility(dataSubjectId) {
    // Check legal grounds for erasure
    const eligibilityReasons = [];
    const restrictions = [];

    // Check if data is still necessary for original purpose
    const stillNecessary = await this.checkDataNecessity(dataSubjectId);
    if (!stillNecessary) {
      eligibilityReasons.push('no_longer_necessary');
    }

    // Check consent status
    const hasValidConsent = await this.checkValidConsent(dataSubjectId);
    if (!hasValidConsent) {
      eligibilityReasons.push('consent_withdrawn');
    }

    // Check for legal obligations that prevent erasure
    const legalObligations = await this.checkLegalObligations(dataSubjectId);
    if (legalObligations.length > 0) {
      restrictions.push(...legalObligations);
    }

    return {
      eligible: eligibilityReasons.length > 0 && restrictions.length === 0,
      reasons: eligibilityReasons,
      restrictions,
      legalBasis: eligibilityReasons[0] || null
    };
  }

  getDataSubjectRights() {
    return {
      access: 'Right to obtain confirmation of processing and access to your personal data',
      rectification: 'Right to correct inaccurate or incomplete personal data',
      erasure: 'Right to deletion of your personal data under certain circumstances',
      restriction: 'Right to restrict processing of your personal data',
      portability: 'Right to receive your data in a structured, machine-readable format',
      objection: 'Right to object to processing based on legitimate interests',
      withdraw_consent: 'Right to withdraw consent at any time',
      complaint: 'Right to lodge a complaint with supervisory authority'
    };
  }

  async logDataSubjectRequest(requestType, dataSubjectId, requestData) {
    const requestId = crypto.randomUUID();

    const logEntry = {
      id: requestId,
      type: requestType,
      dataSubjectId,
      requestData,
      timestamp: new Date().toISOString(),
      status: 'received'
    };

    await this.storeRequestLog(logEntry);
    await this.sendRequestAcknowledgment(dataSubjectId, requestId, requestType);

    return requestId;
  }

  async updateRequestStatus(requestId, status, result = null) {
    const update = {
      requestId,
      status,
      result,
      updatedAt: new Date().toISOString()
    };

    await this.storeRequestUpdate(update);
  }

  async generateExportFile(data) {
    return {
      url: '/downloads/export-12345.json',
      expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
      size: JSON.stringify(data).length
    };
  }

  // Database operation methods (implement according to your system)
  async getImageProcessingData(dataSubjectId) { return {}; }
  async getConsentData(dataSubjectId) { return {}; }
  async eraseImageData(dataSubjectId) { return { deleted: true, count: 0 }; }
  async verifyErasure(dataSubjectId) { return { complete: true, exceptions: [] }; }
  async checkDataNecessity(dataSubjectId) { return false; }
  async checkValidConsent(dataSubjectId) { return false; }
  async checkLegalObligations(dataSubjectId) { return []; }
  async storeRequestLog(logEntry) { console.log('Storing request:', logEntry); }
  async storeRequestUpdate(update) { console.log('Updating request:', update); }
  async sendRequestAcknowledgment(dataSubjectId, requestId, requestType) {
    console.log(`Acknowledgment sent for ${requestType} request ${requestId}`);
  }
}

export default DataSubjectRightsManager;

// services/gdpr-compliance-monitor.js
class GDPRComplianceMonitor {
  constructor() {
    this.complianceChecks = [
      'consent_validity',
      'data_minimization',
      'retention_compliance',
      'security_measures',
      'data_subject_rights'
    ];
  }

  async runComplianceAudit() {
    const auditResults = {
      auditId: crypto.randomUUID(),
      timestamp: new Date().toISOString(),
      scope: 'image_optimization_processing',
      results: {}
    };

    for (const check of this.complianceChecks) {
      try {
        auditResults.results[check] = await this.runComplianceCheck(check);
      } catch (error) {
        auditResults.results[check] = {
          status: 'error',
          error: error.message
        };
      }
    }

    auditResults.overallStatus = this.calculateOverallCompliance(auditResults.results);
    auditResults.recommendations = this.generateRecommendations(auditResults.results);

    await this.storeAuditResults(auditResults);

    return auditResults;
  }

  async runComplianceCheck(checkType) {
    switch (checkType) {
      case 'consent_validity':
        return await this.checkConsentValidity();
      case 'data_minimization':
        return await this.checkDataMinimization();
      case 'retention_compliance':
        return await this.checkRetentionCompliance();
      case 'security_measures':
        return await this.checkSecurityMeasures();
      case 'data_subject_rights':
        return await this.checkDataSubjectRights();
      default:
        throw new Error(`Unknown compliance check: ${checkType}`);
    }
  }

  async checkConsentValidity() {
    const recentConsents = await this.getRecentConsents(30);
    const invalidConsents = [];

    for (const consent of recentConsents) {
      const validation = await this.validateConsent(consent);

      if (!validation.valid) {
        invalidConsents.push({
          consentId: consent.id,
          issues: validation.issues
        });
      }
    }

    return {
      status: invalidConsents.length === 0 ? 'compliant' : 'non_compliant',
      totalConsents: recentConsents.length,
      invalidConsents: invalidConsents.length,
      issues: invalidConsents
    };
  }

  async checkDataMinimization() {
    const processedData = await this.getProcessedDataSample();
    const minimizationIssues = [];

    for (const dataItem of processedData) {
      if (dataItem.metadata && dataItem.metadata.length > 10) {
        minimizationIssues.push({
          dataId: dataItem.id,
          issue: 'excessive_metadata_retention'
        });
      }
    }

    return {
      status: minimizationIssues.length === 0 ? 'compliant' : 'needs_attention',
      sampledRecords: processedData.length,
      issues: minimizationIssues
    };
  }

  async checkRetentionCompliance() {
    const expiredData = await this.getExpiredData();

    return {
      status: expiredData.length === 0 ? 'compliant' : 'non_compliant',
      expiredRecords: expiredData.length
    };
  }

  async checkSecurityMeasures() {
    const securityChecks = {
      encryption: await this.checkEncryption(),
      accessControls: await this.checkAccessControls(),
      backupSecurity: await this.checkBackupSecurity()
    };

    const failedChecks = Object.entries(securityChecks)
      .filter(([key, result]) => !result.passed)
      .map(([key]) => key);

    return {
      status: failedChecks.length === 0 ? 'compliant' : 'non_compliant',
      checks: securityChecks,
      failedChecks
    };
  }

  async checkDataSubjectRights() {
    const requestStats = await this.getDataSubjectRequestStats();
    const averageResponseTime = requestStats.averageResponseTime;
    const maxAllowedTime = 30; // days

    return {
      status: averageResponseTime <= maxAllowedTime ? 'compliant' : 'non_compliant',
      averageResponseTime,
      maxAllowedTime,
      pendingRequests: requestStats.pending
    };
  }

  calculateOverallCompliance(results) {
    const statuses = Object.values(results).map(r => r.status);
    const nonCompliant = statuses.filter(s => s === 'non_compliant').length;

    return nonCompliant > 0 ? 'non_compliant' : 'compliant';
  }

  generateRecommendations(results) {
    const recommendations = [];

    Object.entries(results).forEach(([check, result]) => {
      if (result.status === 'non_compliant') {
        recommendations.push({
          priority: 'high',
          check,
          recommendation: this.getRecommendationForCheck(check)
        });
      }
    });

    return recommendations;
  }

  getRecommendationForCheck(check) {
    const recommendations = {
      consent_validity: 'Update consent collection mechanisms and refresh invalid consents',
      data_minimization: 'Implement stricter data collection policies',
      retention_compliance: 'Implement automated data deletion',
      security_measures: 'Enhance security controls and encryption',
      data_subject_rights: 'Improve request handling response times'
    };

    return recommendations[check] || 'Review compliance measures';
  }

  // Implementation methods (customize for your system)
  async getRecentConsents(days) { return []; }
  async validateConsent(consent) { return { valid: true, issues: [] }; }
  async getProcessedDataSample() { return []; }
  async getExpiredData() { return []; }
  async checkEncryption() { return { passed: true }; }
  async checkAccessControls() { return { passed: true }; }
  async checkBackupSecurity() { return { passed: true }; }
  async getDataSubjectRequestStats() {
    return { averageResponseTime: 15, pending: 0 };
  }
  async storeAuditResults(results) {
    console.log('Storing audit results:', results);
  }
}

export default GDPRComplianceMonitor;

// utils/gdpr-documentation.js
class GDPRDocumentationGenerator {
  generatePrivacyPolicy(organizationData) {
    return `
# Privacy Policy - Image Processing Service

**Last Updated:** ${new Date().toLocaleDateString()}

## 1. Introduction

${organizationData.name} respects your privacy and is committed to protecting your personal data when you use our image optimization services.

## 2. Data We Process

### Image Data
- Original images you upload for optimization
- Optimized versions of your images
- Image metadata (removed for privacy protection)

### Technical Data
- IP address (anonymized after processing)
- Browser type and device information
- Processing preferences and settings

## 3. Legal Basis for Processing

We process your personal data based on:
- **Consent**: For image processing and optimization services
- **Legitimate Interest**: For service improvement and security

## 4. How We Use Your Data

### Primary Purposes
- Image optimization and format conversion
- Service delivery and performance improvement
- Security and fraud prevention

## 5. Data Sharing

We may use approved third-party services for:
- Content Delivery Networks (CDN)
- Cloud storage and processing
- Analytics (anonymized data only)

All third-party processors are GDPR-compliant.

## 6. Data Retention

- **Image Data**: Maximum 30 days
- **Processing Logs**: 90 days
- **Analytics Data**: 12 months (anonymized)
- **Consent Records**: 3 years

## 7. Your Rights

You have the right to:
- Access your personal data
- Rectify inaccurate data
- Erase your data
- Restrict processing
- Data portability
- Object to processing
- Withdraw consent

## 8. Security

We implement encryption, access controls, and regular security assessments to protect your data.

## 9. Contact

Data Protection Officer: ${organizationData.dpoEmail}
General Inquiries: ${organizationData.contactEmail}

## 10. Complaints

You have the right to lodge a complaint with your local data protection authority.
    `;
  }

  generateConsentForm() {
    return `
# Image Processing Consent

## Your Consent is Important

We need your consent to process your images and personal data.

### What we do:
- ✅ Optimize images for better performance
- ✅ Remove metadata for privacy protection
- ✅ Store optimized images temporarily

### Your choices:

**Required for Service:**
☐ I consent to processing my images for optimization
☐ I consent to temporary storage (up to 30 days)

**Optional:**
☐ I consent to third-party CDN services
☐ I consent to anonymized analytics

### Your rights:
- ✅ Withdraw consent at any time
- ✅ Access your data
- ✅ Request deletion
- ✅ Data portability

**Contact:** privacy@example.com for questions about your data.
    `;
  }
}

export default GDPRDocumentationGenerator;