/**
 * Supabase Storage Service
 * Handles file uploads to Supabase Storage with organized folder structure
 * 
 * Folder Structure:
 * CampVerse/
 * ├── events/
 * │   ├── logos/
 * │   └── banners/
 * ├── users/
 * │   ├── profiles/
 * │   └── documents/
 * │       ├── id-cards/
 * │       └── permissions/
 * ├── certificates/
 * │   └── {eventId}/
 * └── institutions/
 *     └── logos/
 */

const { createClient } = require('@supabase/supabase-js');
const path = require('path');
const { randomUUID } = require('crypto');
const { logger } = require('../Middleware/errorHandler');

class SupabaseStorageService {
  constructor() {
    this.supabaseUrl = process.env.SUPABASE_URL;
    this.supabaseAnonKey = process.env.SUPABASE_ANON_KEY;
    this.supabaseServiceKey = process.env.SUPABASE_SERVICE_KEY; // For admin operations
    this.bucketName = process.env.SUPABASE_BUCKET_NAME || 'campverse-storage';
    this.baseFolder = 'CampVerse';
    this.initialized = false;
    
    if (this.supabaseUrl && this.supabaseAnonKey) {
      // Client for authenticated operations
      this.supabase = createClient(this.supabaseUrl, this.supabaseAnonKey);
      
      // Admin client for operations that bypass RLS (if service key provided)
      if (this.supabaseServiceKey) {
        this.supabaseAdmin = createClient(this.supabaseUrl, this.supabaseServiceKey, {
          auth: {
            autoRefreshToken: false,
            persistSession: false
          }
        });
      }
      
      this.initialized = true;
      logger.info('Supabase Storage Service initialized with authentication');
    } else {
      logger.error('Supabase credentials missing. Please set SUPABASE_URL and SUPABASE_ANON_KEY');
    }
  }

  /**
   * Create authenticated Supabase client for a specific user
   * This method would need to be called with proper JWT token
   */
  createAuthenticatedClient(userToken) {
    if (!userToken) {
      return this.supabaseAdmin || this.supabase; // Fallback to admin or anon client
    }
    
    const authClient = createClient(this.supabaseUrl, this.supabaseAnonKey);
    authClient.auth.setSession({ access_token: userToken, refresh_token: null });
    return authClient;
  }

  /**
   * Generate organized file path with timestamp and unique ID
   */
  generateFilePath(category, subcategory, filename, userId = null) {
    const timestamp = Date.now();
    const uniqueId = randomUUID().substring(0, 8);
    const fileExtension = path.extname(filename);
    const baseName = path.basename(filename, fileExtension);
    const cleanFilename = `${timestamp}_${uniqueId}_${baseName}${fileExtension}`;
    
    if (userId) {
      return `${this.baseFolder}/${category}/${userId}/${subcategory}/${cleanFilename}`;
    }
    return `${this.baseFolder}/${category}/${subcategory}/${cleanFilename}`;
  }

  /**
   * Upload file to Supabase Storage (Private)
   */
  async uploadFile(fileBuffer, filename, filePath, mimetype, metadata = {}, _userToken = null) {
    try {
      if (!this.initialized) {
        throw new Error('Supabase Storage Service not initialized');
      }

      // Use admin client for upload to bypass RLS, or authenticated client
      const client = this.supabaseAdmin || this.supabase;
      
      const { data, error } = await client.storage
        .from(this.bucketName)
        .upload(filePath, fileBuffer, {
          contentType: mimetype,
          metadata: {
            originalName: filename,
            uploadedAt: new Date().toISOString(),
            ...metadata
          }
        });

      if (error) {
        throw new Error(`Supabase upload error: ${error.message}`);
      }

      // For private storage, generate a signed URL instead of public URL
      const { data: signedUrlData, error: urlError } = await client.storage
        .from(this.bucketName)
        .createSignedUrl(filePath, 365 * 24 * 60 * 60); // 1 year expiry

      if (urlError) {
        logger.warn(`Could not generate signed URL for ${filePath}, falling back to path`);
        // Return the path for later URL generation
        return {
          url: filePath, // Store path instead of URL
          path: filePath,
          filename: data.path,
          size: fileBuffer.length,
          mimetype,
          isPrivate: true
        };
      }

      logger.info(`File uploaded to Supabase successfully: ${filePath}`);
      
      return {
        url: signedUrlData.signedUrl,
        path: filePath,
        filename: data.path,
        size: fileBuffer.length,
        mimetype,
        isPrivate: true
      };
    } catch (error) {
      logger.error(`Failed to upload file to Supabase: ${filePath}`, error);
      throw error;
    }
  }

