server.js

const express = require('express');
const cors = require('cors');
const multer = require('multer');
const { BlobServiceClient, StorageSharedKeyCredential } = require('@azure/storage-blob');

const app = express();
const port = process.env.PORT || 8080;

// Middleware
app.use(cors());
app.use(express.json({ limit: '50mb' }));
app.use(express.urlencoded({ extended: true, limit: '50mb' }));

// Memory storage for file uploads
const storage = multer.memoryStorage();
const upload = multer({ storage });

// Load environment variables
require('dotenv').config();

// Azure configuration
const AZURE_CONFIG = {
  accountName: process.env.AZURE_STORAGE_ACCOUNT_NAME,
  accountKey: process.env.AZURE_STORAGE_ACCOUNT_KEY,
  container: process.env.AZURE_STORAGE_CONTAINER
};

// API Key for authentication
const API_KEY = process.env.API_KEY || 'azure-upload-service-key-2025';

// Middleware to check API key
const authenticateApiKey = (req, res, next) => {
  const providedKey = req.headers['x-api-key'] || req.headers['authorization']?.replace('Bearer ', '');
  
  if (!providedKey) {
    return res.status(401).json({ 
      success: false, 
      error: 'API key required. Provide via X-API-Key header or Authorization: Bearer <key>' 
    });
  }
  
  if (providedKey !== API_KEY) {
    return res.status(403).json({ 
      success: false, 
      error: 'Invalid API key' 
    });
  }
  
  next();
};

console.log('🔧 Azure Upload Service Starting...');
console.log('📋 Configuration:', {
  accountName: AZURE_CONFIG.accountName,
  container: AZURE_CONFIG.container,
  hasAccountKey: !!AZURE_CONFIG.accountKey,
  keyLength: AZURE_CONFIG.accountKey?.length
});

// Initialize Azure client
let azureClient;
try {
  const credential = new StorageSharedKeyCredential(AZURE_CONFIG.accountName, AZURE_CONFIG.accountKey);
  const serviceUrl = `https://${AZURE_CONFIG.accountName}.blob.core.windows.net`;
  const blobServiceClient = new BlobServiceClient(serviceUrl, credential);
  azureClient = blobServiceClient.getContainerClient(AZURE_CONFIG.container);
  console.log('✅ Azure client initialized successfully');
} catch (error) {
  console.error('❌ Azure client initialization failed:', error);
  process.exit(1);
}

// Health check endpoint
app.get('/health', (req, res) => {
  res.json({ 
    status: 'ok', 
    service: 'azure-upload-service',
    timestamp: new Date().toISOString(),
    config: {
      accountName: AZURE_CONFIG.accountName,
      container: AZURE_CONFIG.container
    }
  });
});

// Test Azure connectivity (protected)
app.get('/test-azure', authenticateApiKey, async (req, res) => {
  try {
    console.log('🔍 Testing Azure connectivity...');
    
    // Test container access
    const exists = await azureClient.exists();
    console.log(`📦 Container '${AZURE_CONFIG.container}' exists: ${exists}`);
    
    // Test upload with tiny file
    const testBlob = `test-${Date.now()}.txt`;
    const testContent = Buffer.from('test connectivity');
    const blockBlobClient = azureClient.getBlockBlobClient(testBlob);
    
    console.log(`🔍 Testing upload: ${testBlob}`);
    const uploadResponse = await blockBlobClient.upload(testContent, testContent.length, {
      blobHTTPHeaders: { blobContentType: 'text/plain' }
    });
    
    console.log('📊 Upload response:', {
      requestId: uploadResponse.requestId,
      version: uploadResponse.version,
      date: uploadResponse.date,
      etag: uploadResponse.etag,
      errorCode: uploadResponse.errorCode
    });
    
    // Clean up
    await blockBlobClient.delete();
    console.log('🧹 Test file deleted');
    
    res.json({
      success: true,
      containerExists: exists,
      uploadTest: {
        requestId: uploadResponse.requestId,
        version: uploadResponse.version,
        date: uploadResponse.date,
        etag: uploadResponse.etag,
        hasRequestId: !!uploadResponse.requestId
      }
    });
    
  } catch (error) {
    console.error('❌ Azure test failed:', error);
    res.status(500).json({
      success: false,
      error: error.message,
      stack: error.stack
    });
  }
});

