/**
 * Local Storage Service
 * Replacement for Firebase/Drive storage - stores files locally
 * This is a temporary solution - files will be lost on container restart
 */

const fs = require('fs').promises;
const path = require('path');
const { randomUUID } = require('crypto');
const { logger } = require('../Middleware/errorHandler');

class LocalStorageService {
  constructor() {
    this.baseDir = path.join(__dirname, '..', 'uploads');
    this.initialized = false;
    this.init();
  }

  async init() {
    try {
      // Create uploads directory if it doesn't exist
      await fs.mkdir(this.baseDir, { recursive: true });
      await fs.mkdir(path.join(this.baseDir, 'events'), { recursive: true });
      await fs.mkdir(path.join(this.baseDir, 'profiles'), { recursive: true });
      this.initialized = true;
      logger.info('Local storage service initialized');
    } catch (error) {
      logger.error('Failed to initialize local storage service:', error);
    }
  }

  /**
   * Generate file path
   */
  generateFilePath(category, filename) {
    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}`;
    
    return path.join(this.baseDir, category, cleanFilename);
  }

  /**
   * Upload event image (logo or banner)
   */
  async uploadEventImage(fileBuffer, filename, type, _mimetype) {
    try {
      if (!this.initialized) {
        throw new Error('Local storage service not initialized');
      }

      const filePath = this.generateFilePath('events', filename);
      await fs.writeFile(filePath, fileBuffer);
      
      // Return a relative URL that could be served by express.static
      const relativePath = path.relative(this.baseDir, filePath);
      const url = `/uploads/${relativePath.replace(/\\/g, '/')}`;
      
      logger.info(`Event ${type} uploaded locally: ${url}`);
      return url;
    } catch (error) {
      logger.error(`Failed to upload event ${type}:`, error);
      throw error;
    }
  }

  /**
   * Upload profile photo
   */
  async uploadProfilePhoto(fileBuffer, filename, userId, _mimetype) {
    try {
      if (!this.initialized) {
        throw new Error('Local storage service not initialized');
      }

      const filePath = this.generateFilePath('profiles', filename);
      await fs.writeFile(filePath, fileBuffer);
      
      const relativePath = path.relative(this.baseDir, filePath);
      const url = `/uploads/${relativePath.replace(/\\/g, '/')}`;
      
      logger.info(`Profile photo uploaded locally for user ${userId}: ${url}`);
      return url;
    } catch (error) {
      logger.error('Failed to upload profile photo:', error);
      throw error;
    }
  }

  /**
   * Delete file (placeholder - files are small and cleanup can be manual)
   */
  async deleteEventImage(url) {
    try {
      if (!url || !url.startsWith('/uploads/')) {
        return; // Not a local file or invalid URL
      }
      
      const relativePath = url.replace('/uploads/', '');
      const filePath = path.join(this.baseDir, relativePath);
      
      await fs.unlink(filePath);
      logger.info(`Deleted local file: ${url}`);
    } catch (error) {
      logger.warn(`Failed to delete local file ${url}:`, error.message);
      // Don't throw - deletion failures shouldn't break the app
    }
  }

  /**
   * Delete profile photo
   */
  async deleteProfilePhoto(url) {
    return this.deleteEventImage(url); // Same logic
  }

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

      // Check if uploads directory exists and is writable
      const fs = require('fs').promises;
      await fs.access(this.baseDir, fs.constants.W_OK);

      return {
        status: 'healthy',
        message: 'Local storage service is operational',
        baseDir: this.baseDir,
        initialized: this.initialized
      };
    } catch (error) {
      return {
        status: 'error',
        message: error.message,
        baseDir: this.baseDir,
        initialized: this.initialized
      };
    }
  }
}

// Create singleton instance
const localStorageService = new LocalStorageService();

module.exports = {
  uploadEventImage: (fileBuffer, filename, type, mimetype) => 
    localStorageService.uploadEventImage(fileBuffer, filename, type, mimetype),
  uploadProfilePhoto: (fileBuffer, filename, userId, mimetype) => 
    localStorageService.uploadProfilePhoto(fileBuffer, filename, userId, mimetype),
  deleteEventImage: (url) => 
    localStorageService.deleteEventImage(url),
  deleteProfilePhoto: (url) => 
    localStorageService.deleteProfilePhoto(url),
  healthCheck: () =>
    localStorageService.healthCheck(),
  localStorageService
};