  /**
   * Generate signed URL for private file access
   */
  async generateSignedUrl(filePath, expiresIn = 3600) {
    try {
      if (!this.initialized) {
        throw new Error('Supabase Storage Service not initialized');
      }

      const client = this.supabaseAdmin || this.supabase;
      const { data, error } = await client.storage
        .from(this.bucketName)
        .createSignedUrl(filePath, expiresIn);

      if (error) {
        throw new Error(`Failed to generate signed URL: ${error.message}`);
      }

      return data.signedUrl;
    } catch (error) {
      logger.error(`Failed to generate signed URL for: ${filePath}`, error);
      throw error;
    }
  }

  /**
   * Upload event image (logo or banner)
   */
  async uploadEventImage(fileBuffer, filename, type, mimetype) {
    try {
      // Validate file type
      const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp'];
      if (!allowedTypes.includes(mimetype)) {
        throw new Error(`Invalid file type: ${mimetype}. Allowed types: ${allowedTypes.join(', ')}`);
      }

      const filePath = this.generateFilePath('events', `${type}s`, filename);
      
      const metadata = {
        category: 'event',
        type,
        fileType: 'image'
      };

      const result = await this.uploadFile(fileBuffer, filename, filePath, mimetype, metadata);
      
      logger.info(`Event ${type} uploaded to Supabase successfully: ${filename}`);
      return result.url; // Return URL for backward compatibility
    } catch (error) {
      logger.error(`Failed to upload event ${type} to Supabase:`, error);
      throw error;
    }
  }

  /**
   * Upload profile photo
   */
  async uploadProfilePhoto(fileBuffer, filename, userId, mimetype) {
    try {
      // Validate file type
      const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp'];
      if (!allowedTypes.includes(mimetype)) {
        throw new Error(`Invalid file type: ${mimetype}. Allowed types: ${allowedTypes.join(', ')}`);
      }

      const filePath = this.generateFilePath('users', 'profiles', filename, userId);
      
      const metadata = {
        category: 'profile',
        userId,
        fileType: 'image'
      };

      const result = await this.uploadFile(fileBuffer, filename, filePath, mimetype, metadata);
      
      logger.info(`Profile photo uploaded to Supabase successfully for user: ${userId}`);
      return result.url; // Return URL for backward compatibility
    } catch (error) {
      logger.error(`Failed to upload profile photo to Supabase for user ${userId}:`, error);
      throw error;
    }
  }