// Upload base64 data (protected)
app.post('/upload-base64', authenticateApiKey, async (req, res) => {
  try {
    const { filename, base64Data, contentType = 'application/octet-stream' } = req.body;
    
    if (!filename || !base64Data) {
      return res.status(400).json({ error: 'filename and base64Data are required' });
    }
    
    console.log(`🚀 Upload request: ${filename}, type: ${contentType}`);
    console.log(`📊 Base64 data length: ${base64Data.length} characters`);
    
    // Convert base64 to buffer
    const buffer = Buffer.from(base64Data, 'base64');
    console.log(`📊 Buffer size: ${buffer.length} bytes`);
    
    // Upload to Azure
    const blockBlobClient = azureClient.getBlockBlobClient(filename);
    
    console.log(`🎯 Starting Azure upload...`);
    const startTime = Date.now();
    
    const uploadResponse = await blockBlobClient.upload(buffer, buffer.length, {
      blobHTTPHeaders: { blobContentType: contentType }
    });
    
    const uploadTime = Date.now() - startTime;
    console.log(`⏱️ Upload completed in ${uploadTime}ms`);
    
    // Detailed response logging
    console.log('📊 Detailed upload response:', {
      requestId: uploadResponse.requestId,
      version: uploadResponse.version,
      date: uploadResponse.date,
      etag: uploadResponse.etag,
      lastModified: uploadResponse.lastModified,
      errorCode: uploadResponse.errorCode,
      responseType: typeof uploadResponse,
      responseConstructor: uploadResponse.constructor.name,
      responseKeys: Object.keys(uploadResponse)
    });
    
    // Test file accessibility
    const exists = await blockBlobClient.exists();
    const blobUrl = blockBlobClient.url;
    
    console.log(`✅ File uploaded successfully: ${filename}`);
    console.log(`🔗 Blob URL: ${blobUrl}`);
    console.log(`📋 File exists check: ${exists}`);
    
    res.json({
      success: true,
      filename,
      blobUrl,
      exists,
      uploadTime,
      response: {
        requestId: uploadResponse.requestId,
        version: uploadResponse.version,
        date: uploadResponse.date,
        etag: uploadResponse.etag,
        lastModified: uploadResponse.lastModified,
        errorCode: uploadResponse.errorCode,
        hasRequestId: !!uploadResponse.requestId
      }
    });
    
  } catch (error) {
    console.error('❌ Upload failed:', error);
    res.status(500).json({
      success: false,
      error: error.message,
      stack: error.stack
    });
  }
});

// Upload file endpoint (protected)
app.post('/upload-file', authenticateApiKey, upload.single('file'), async (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({ error: 'No file provided' });
    }
    
    const filename = req.body.filename || req.file.originalname || `upload-${Date.now()}`;
    const contentType = req.file.mimetype;
    
    console.log(`🚀 File upload: ${filename}, type: ${contentType}, size: ${req.file.size} bytes`);
    
    // Upload to Azure
    const blockBlobClient = azureClient.getBlockBlobClient(filename);
    
    const uploadResponse = await blockBlobClient.upload(req.file.buffer, req.file.size, {
      blobHTTPHeaders: { blobContentType: contentType }
    });
    
    console.log('📊 Upload response:', {
      requestId: uploadResponse.requestId,
      version: uploadResponse.version,
      hasRequestId: !!uploadResponse.requestId
    });
    
    const blobUrl = blockBlobClient.url;
    
    res.json({
      success: true,
      filename,
      blobUrl,
      response: {
        requestId: uploadResponse.requestId,
        version: uploadResponse.version,
        date: uploadResponse.date,
        etag: uploadResponse.etag,
        hasRequestId: !!uploadResponse.requestId
      }
    });
    
  } catch (error) {
    console.error('❌ File upload failed:', error);
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

app.listen(port, () => {
  console.log(`🚀 Azure Upload Service running on port ${port}`);
  console.log(`📍 Endpoints:`);
  console.log(`   GET  /health - Health check`);
  console.log(`   GET  /test-azure - Test Azure connectivity`);
  console.log(`   POST /upload-base64 - Upload base64 data`);
  console.log(`   POST /upload-file - Upload file (multipart)`);
});

// Graceful shutdown
process.on('SIGTERM', () => {
  console.log('🛑 Received SIGTERM, shutting down gracefully');
  process.exit(0);
});

process.on('SIGINT', () => {
  console.log('🛑 Received SIGINT, shutting down gracefully');
  process.exit(0);
});