server.js

require('dotenv').config();
const express = require('express');
const cors = require('cors');
const multer = require('multer');
const path = require('path');
const fs = require('fs');
const axios = require('axios');
const audioProcessor = require('./services/audioProcessor');
const fingerprinter = require('./services/fingerprinter');

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

// Middleware
app.use(cors());
app.use(express.json());
app.use(express.static('public'));

// Create necessary directories
const dirs = ['uploads', 'temp'];
dirs.forEach(dir => {
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir, { recursive: true });
  }
});

// Configure multer for file uploads
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, 'uploads/');
  },
  filename: (req, file, cb) => {
    cb(null, Date.now() + '-' + file.originalname);
  }
});

const upload = multer({
  storage: storage,
  limits: { fileSize: 500 * 1024 * 1024 }, // 500MB limit
  fileFilter: (req, file, cb) => {
    const ext = path.extname(file.originalname).toLowerCase();
    if (ext === '.mp3' || ext === '.wav' || ext === '.m4a') {
      cb(null, true);
    } else {
      cb(new Error(`Invalid file type: ${ext || 'unknown'}. Please upload MP3, WAV, or M4A files only.`));
    }
  }
});

// Routes
app.get('/', (req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

const activeSessions = new Map();
const mixtapeNames = new Map();
const MIN_CONFIDENCE_THRESHOLD = 0.10;
const PARALLEL_BATCH_SIZE = 3;
const SPOTIFY_USER_ID = process.env.SPOTIFY_USER_ID || null;

// Upload and process audio file
app.post('/api/upload', upload.single('audio'), async (req, res) => {
  try {
    if (!req.file) {
      console.error('No file uploaded');
      return res.status(400).json({ error: 'No file uploaded' });
    }

    console.log(`File uploaded: ${req.file.originalname} (${req.file.size} bytes)`);
    const filePath = req.file.path;
    const sessionId = Date.now().toString();
    
    // Store mixtape name (remove extension)
    const mixtapeName = req.file.originalname.replace(/\.[^/.]+$/, '');
    mixtapeNames.set(sessionId, mixtapeName);

    res.json({ success: true, sessionId, filePath });

    processAudioFileStreaming(filePath, sessionId, mixtapeName).catch(error => {
      console.error('Background processing error:', error);
    });
  } catch (error) {
    console.error('Error processing upload:', error);
    res.status(500).json({ error: error.message });
  }
});

// Process YouTube or SoundCloud link
app.post('/api/process-link', async (req, res) => {
  try {
    const { url, type } = req.body;

    if (!url || !type) {
      console.error('Missing URL or type');
      return res.status(400).json({ error: 'URL and type are required' });
    }

    console.log(`Processing ${type} link: ${url}`);
    const sessionId = Date.now().toString();

    res.json({ success: true, sessionId });

    // Download and process in background
    (async () => {
      let filePath = null;
      let mixtapeName = 'Mixtape';
      try {
        let result;
        if (type === 'youtube') {
          console.log(`Attempting to download YouTube: ${url}`);
          result = await audioProcessor.downloadYouTube(url);
        } else if (type === 'soundcloud') {
          console.log(`Attempting to download SoundCloud: ${url}`);
          result = await audioProcessor.downloadSoundCloud(url);
        } else if (type === 'mixcloud') {
          console.log(`Attempting to download Mixcloud: ${url}`);
          result = await audioProcessor.downloadMixcloud(url);
        } else {
          throw new Error('Invalid source type');
        }
        
        if (!result || !result.filePath) {
          throw new Error('Failed to download audio - no file path returned');
        }
        
        filePath = result.filePath;
        mixtapeName = result.title || mixtapeName;
        mixtapeNames.set(sessionId, mixtapeName);
        
        console.log(`Successfully downloaded: ${mixtapeName}`);
        await processAudioFileStreaming(filePath, sessionId, mixtapeName);
      } catch (error) {
        console.error(`Download/Processing error (${type}):`, error.message);
        console.error('Full error:', error.stack);
        
        // Send detailed error message to client
        let userFriendlyError = error.message;
        
        // Add helpful context based on the error
        if (error.message.includes('yt-dlp') || error.message.includes('youtube-dl')) {
          userFriendlyError += ' Please ensure yt-dlp is installed and updated: brew install yt-dlp';
        } else if (error.message.includes('FFmpeg') || error.message.includes('ffmpeg')) {
          userFriendlyError += ' Please ensure FFmpeg is installed: brew install ffmpeg';
        }
        
        if (activeSessions.has(sessionId)) {
          const clients = activeSessions.get(sessionId);
          clients.forEach(client => {
            try {
              client.write(`data: ${JSON.stringify({ 
                type: 'error', 
                error: userFriendlyError,
                details: {
                  source: type,
                  url: url,
                  timestamp: new Date().toISOString()
                }
              })}\n\n`);
            } catch (err) {}
          });
        }
        if (filePath && fs.existsSync(filePath)) {
          try {
            fs.unlinkSync(filePath);
          } catch (cleanupError) {
            console.error('Error cleaning up downloaded file:', cleanupError.message);
          }
        }
      }
    })();
  } catch (error) {
    console.error('Error processing link:', error);
    res.status(500).json({ error: error.message });
  }
});

app.get('/api/stream/:sessionId', (req, res) => {
  const { sessionId } = req.params;

  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');

  if (!activeSessions.has(sessionId)) {
    activeSessions.set(sessionId, []);
  }
  activeSessions.get(sessionId).push(res);

  console.log(`Client connected to session ${sessionId}`);


  req.on('close', () => {
    const clients = activeSessions.get(sessionId);
    if (clients) {
      const index = clients.indexOf(res);
      if (index !== -1) {
        clients.splice(index, 1);
      }
      if (clients.length === 0) {
        activeSessions.delete(sessionId);
      }
    }
  });
});

function calculateOptimalInterval(duration) {
  if (duration < 600) return 60;
  if (duration < 1800) return 90;
  if (duration < 3600) return 120;
  return 150;
}

async function processAudioFileStreaming(filePath, sessionId, mixtapeName = 'Mixtape') {
  const sendUpdate = (data) => {
    const clients = activeSessions.get(sessionId);
    if (clients) {
      clients.forEach(client => {
        client.write(`data: ${JSON.stringify(data)}\n\n`);
      });
    }
  };

  try {
    const duration = await audioProcessor.getAudioDuration(filePath);
    const detections = [];
    const sentSongs = new Set(); // Track songs we've already sent to avoid duplicates
    let totalSamplesProcessed = 0;

    sendUpdate({ type: 'init', duration, pass: 1, mixtapeName });

    const interval = calculateOptimalInterval(duration);
    sendUpdate({ type: 'pass', pass: 1, description: `Quick overview - sampling every ${Math.round(interval/60)} minutes` });
    
    const pass1Samples = [];
    for (let time = 0; time < duration; time += interval) {
      pass1Samples.push({ time, duration: 30, pass: 1 });
    }

    for (let i = 0; i < pass1Samples.length; i += PARALLEL_BATCH_SIZE) {
      const batch = pass1Samples.slice(i, i + PARALLEL_BATCH_SIZE);
      
      // Send progress updates for batch
      batch.forEach((sample, batchIdx) => {
        sendUpdate({
          type: 'progress',
          pass: 1,
          current: i + batchIdx + 1,
          total: pass1Samples.length,
          status: 'processing',
          timestamp: formatTimestamp(sample.time)
        });
      });

      // Process batch in parallel
      const results = await Promise.allSettled(
        batch.map((sample, batchIdx) => 
          processSample(
            filePath, 
            sample.time, 
            sample.duration, 
            sendUpdate, 
            { current: i + batchIdx + 1, total: pass1Samples.length, pass: 1 }
          )
        )
      );
      
      // Collect results
      results.forEach((result, batchIdx) => {
        totalSamplesProcessed++;
        
        if (result.status === 'fulfilled' && result.value && (result.value.confidence || 0) >= MIN_CONFIDENCE_THRESHOLD) {
          const sample = batch[batchIdx];
          detections.push({
            ...result.value,
            timestamp: sample.time,
            pass: 1,
            verified: false
          });
          
          // Only send song event if we haven't sent this song before
          const songKey = normalizeTrackInfo(result.value.artist, result.value.title);
          if (!sentSongs.has(songKey)) {
            sentSongs.add(songKey);
            sendUpdate({
              type: 'song',
              song: { ...result.value, timestamp: formatTimestamp(sample.time), pass: 1 }
            });
          }
        }
      });
    }

    sendUpdate({ type: 'pass', pass: 2, description: 'Identifying undetected regions with temporal analysis' });
    
    const gaps = identifyGaps(detections, duration);
    const inferredTracks = inferMissedTracks(detections, duration);

    const pass2Samples = [];
    
    inferredTracks.forEach(inferred => {
      pass2Samples.push({
        time: inferred.time,
        duration: inferred.duration,
        pass: 2,
        priority: 'high',
        reason: inferred.reason
      });
    });
    
    gaps.forEach(gap => {
      if (gap.duration >= 180 && gap.end > gap.start + 30) {
        for (let time = gap.start + 20; time < gap.end - 30 && time < duration - 30; time += 20) {
          const tooCloseToInferred = inferredTracks.some(inf => Math.abs(inf.time - time) < 30);
          if (!tooCloseToInferred) {
            pass2Samples.push({ time, duration: 30, pass: 2, gapSize: gap.duration });
          }
        }
      }
    });

    for (let i = 0; i < pass2Samples.length; i += PARALLEL_BATCH_SIZE) {
      const batch = pass2Samples.slice(i, i + PARALLEL_BATCH_SIZE);
      
      // Send progress updates for batch
      batch.forEach((sample, batchIdx) => {
        sendUpdate({
          type: 'progress',
          pass: 2,
          current: i + batchIdx + 1,
          total: pass2Samples.length,
          status: 'processing',
          timestamp: formatTimestamp(sample.time)
        });
      });

      // Process batch in parallel
      const results = await Promise.allSettled(
        batch.map((sample, batchIdx) =>
          processSample(
            filePath, 
            sample.time, 
            sample.duration, 
            sendUpdate, 
            { current: i + batchIdx + 1, total: pass2Samples.length, pass: 2 }
          )
        )
      );
      
      // Collect results
      results.forEach((result, batchIdx) => {
        totalSamplesProcessed++;
        
        if (result.status === 'fulfilled' && result.value && (result.value.confidence || 0) >= MIN_CONFIDENCE_THRESHOLD) {
          const sample = batch[batchIdx];
          detections.push({
            ...result.value,
            timestamp: sample.time,
            pass: 2,
            verified: false
          });
          
          // Only send song event if we haven't sent this song before
          const songKey = normalizeTrackInfo(result.value.artist, result.value.title);
          if (!sentSongs.has(songKey)) {
            sentSongs.add(songKey);
            sendUpdate({
              type: 'song',
              song: { ...result.value, timestamp: formatTimestamp(sample.time), pass: 2 }
            });
          }
        }
      });
    }

    sendUpdate({ type: 'pass', pass: 3, description: 'Verifying uncertain identifications' });
    
    const uncertainDetections = detections.filter(d => 
      (d.confidence && d.confidence < 0.7) || d.pass === 2
    );

    for (let i = 0; i < uncertainDetections.length; i++) {
      const detection = uncertainDetections[i];
      totalSamplesProcessed++;
      
      const verifyTime = detection.timestamp + 15; // Sample 15s later
      if (verifyTime < duration - 30) {
        sendUpdate({
          type: 'progress',
          pass: 3,
          current: i + 1,
          total: uncertainDetections.length,
          status: 'processing',
          timestamp: formatTimestamp(verifyTime)
        });

        const result = await processSample(
          filePath, 
          verifyTime, 
          30, 
          sendUpdate, 
          { current: i + 1, total: uncertainDetections.length, pass: 3 }
        );
        
        if (result && isSameSong(result, detection)) {
          detection.verified = true;
          detection.confidence = Math.min((detection.confidence || 0.5) + 0.3, 1.0);
        }
      }
    }

    sendUpdate({ type: 'pass', pass: 4, description: 'Analyzing and validating tracks with context' });
    
    const validatedTracks = smartDeduplication(detections, duration);
    const finalTracks = validateTracks(validatedTracks);

    const cacheStats = fingerprinter.getCacheStats();
    const learningStats = fingerprinter.getLearningStats();
    console.log(`Cache: ${cacheStats.hits} hits, ${cacheStats.misses} misses (${cacheStats.hitRate})`);
    console.log('Service Reliability:', learningStats.serviceReliability);
    

    sendUpdate({
      type: 'complete',
      totalSongs: finalTracks.length,
      totalSamples: totalSamplesProcessed,
      passes: 3,
      stats: {
        cacheHitRate: cacheStats.hitRate,
        totalDetections: detections.length,
        finalTracks: finalTracks.length
      }
    });

    // Send final track list with confidence and warnings
    finalTracks.forEach(track => {
      sendUpdate({
        type: 'final-track',
        track: {
          ...track,
          timestamp: formatTimestamp(track.startTime),
          endTime: track.endTime ? formatTimestamp(track.endTime) : null
        }
      });
    });

    // Clean up uploaded file
    if (fs.existsSync(filePath)) {
      try {
        fs.unlinkSync(filePath);
      } catch (cleanupError) {
        console.error('Error cleaning up uploaded file:', cleanupError.message);
      }
    }

    setTimeout(() => {
      const clients = activeSessions.get(sessionId);
      if (clients) {
        clients.forEach(client => {
        try {
          client.end();
        } catch (err) {}
        });
        activeSessions.delete(sessionId);
      }
    }, 1000);

  } catch (error) {
    console.error('Error in processAudioFileStreaming:', error);
    
    const clients = activeSessions.get(sessionId);
    if (clients) {
      clients.forEach(client => {
        try {
          client.write(`data: ${JSON.stringify({ type: 'error', error: error.message })}\n\n`);
        } catch (err) {}
      });
    }
    

    if (fs.existsSync(filePath)) {
      try {
        fs.unlinkSync(filePath);
      } catch (cleanupError) {
        console.error('Error cleaning up file after error:', cleanupError.message);
      }
    }
  }
}

async function processSample(filePath, startTime, duration, sendUpdate, segmentInfo, options = {}) {
  let chunkPath = null;
  try {
    if (sendUpdate && segmentInfo) {
      sendUpdate({
        type: 'step',
        step: 'segmenting',
        timestamp: formatTimestamp(startTime),
        segment: segmentInfo.current,
        totalSegments: segmentInfo.total,
        pass: segmentInfo.pass
      });
    }
    
    // Enable noise cancellation for all passes
    const useEnhanced = true;
    const enhanceOptions = {
      removeNoise: true, // Always apply noise reduction
      boost: options.boost || (segmentInfo.pass >= 3 ? 1.3 : 1.0),
      aggressiveNoise: segmentInfo.pass >= 3 // More aggressive for verification pass
    };
    
    if (useEnhanced) {
      chunkPath = await audioProcessor.extractChunkEnhanced(filePath, startTime, duration, enhanceOptions);
    } else {
      chunkPath = await audioProcessor.extractChunk(filePath, startTime, duration);
    }
    
    if (sendUpdate && segmentInfo) {
      sendUpdate({
        type: 'step',
        step: 'fingerprinting',
        timestamp: formatTimestamp(startTime),
        segment: segmentInfo.current,
        totalSegments: segmentInfo.total,
        pass: segmentInfo.pass
      });
    }
    
    let result = await fingerprinter.identifyWithConfidence(chunkPath, {
      timeout: 15000
    });
    
    if (result) {
      result = fingerprinter.calibrateConfidence(result);
      
      fingerprinter.recordIdentificationResult(
        result.service,
        result.confidence >= MIN_CONFIDENCE_THRESHOLD,
        result.confidence,
        { strategy: options.strategy || 'standard', genre: result.genre }
      );
      
      if (segmentInfo.pass === 3 && result.confidence < 0.65 && result.confidence >= MIN_CONFIDENCE_THRESHOLD) {
        result = await fingerprinter.verifyLowConfidence(chunkPath, result, audioProcessor);
      }
    }
    
    if (sendUpdate && segmentInfo) {
      sendUpdate({
        type: 'step',
        step: 'matching',
        timestamp: formatTimestamp(startTime),
        segment: segmentInfo.current,
        totalSegments: segmentInfo.total,
        pass: segmentInfo.pass,
        matched: !!result
      });
    }
    
    return result;
  } catch (error) {
    console.error(`Error processing sample at ${startTime}s:`, error.message);
    return null;
  } finally {
    if (chunkPath && fs.existsSync(chunkPath)) {
      try {
        fs.unlinkSync(chunkPath);
      } catch (cleanupError) {
        console.error('Error cleaning up chunk file:', cleanupError.message);
      }
    }
  }
}

function identifyGaps(detections, totalDuration) {
  if (detections.length === 0) {
    return [{ start: 0, end: Math.max(0, totalDuration - 30), duration: totalDuration }];
  }

  const sortedDetections = [...detections].sort((a, b) => a.timestamp - b.timestamp);
  const gaps = [];
  const minGapSize = 90;

  for (let i = 0; i < sortedDetections.length - 1; i++) {
    const current = sortedDetections[i];
    const next = sortedDetections[i + 1];
    const gapDuration = next.timestamp - current.timestamp;

    if (gapDuration >= minGapSize) {
      const gapStart = Math.min(current.timestamp + 30, totalDuration - 30);
      const gapEnd = Math.min(next.timestamp, totalDuration);
      
      if (gapEnd > gapStart + 30) {
        gaps.push({
          start: gapStart,
          end: gapEnd,
          duration: gapEnd - gapStart
        });
      }
    }
  }

  const lastDetection = sortedDetections[sortedDetections.length - 1];
  const remainingTime = totalDuration - lastDetection.timestamp;
  
  if (remainingTime >= minGapSize) {
    const gapStart = Math.min(lastDetection.timestamp + 30, totalDuration - 30);
    
    if (totalDuration > gapStart + 30) {
      gaps.push({
        start: gapStart,
        end: totalDuration,
        duration: totalDuration - gapStart
      });
    }
  }

  return gaps;
}

function inferMissedTracks(detections, totalDuration) {
  if (!detections || detections.length < 2) {
    return [];
  }
  
  const sorted = [...detections].sort((a, b) => a.timestamp - b.timestamp);
  const inferred = [];
  const avgTrackLength = 180;
  
  for (let i = 0; i < sorted.length - 1; i++) {
    const gap = sorted[i + 1].timestamp - sorted[i].timestamp;
    
    if (gap >= 240 && gap <= 900) {
      const probableTracks = Math.floor(gap / avgTrackLength);
      
      if (probableTracks >= 1 && probableTracks <= 3) {
        for (let j = 1; j <= probableTracks; j++) {
          const inferredTime = sorted[i].timestamp + (j * gap / (probableTracks + 1));
          
          const tooClose = sorted.some(d => Math.abs(d.timestamp - inferredTime) < 45);
          
          if (!tooClose && inferredTime > 0 && inferredTime < totalDuration - 30) {
            inferred.push({
              time: inferredTime,
              duration: 30,
              pass: 2,
              reason: 'gap-inference',
              priority: 'high',
              inferredTrackCount: probableTracks,
              gapSize: gap
            });
          }
        }
      }
    }
  }
  
  console.log(`Temporal analysis: inferred ${inferred.length} potential missed tracks`);
  return inferred;
}

function buildDetectionContext(detection, allDetections, index) {
  const context = {};
  const windowSize = 300;
  
  const nearby = allDetections.filter((d, idx) => 
    idx !== index && 
    Math.abs(d.timestamp - detection.timestamp) <= windowSize
  );
  

  if (nearby.some(d => d.artist && detection.artist && 
      normalizeTrackInfo(d.artist, '').includes(normalizeTrackInfo(detection.artist, '')))) {
    context.nearbyArtistMatch = true;
  }
  
  if (detection.album && nearby.some(d => d.album === detection.album)) {
    context.albumContinuity = true;
  }
  
  if (detection.genre) {
    const nearbyGenres = nearby.filter(d => d.genre).map(d => d.genre);
    if (nearbyGenres.filter(g => g === detection.genre).length >= 2) {
      context.genreConsistency = true;
    }
  }
  
  const repetitions = allDetections.filter(d => 
    d !== detection && 
    normalizeTrackInfo(d.artist, d.title) === normalizeTrackInfo(detection.artist, detection.title)
  );
  
  if (repetitions.length >= 2) {
    context.repetitionDetected = true;
  }
  
  if (detection.duration && detection.duration < 90) {
    context.suspiciouslyShort = true;
  }
  
  context.genre = detection.genre;
  
  return context;
}

function normalizeTrackInfo(artist, title) {
  const normalize = str => {
    if (!str) return '';
    return str
      .toLowerCase()
      .replace(/\(.*?\)/g, '')
      .replace(/\[.*?\]/g, '')
      .replace(/feat\.|ft\.|featuring/gi, '')
      .replace(/&/g, 'and')
      .replace(/\s+and\s+/g, ',')
      .replace(/[^a-z0-9,]/g, '')
      .replace(/,+/g, ',')
      .trim();
  };
  
  return `${normalize(artist)}|${normalize(title)}`;
}

function smartDeduplication(detections, totalDuration) {
  if (!detections || detections.length === 0) {
    return [];
  }

  const tracks = [];
  const grouped = new Map();

  detections.forEach(detection => {
    if (!detection.artist || !detection.title) return;
    
    const key = normalizeTrackInfo(detection.artist, detection.title);
    if (!grouped.has(key)) {
      grouped.set(key, []);
    }
    grouped.get(key).push(detection);
  });

  // Process each song group - show each unique song only once
  grouped.forEach((instances, songKey) => {
    instances.sort((a, b) => a.timestamp - b.timestamp);

    let bestInstance = instances[0];
    instances.forEach(instance => {
      if ((instance.confidence || 0.5) > (bestInstance.confidence || 0.5)) {
        bestInstance = instance;
      }
    });

    const firstDetection = instances[0].timestamp;
    const lastDetection = instances[instances.length - 1].timestamp;
    const detectionSpread = lastDetection - firstDetection;
    
    const estimatedDuration = detectionSpread > 0 
      ? Math.min(detectionSpread + 60, 600)
      : 180;


    const track = {
      artist: bestInstance.artist,
      title: bestInstance.title,
      service: bestInstance.service || bestInstance.serviceName,
      spotifyLink: bestInstance.spotifyLink,
      album: bestInstance.album,
      genre: bestInstance.genre,
      startTime: firstDetection,
      endTime: Math.min(firstDetection + estimatedDuration, totalDuration),
      duration: Math.min(estimatedDuration, totalDuration - firstDetection),
      confidence: bestInstance.confidence || 0.5,
      verified: bestInstance.verified,
      detections: instances.length,
      consensus: bestInstance.consensus,
      services: bestInstance.services,
      detectionSpread: detectionSpread
    };
    
    tracks.push(track);
  });
  
  const sortedTracks = tracks.sort((a, b) => a.startTime - b.startTime);
  
  const contextAdjustedTracks = sortedTracks.map((track, index) => {
    const context = buildDetectionContext(track, sortedTracks, index);
    return fingerprinter.adjustConfidenceByContext(track, context);
  });

  return contextAdjustedTracks;
}

function validateTracks(tracks) {
  return tracks
    .filter(track => (track.confidence || 0) >= MIN_CONFIDENCE_THRESHOLD)
    .map(track => {
      const warnings = [];
      const duration = track.endTime - track.startTime;

      if (duration < 120) {
        warnings.push('Suspiciously short track (<2 min)');
      } else if (duration > 600) {
        warnings.push('Unusually long track (>10 min)');
      }

      if (track.confidence < 0.5) {
        warnings.push('Low confidence - may be incorrect');
      }

      if (!track.verified && track.confidence < 0.7) {
        warnings.push('Unverified identification');
      }

      return {
        ...track,
        duration,
        warnings: warnings.length > 0 ? warnings : null
      };
    });
}

function isSameSong(result1, result2) {
  if (!result1 || !result2) return false;
  return normalizeTrackInfo(result1.artist, result1.title) === 
         normalizeTrackInfo(result2.artist, result2.title);
}

function formatTimestamp(seconds) {
  const mins = Math.floor(seconds / 60);
  const secs = Math.floor(seconds % 60);
  return `${mins}:${secs.toString().padStart(2, '0')}`;
}

app.post('/api/create-spotify-playlist', async (req, res) => {
  try {
    const { trackIds, playlistName, filter } = req.body;
    
    if (!trackIds || trackIds.length === 0) {
      return res.status(400).json({ error: 'No tracks provided' });
    }
    
    if (!process.env.SPOTIFY_CLIENT_ID || !process.env.SPOTIFY_CLIENT_SECRET) {
      return res.status(400).json({ 
        error: 'Spotify API credentials not configured. Please add SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET to your .env file.' 
      });
    }
    
    if (!SPOTIFY_USER_ID) {
      return res.status(400).json({ 
        error: 'Spotify User ID not configured. Please add SPOTIFY_USER_ID to your .env file.' 
      });
    }
    
    const token = await fingerprinter.getSpotifyToken();
    
    if (!token) {
      return res.status(500).json({ error: 'Failed to authenticate with Spotify' });
    }
    
    const createResponse = await axios.post(
      `https://api.spotify.com/v1/users/${SPOTIFY_USER_ID}/playlists`,
      {
        name: playlistName,
        description: `Created by MixtapeID (${filter} filter) - ${new Date().toLocaleDateString()}`,
        public: false
      },
      {
        headers: {
          'Authorization': `Bearer ${token}`,
          'Content-Type': 'application/json'
        }
      }
    );
    
    const playlistId = createResponse.data.id;
    const playlistUrl = createResponse.data.external_urls.spotify;
    
    const trackUris = trackIds.map(id => `spotify:track:${id}`);
    const chunks = [];
    for (let i = 0; i < trackUris.length; i += 100) {
      chunks.push(trackUris.slice(i, i + 100));
    }
    
    let addedTracks = 0;
    for (const chunk of chunks) {
      await axios.post(
        `https://api.spotify.com/v1/playlists/${playlistId}/tracks`,
        { uris: chunk },
        {
          headers: {
            'Authorization': `Bearer ${token}`,
            'Content-Type': 'application/json'
          }
        }
      );
      addedTracks += chunk.length;
    }
    
    res.json({
      success: true,
      playlistId,
      playlistUrl,
      addedTracks
    });
    
  } catch (error) {
    console.error('Error creating Spotify playlist:', error.response?.data || error.message);
    res.status(500).json({ 
      error: error.response?.data?.error?.message || error.message || 'Failed to create playlist' 
    });
  }
});

app.use((error, req, res, next) => {
  console.error('Server error:', error);
  res.status(500).json({ error: error.message || 'Internal server error' });
});

// Check for required dependencies
const { execSync } = require('child_process');

function checkDependency(command, name) {
  try {
    // Try using 'which' to find the command first
    execSync(`which ${command}`, { 
      stdio: 'pipe',
      shell: '/bin/zsh'
    });
    console.log(`✓ ${name} is installed`);
    return true;
  } catch (error) {
    console.error(`✗ ${name} is NOT installed`);
    return false;
  }
}

app.listen(PORT, () => {
  console.log(`\n🎵 MixtapeID server running on http://localhost:${PORT}\n`);
  
  console.log('Checking dependencies...');
  const ffmpegOk = checkDependency('ffmpeg', 'FFmpeg');
  const ytdlpOk = checkDependency('yt-dlp', 'yt-dlp');
  
  console.log('');
  if (!ffmpegOk) {
    console.log('⚠️  FFmpeg not found. Audio processing will not work.');
    console.log('   Install: brew install ffmpeg\n');
  }
  if (!ytdlpOk) {
    console.log('⚠️  yt-dlp not found. YouTube/Mixcloud downloads will not work.');
    console.log('   Install: brew install yt-dlp\n');
  }
  
  if (ffmpegOk && ytdlpOk) {
    console.log('✅ All dependencies are installed!\n');
  }
  
  console.log('Make sure API credentials are set in .env file');
  console.log('');
});