  /**
   * Upload user document (ID card, event permission, etc.)
   */
  async uploadUserDocument(fileBuffer, filename, documentType, userId, mimetype) {
    try {
      // Validate file type
      const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'application/pdf'];
      if (!allowedTypes.includes(mimetype)) {
        throw new Error(`Invalid file type: ${mimetype}. Allowed types: ${allowedTypes.join(', ')}`);
      }

      const filePath = this.generateFilePath('users', `documents/${documentType}`, filename, userId);
      
      const metadata = {
        category: 'user_document',
        documentType,
        userId,
        fileType: mimetype.includes('image') ? 'image' : 'document'
      };

      const result = await this.uploadFile(fileBuffer, filename, filePath, mimetype, metadata);
      
      logger.info(`User document uploaded to Supabase successfully: ${documentType} for user ${userId}`);
      return result.url;
    } catch (error) {
      logger.error('Failed to upload user document to Supabase:', error);
      throw error;
    }
  }

  /**
   * Upload certificate
   */
  async uploadCertificate(fileBuffer, filename, eventId, userId, mimetype) {
    try {
      // Validate file type
      const allowedTypes = ['application/pdf', 'image/jpeg', 'image/jpg', 'image/png'];
      if (!allowedTypes.includes(mimetype)) {
        throw new Error(`Invalid file type: ${mimetype}. Allowed types: ${allowedTypes.join(', ')}`);
      }

      const filePath = this.generateFilePath('certificates', eventId, filename, userId);
      
      const metadata = {
        category: 'certificate',
        eventId,
        userId,
        fileType: mimetype.includes('pdf') ? 'pdf' : 'image'
      };

      const result = await this.uploadFile(fileBuffer, filename, filePath, mimetype, metadata);
      
      logger.info(`Certificate uploaded to Supabase successfully for event ${eventId}, user ${userId}`);
      return result.url;
    } catch (error) {
      logger.error('Failed to upload certificate to Supabase:', error);
      throw error;
    }
  }

  /**
   * Upload certificate template
   */
  async uploadCertificateTemplate(fileBuffer, filename, eventId, templateType, mimetype) {
    try {
      // Validate file type
      const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png'];
      if (!allowedTypes.includes(mimetype)) {
        throw new Error(`Invalid file type: ${mimetype}. Allowed types: ${allowedTypes.join(', ')}`);
      }

      const filePath = `${this.baseFolder}/certificates/assets/${eventId}/templates/${templateType}_${Date.now()}_${filename}`;
      
      const metadata = {
        category: 'certificate-template',
        eventId,
        templateType,
        fileType: 'image'
      };

      const result = await this.uploadFile(fileBuffer, filename, filePath, mimetype, metadata);
      
      logger.info(`Certificate template uploaded to Supabase successfully for event ${eventId}, type: ${templateType}`);
      return result;
    } catch (error) {
      logger.error('Failed to upload certificate template to Supabase:', error);
      throw error;
    }
  }

  /**
   * Upload certificate logo (organization logo)
   */
  async uploadCertificateLogo(fileBuffer, filename, eventId, logoType, mimetype) {
    try {
      // Validate file type
      const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/webp'];
      if (!allowedTypes.includes(mimetype)) {
        throw new Error(`Invalid file type: ${mimetype}. Allowed types: ${allowedTypes.join(', ')}`);
      }

      const filePath = `${this.baseFolder}/certificates/assets/${eventId}/logos/${logoType}_${Date.now()}_${filename}`;
      
      const metadata = {
        category: 'certificate-logo',
        eventId,
        logoType,
        fileType: 'image'
      };

      const result = await this.uploadFile(fileBuffer, filename, filePath, mimetype, metadata);
      
      logger.info(`Certificate logo uploaded to Supabase successfully for event ${eventId}, type: ${logoType}`);
      return result;
    } catch (error) {
      logger.error('Failed to upload certificate logo to Supabase:', error);
      throw error;
    }
  }

  /**
   * Upload certificate signature
   */
  async uploadCertificateSignature(fileBuffer, filename, eventId, signatureType, mimetype) {
    try {
      // Validate file type
      const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/webp'];
      if (!allowedTypes.includes(mimetype)) {
        throw new Error(`Invalid file type: ${mimetype}. Allowed types: ${allowedTypes.join(', ')}`);
      }

      const filePath = `${this.baseFolder}/certificates/assets/${eventId}/signatures/${signatureType}_${Date.now()}_${filename}`;
      
      const metadata = {
        category: 'certificate-signature',
        eventId,
        signatureType,
        fileType: 'image'
      };

      const result = await this.uploadFile(fileBuffer, filename, filePath, mimetype, metadata);
      
      logger.info(`Certificate signature uploaded to Supabase successfully for event ${eventId}, type: ${signatureType}`);
      return result;
    } catch (error) {
      logger.error('Failed to upload certificate signature to Supabase:', error);
      throw error;
    }
  }

  /**
   * Upload institution logo
   */
  async uploadInstitutionLogo(fileBuffer, filename, institutionId, mimetype) {
    try {
      // Validate file type
      const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp'];
      if (!allowedTypes.includes(mimetype)) {
        throw new Error(`Invalid file type: ${mimetype}. Allowed types: ${allowedTypes.join(', ')}`);
      }

      const filePath = this.generateFilePath('institutions', 'logos', filename, institutionId);
      
      const metadata = {
        category: 'institution',
        institutionId,
        fileType: 'image'
      };

      const result = await this.uploadFile(fileBuffer, filename, filePath, mimetype, metadata);
      
      logger.info(`Institution logo uploaded to Supabase successfully for institution: ${institutionId}`);
      return result.url;
    } catch (error) {
      logger.error('Failed to upload institution logo to Supabase:', error);
      throw error;
    }
  }

  /**
   * Delete file from Supabase Storage
   */
  async deleteFile(fileUrl) {
    try {
      if (!this.initialized) {
        throw new Error('Supabase Storage Service not initialized');
      }

      if (!fileUrl) {
        logger.warn('No file URL provided for deletion');
        return false;
      }

      logger.info(`Starting deletion for URL: ${fileUrl}`);

      // Extract filename from the URL - works for both public and signed URLs
      let filename = null;
      
      // For Supabase URLs, the filename is at the end of the path before any query parameters
      if (fileUrl.includes(this.supabaseUrl)) {
        // Remove query parameters (like ?token=...)
        const urlWithoutQuery = fileUrl.split('?')[0];
        // Get the last part of the path (the filename)
        const pathParts = urlWithoutQuery.split('/');
        filename = pathParts[pathParts.length - 1];
        
        logger.info(`Extracted filename: ${filename}`);
        
        // Since we know the file structure, we can find the user ID from the URL
        const userMatch = fileUrl.match(/\/users\/([^/]+)\/profiles\//);
        if (userMatch && userMatch[1]) {
          const userId = userMatch[1];
          const filePath = `CampVerse/users/${userId}/profiles/${filename}`;
          
          logger.info(`Constructed file path: ${filePath}`);
          
          // Use admin client for deletion to bypass RLS
          const client = this.supabaseAdmin || this.supabase;
          const { error } = await client.storage
            .from(this.bucketName)
            .remove([filePath]);

          if (error) {
            logger.error(`Deletion failed: ${error.message}`);
            return false;
          }

          logger.info(`File deleted successfully: ${filePath}`);
          return true;
        }
      }

      logger.warn(`Could not extract file information from URL: ${fileUrl}`);
      return false;
    } catch (error) {
      logger.error(`Failed to delete file from Supabase: ${fileUrl}`, error);
      return false; // Don't throw - deletion failures shouldn't break the app
    }
  }

  /**
   * List files in a folder
   */
  async listFiles(folderPath) {
    try {
      if (!this.initialized) {
        throw new Error('Supabase Storage Service not initialized');
      }

      const { data, error } = await this.supabase.storage
        .from(this.bucketName)
        .list(`${this.baseFolder}/${folderPath}`);

      if (error) {
        throw new Error(`Supabase list error: ${error.message}`);
      }

      const fileList = data.map(file => {
        const fullPath = `${this.baseFolder}/${folderPath}/${file.name}`;
        const { data: urlData } = this.supabase.storage
          .from(this.bucketName)
          .getPublicUrl(fullPath);

        return {
          name: file.name,
          path: fullPath,
          url: urlData.publicUrl,
          size: file.metadata?.size || 0,
          contentType: file.metadata?.mimetype || 'unknown',
          timeCreated: file.created_at,
          updated: file.updated_at
        };
      });

      logger.info(`Listed ${fileList.length} files in Supabase folder: ${folderPath}`);
      return fileList;
    } catch (error) {
      logger.error(`Failed to list files in Supabase folder: ${folderPath}`, error);
      throw error;
    }
  }

  /**
   * Health check
   */
  async healthCheck() {
    try {
      if (!this.initialized) {
        return {
          status: 'error',
          message: 'Supabase Storage service not initialized',
          initialized: false
        };
      }

      // Test bucket access by trying to list files
      const { error } = await this.supabase.storage
        .from(this.bucketName)
        .list('', { limit: 1 });

      if (error) {
        return {
          status: 'error',
          message: `Supabase Storage error: ${error.message}`,
          bucket: this.bucketName,
          initialized: this.initialized
        };
      }

      return {
        status: 'healthy',
        message: 'Supabase Storage service is operational',
        bucket: this.bucketName,
        initialized: this.initialized
      };
    } catch (error) {
      return {
        status: 'error',
        message: error.message,
        bucket: this.bucketName,
        initialized: this.initialized
      };
    }
  }
}

// Create singleton instance
const supabaseStorageService = new SupabaseStorageService();

module.exports = {
  SupabaseStorageService,
  supabaseStorageService
};