File Message

import { 
  FileRepository, 
  MessageRepository, 
  MessageContentType 
} from '@amityco/ts-sdk';

// Complete file message creation process
async function createFileMessage(subChannelId: string, file: File) {
  try {
    // Step 1: Upload file with progress tracking
    const onUploading = (percent: number) => {
      console.log(`Upload progress: ${percent}%`);
      updateProgressBar(percent);
    };

    console.log('Starting file upload...');
    const formData = new FormData();
    formData.append('files', file);

    const { data: uploadedFiles } = await FileRepository.uploadFile(
      formData, 
      onUploading
    );
    const { fileId, fileName, fileSize, mimeType } = uploadedFiles[0];

    // Step 2: Create file message with uploaded file
    const fileMessage = {
      subChannelId: subChannelId,
      dataType: MessageContentType.FILE,
      fileId: fileId,
      caption: 'Important project documentation attached 📁',
      tags: ['documentation', 'project', 'important'],
      metadata: {
        file: {
          original_name: file.name,
          file_size: file.size,
          mime_type: file.type,
          uploaded_at: new Date().toISOString(),
          checksum: await calculateFileChecksum(file)
        },
        content: {
          type: 'documentation',
          category: 'project_files',
          importance: 'high',
          access_level: 'team'
        },
        workflow: {
          requires_approval: false,
          notification_required: true,
          retention_days: 365,
          backup_required: true
        }
      }
    };

    // Step 3: Send the message
    const { data: message } = await MessageRepository.createMessage(fileMessage);
    console.log('File message created:', message.messageId);
    return message;

  } catch (error) {
    console.error('Failed to create file message:', error);
    throw error;
  }
}

// Enhanced upload with validation and retry
async function createFileMessageWithValidation(
  subChannelId: string, 
  file: File,
  options: {
    maxFileSize?: number;
    allowedTypes?: string[];
    onProgress?: (progress: { percentage: number; stage: string }) => void;
  } = {}
) {
  try {
    const { 
      maxFileSize = 100 * 1024 * 1024, // 100MB default
      allowedTypes = [], // Empty means all types allowed
      onProgress 
    } = options;

    // Validate file before upload
    if (file.size > maxFileSize) {
      throw new Error(`File size ${formatFileSize(file.size)} exceeds limit of ${formatFileSize(maxFileSize)}`);
    }

    if (allowedTypes.length > 0 && !allowedTypes.includes(file.type)) {
      throw new Error(`File type ${file.type} is not allowed`);
    }

    onProgress?.({ percentage: 0, stage: 'validation_complete' });

    // Upload with detailed progress
    const formData = new FormData();
    formData.append('files', file);

    const onUploading = (percent: number) => {
      onProgress?.({ percentage: percent * 0.8, stage: 'uploading' }); // 80% for upload
    };

    const { data: uploadedFiles } = await FileRepository.uploadFile(
      formData, 
      onUploading
    );
    const { fileId } = uploadedFiles[0];

    onProgress?.({ percentage: 85, stage: 'processing' });

    // Create message
    const fileMessage = {
      subChannelId,
      dataType: MessageContentType.FILE,
      fileId,
      caption: `File uploaded: ${file.name} ✅`,
      metadata: {
        validation: {
          size_checked: true,
          type_validated: true,
          virus_scanned: false // Would require additional service
        }
      }
    };

    const { data: message } = await MessageRepository.createMessage(fileMessage);
    
    onProgress?.({ percentage: 100, stage: 'complete' });
    return message;

  } catch (error) {
    onProgress?.({ percentage: 0, stage: 'failed' });
    console.error('File message creation failed:', error);
    throw error;
  }
}

// Utility functions
function formatFileSize(bytes: number): string {
  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
  if (bytes === 0) return '0 Bytes';
  const i = Math.floor(Math.log(bytes) / Math.log(1024));
  return Math.round(bytes / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i];
}

async function calculateFileChecksum(file: File): Promise<string> {
  const buffer = await file.arrayBuffer();
  const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
}

// Batch file upload for multiple files
async function createMultipleFileMessages(
  subChannelId: string, 
  files: File[]
) {
  const results = [];
  
  for (const [index, file] of files.entries()) {
    try {
      console.log(`Processing file ${index + 1} of ${files.length}: ${file.name}`);
      const message = await createFileMessage(subChannelId, file);
      results.push({ success: true, message, file: file.name });
    } catch (error) {
      results.push({ success: false, error, file: file.name });
    }
  }
  
  return results;
}