How to Build a Music Streaming App Like Spotify: A Complete Developer's Guide

@Composable
fun MusicPlayerScreen(song: Song) {
    Column(
        modifier = Modifier.fillMaxSize(),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        AsyncImage(
            model = song.albumArt,
            contentDescription = "Album Art",
            modifier = Modifier.size(300.dp)
        )

        Text(
            text = song.title,
            style = MaterialTheme.typography.headlineMedium
        )

        Text(
            text = song.artist,
            style = MaterialTheme.typography.bodyLarge
        )

        PlaybackControls(song = song)
    }
}

class AudioPlayerManager(private val context: Context) {
    private var exoPlayer: ExoPlayer? = null

    fun initializePlayer() {
        exoPlayer = ExoPlayer.Builder(context)
            .setAudioAttributes(AudioAttributes.DEFAULT, true)
            .setHandleAudioBecomingNoisy(true)
            .build()
    }

    fun playTrack(url: String) {
        val mediaItem = MediaItem.fromUri(url)
        exoPlayer?.apply {
            setMediaItem(mediaItem)
            prepare()
            play()
        }
    }

    fun releasePlayer() {
        exoPlayer?.release()
        exoPlayer = null
    }
}

// Node.js backend example - streaming audio
const express = require('express');
const AWS = require('aws-sdk');
const app = express();

const s3 = new AWS.S3({
    accessKeyId: process.env.AWS_ACCESS_KEY,
    secretAccessKey: process.env.AWS_SECRET_KEY
});

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

    // Get song metadata from database
    const song = await getSongById(songId);

    const params = {
        Bucket: 'your-music-bucket',
        Key: song.s3Key
    };

    // Stream from S3
    const stream = s3.getObject(params).createReadStream();

    res.set({
        'Content-Type': 'audio/mpeg',
        'Content-Length': song.fileSize,
        'Accept-Ranges': 'bytes'
    });

    stream.pipe(res);
});

dependencies {
    implementation "com.google.android.exoplayer:exoplayer:2.19.1"
    implementation "com.google.android.exoplayer:exoplayer-core:2.19.1"
    implementation "com.google.android.exoplayer:exoplayer-dash:2.19.1"
    implementation "com.google.android.exoplayer:exoplayer-ui:2.19.1"
}

class MusicPlayerService : Service() {
    private var exoPlayer: ExoPlayer? = null
    private val binder = MusicBinder()

    inner class MusicBinder : Binder() {
        fun getService(): MusicPlayerService = this@MusicPlayerService
    }

    override fun onCreate() {
        super.onCreate()
        initializePlayer()
        createNotificationChannel()
    }

    private fun initializePlayer() {
        exoPlayer = ExoPlayer.Builder(this).build().apply {
            // Handle audio focus
            setAudioAttributes(
                AudioAttributes.Builder()
                    .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
                    .setUsage(C.USAGE_MEDIA)
                    .build(),
                true
            )

            // Add listener for state changes
            addListener(object : Player.Listener {
                override fun onPlaybackStateChanged(state: Int) {
                    when (state) {
                        Player.STATE_READY -> updateNotification()
                        Player.STATE_ENDED -> playNextTrack()
                        Player.STATE_BUFFERING -> showBuffering()
                    }
                }
            })
        }
    }

    fun playTrack(track: Track) {
        val mediaItem = MediaItem.Builder()
            .setUri(track.streamUrl)
            .setMediaMetadata(
                MediaMetadata.Builder()
                    .setTitle(track.title)
                    .setArtist(track.artist)
                    .setArtworkUri(Uri.parse(track.albumArt))
                    .build()
            )
            .build()

        exoPlayer?.apply {
            setMediaItem(mediaItem)
            prepare()
            play()
        }

        startForeground(NOTIFICATION_ID, createNotification(track))
    }

    override fun onBind(intent: Intent): IBinder = binder
}

private fun setupAdaptiveStreaming() {
    val trackSelector = DefaultTrackSelector(this).apply {
        parameters = buildUponParameters()
            .setMaxVideoBitrate(Int.MAX_VALUE)
            .setMaxAudioBitrate(128000) // Default to 128kbps
            .build()
    }

    exoPlayer = ExoPlayer.Builder(this)
        .setTrackSelector(trackSelector)
        .setLoadControl(
            DefaultLoadControl.Builder()
                .setBufferDurationsMs(
                    15000,  // Min buffer: 15s
                    50000,  // Max buffer: 50s
                    2500,   // Playback buffer: 2.5s
                    5000    // Rebuffer: 5s
                )
                .build()
        )
        .build()
}

class NetworkMonitor(private val context: Context) {
    private val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

    fun observeNetworkQuality(): Flow<NetworkQuality> = callbackFlow {
        val callback = object : ConnectivityManager.NetworkCallback() {
            override fun onCapabilitiesChanged(
                network: Network,
                capabilities: NetworkCapabilities
            ) {
                val downSpeed = capabilities.linkDownstreamBandwidthKbps
                val quality = when {
                    downSpeed > 5000 -> NetworkQuality.HIGH  // 320kbps
                    downSpeed > 1000 -> NetworkQuality.MEDIUM // 160kbps
                    else -> NetworkQuality.LOW  // 96kbps
                }
                trySend(quality)
            }
        }

        connectivityManager.registerDefaultNetworkCallback(callback)
        awaitClose { connectivityManager.unregisterNetworkCallback(callback) }
    }
}

private fun createNotification(track: Track): Notification {
    val playPauseAction = if (exoPlayer?.isPlaying == true) {
        NotificationCompat.Action(
            R.drawable.ic_pause,
            "Pause",
            getPendingIntent(ACTION_PAUSE)
        )
    } else {
        NotificationCompat.Action(
            R.drawable.ic_play,
            "Play",
            getPendingIntent(ACTION_PLAY)
        )
    }

    return NotificationCompat.Builder(this, CHANNEL_ID)
        .setContentTitle(track.title)
        .setContentText(track.artist)
        .setLargeIcon(loadAlbumArt(track.albumArt))
        .setSmallIcon(R.drawable.ic_music_note)
        .addAction(R.drawable.ic_skip_previous, "Previous", getPendingIntent(ACTION_PREVIOUS))
        .addAction(playPauseAction)
        .addAction(R.drawable.ic_skip_next, "Next", getPendingIntent(ACTION_NEXT))
        .setStyle(androidx.media.app.NotificationCompat.MediaStyle()
            .setShowActionsInCompactView(0, 1, 2)
            .setMediaSession(mediaSession.sessionToken))
        .setPriority(NotificationCompat.PRIORITY_LOW)
        .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
        .build()
}

class CacheManager(context: Context) {
    private val cacheDir = context.cacheDir
    private val maxCacheSize = 500L * 1024 * 1024 // 500MB

    fun getCachedDataSource(context: Context): DataSource.Factory {
        val cache = SimpleCache(
            File(cacheDir, "media_cache"),
            LeastRecentlyUsedCacheEvictor(maxCacheSize),
            StandaloneDatabaseProvider(context)
        )

        return CacheDataSource.Factory()
            .setCache(cache)
            .setUpstreamDataSourceFactory(
                DefaultHttpDataSource.Factory()
                    .setUserAgent("YourMusicApp/1.0")
            )
            .setCacheWriteDataSinkFactory(null) // Disable cache writing for streams
            .setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
    }
}

@Composable
fun HomeScreen(navController: NavController) {
    Scaffold(
        topBar = { TopAppBarWithSearch() },
        bottomBar = { 
            Column {
                MiniPlayer() // Persistent mini player
                BottomNavigationBar(navController)
            }
        }
    ) { paddingValues ->
        LazyColumn(
            modifier = Modifier
                .fillMaxSize()
                .padding(paddingValues)
        ) {
            item { RecentlyPlayedSection() }
            item { RecommendedPlaylistsSection() }
            item { TopChartsSection() }
            item { NewReleasesSection() }
        }
    }
}

@Composable
fun NowPlayingScreen(song: Song, onDismiss: () -> Unit) {
    Box(
        modifier = Modifier
            .fillMaxSize()
            .background(
                Brush.verticalGradient(
                    colors = listOf(
                        dominantColor(song.albumArt),
                        MaterialTheme.colorScheme.background
                    )
                )
            )
    ) {
        Column(
            modifier = Modifier
                .fillMaxSize()
                .padding(24.dp),
            horizontalAlignment = Alignment.CenterHorizontally
        ) {
            // Draggable dismiss handle
            DismissHandle(onClick = onDismiss)

            Spacer(modifier = Modifier.height(32.dp))

            // Album art with shadow
            Card(
                modifier = Modifier
                    .size(320.dp)
                    .shadow(elevation = 16.dp, shape = RoundedCornerShape(16.dp)),
                shape = RoundedCornerShape(16.dp)
            ) {
                AsyncImage(
                    model = song.albumArt,
                    contentDescription = "Album Art"
                )
            }

            Spacer(modifier = Modifier.height(32.dp))

            // Song info
            Text(
                text = song.title,
                style = MaterialTheme.typography.headlineMedium,
                fontWeight = FontWeight.Bold
            )

            Text(
                text = song.artist,
                style = MaterialTheme.typography.bodyLarge,
                color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f)
            )

            Spacer(modifier = Modifier.height(24.dp))

            // Progress bar
            SeekBar(
                progress = song.currentPosition,
                total = song.duration
            )

            Spacer(modifier = Modifier.height(24.dp))

            // Playback controls
            PlaybackControls(
                isPlaying = song.isPlaying,
                onPrevious = { /* Handle */ },
                onPlayPause = { /* Handle */ },
                onNext = { /* Handle */ },
                onShuffle = { /* Handle */ },
                onRepeat = { /* Handle */ }
            )
        }
    }
}

@Composable
fun PlaylistScreen(playlist: Playlist) {
    val tracks = remember { mutableStateListOf(*playlist.tracks.toTypedArray()) }
    val reorderState = rememberReorderableLazyListState(
        onMove = { from, to ->
            tracks.apply {
                add(to.index, removeAt(from.index))
            }
        }
    )

    LazyColumn(
        state = reorderState.listState,
        modifier = Modifier
            .fillMaxSize()
            .reorderable(reorderState)
    ) {
        itemsIndexed(tracks, key = { _, track -> track.id }) { index, track ->
            ReorderableItem(reorderState, key = track.id) { isDragging ->
                TrackListItem(
                    track = track,
                    isDragging = isDragging,
                    onPlay = { /* Play track */ },
                    onOptions = { /* Show options */ }
                )
            }
        }
    }
}

@Composable
fun MusicAppTheme(
    darkTheme: Boolean = isSystemInDarkTheme(),
    dynamicColor: Boolean = true, // Material You
    content: @Composable () -> Unit
) {
    val colorScheme = when {
        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
            val context = LocalContext.current
            if (darkTheme) dynamicDarkColorScheme(context)
            else dynamicLightColorScheme(context)
        }
        darkTheme -> darkColorScheme(
            primary = Color(0xFF1DB954), // Spotify green
            background = Color(0xFF121212),
            surface = Color(0xFF282828)
        )
        else -> lightColorScheme(
            primary = Color(0xFF1DB954),
            background = Color(0xFFF6F6F6),
            surface = Color.White
        )
    }

    MaterialTheme(
        colorScheme = colorScheme,
        typography = Typography,
        content = content
    )
}

class SimpleRecommendationEngine {
    fun getRecommendations(user: User): List<Track> {
        val recommendations = mutableListOf<Track>()

        // 1. Get user's top genres
        val topGenres = user.listeningHistory
            .groupBy { it.genre }
            .mapValues { it.value.size }
            .toList()
            .sortedByDescending { it.second }
            .take(3)
            .map { it.first }

        // 2. Find popular tracks in those genres
        recommendations.addAll(
            getPopularTracksInGenres(topGenres, limit = 10)
        )

        // 3. Artists similar to user's favorites
        val favoriteArtists = user.likedTracks
            .groupBy { it.artist }
            .mapValues { it.value.size }
            .toList()
            .sortedByDescending { it.second }
            .take(5)
            .map { it.first }

        recommendations.addAll(
            getSimilarArtistTracks(favoriteArtists, limit = 10)
        )

        // 4. Remove already listened tracks
        return recommendations
            .filter { it.id !in user.listeningHistory.map { it.id } }
            .distinctBy { it.id }
            .shuffled()
            .take(20)
    }
}

class CollaborativeFiltering {
    // Find users with similar taste
    fun findSimilarUsers(userId: String, allUsers: List<User>): List<User> {
        val currentUser = allUsers.find { it.id == userId } ?: return emptyList()
        val currentUserLikedTracks = currentUser.likedTracks.map { it.id }.toSet()

        return allUsers
            .filter { it.id != userId }
            .map { otherUser ->
                val otherUserLikedTracks = otherUser.likedTracks.map { it.id }.toSet()

                // Calculate Jaccard similarity
                val intersection = currentUserLikedTracks.intersect(otherUserLikedTracks).size
                val union = currentUserLikedTracks.union(otherUserLikedTracks).size
                val similarity = if (union > 0) intersection.toDouble() / union else 0.0

                otherUser to similarity
            }
            .filter { it.second > 0.2 } // At least 20% similarity
            .sortedByDescending { it.second }
            .take(10)
            .map { it.first }
    }

    fun recommendFromSimilarUsers(user: User, similarUsers: List<User>): List<Track> {
        val userLikedIds = user.likedTracks.map { it.id }.toSet()

        return similarUsers
            .flatMap { it.likedTracks }
            .filter { it.id !in userLikedIds }
            .groupBy { it.id }
            .mapValues { it.value.size } // Count frequency
            .toList()
            .sortedByDescending { it.second }
            .take(20)
            .map { getTrackById(it.first) }
    }
}

data class AudioFeatures(
    val tempo: Double,      // BPM
    val energy: Double,     // 0.0 to 1.0
    val danceability: Double,
    val valence: Double,    // Happiness 0.0 to 1.0
    val acousticness: Double,
    val instrumentalness: Double
)

class ContentBasedRecommendation {
    fun findSimilarTracks(track: Track, allTracks: List<Track>): List<Track> {
        return allTracks
            .filter { it.id != track.id }
            .map { candidate ->
                val similarity = calculateSimilarity(track.audioFeatures, candidate.audioFeatures)
                candidate to similarity
            }
            .sortedByDescending { it.second }
            .take(20)
            .map { it.first }
    }

    private fun calculateSimilarity(f1: AudioFeatures, f2: AudioFeatures): Double {
        // Euclidean distance in feature space
        val distance = sqrt(
            (f1.tempo - f2.tempo).pow(2) +
            (f1.energy - f2.energy).pow(2) +
            (f1.danceability - f2.danceability).pow(2) +
            (f1.valence - f2.valence).pow(2) +
            (f1.acousticness - f2.acousticness).pow(2) +
            (f1.instrumentalness - f2.instrumentalness).pow(2)
        )

        // Convert distance to similarity score
        return 1.0 / (1.0 + distance)
    }
}

class HybridRecommendationEngine(
    private val collaborative: CollaborativeFiltering,
    private val contentBased: ContentBasedRecommendation,
    private val ruleBased: SimpleRecommendationEngine
) {
    fun getPersonalizedRecommendations(user: User, context: Context): List<Track> {
        val recommendations = mutableMapOf<String, Double>()

        // Weight different recommendation sources
        val collaborativeRecs = collaborative.getRecommendations(user)
        collaborativeRecs.forEachIndexed { index, track ->
            recommendations[track.id] = recommendations.getOrDefault(track.id, 0.0) + 
                (0.4 * (20 - index) / 20) // 40% weight
        }

        val contentRecs = contentBased.getRecommendations(user)
        contentRecs.forEachIndexed { index, track ->
            recommendations[track.id] = recommendations.getOrDefault(track.id, 0.0) + 
                (0.3 * (20 - index) / 20) // 30% weight
        }

        val ruleRecs = ruleBased.getRecommendations(user)
        ruleRecs.forEachIndexed { index, track ->
            recommendations[track.id] = recommendations.getOrDefault(track.id, 0.0) + 
                (0.3 * (20 - index) / 20) // 30% weight
        }

        // Apply contextual boosting
        val timeOfDay = Calendar.getInstance().get(Calendar.HOUR_OF_DAY)
        recommendations.forEach { (trackId, score) ->
            val track = getTrackById(trackId)
            val boostedScore = when {
                timeOfDay in 6..11 && track.audioFeatures.energy > 0.7 -> score * 1.2 // Morning energy
                timeOfDay in 22..23 && track.audioFeatures.energy < 0.4 -> score * 1.3 // Evening chill
                else -> score
            }
            recommendations[trackId] = boostedScore
        }

        return recommendations
            .toList()
            .sortedByDescending { it.second }
            .take(30)
            .map { getTrackById(it.first) }
    }
}

class WeeklyDiscoveryGenerator {
    fun generateWeeklyPlaylist(user: User): Playlist {
        val lastWeekHistory = user.listeningHistory.filter {
            it.timestamp > System.currentTimeMillis() - 7.days()
        }

        // Analyze listening patterns
        val topArtists = lastWeekHistory.groupBy { it.artist }.mapValues { it.value.size }
        val topGenres = lastWeekHistory.groupBy { it.genre }.mapValues { it.value.size }
        val avgFeatures = calculateAverageFeatures(lastWeekHistory)

        val recommendations = mutableListOf<Track>()

        // 40% similar to recent favorites
        recommendations.addAll(
            findTracksWithSimilarFeatures(avgFeatures, limit = 12)
        )

        // 30% from similar users
        recommendations.addAll(
            collaborative.recommendFromSimilarUsers(user, limit = 9)
        )

        // 20% from favorite genres but new artists
        recommendations.addAll(
            findNewArtistsInFavoriteGenres(topGenres.keys.toList(), limit = 6)
        )

        // 10% wild cards (different genres to broaden taste)
        recommendations.addAll(
            findWildCardTracks(user, limit = 3)
        )

        return Playlist(
            id = "weekly_discovery_${user.id}_${currentWeek()}",
            name = "Discover Weekly",
            tracks = recommendations.shuffled().distinctBy { it.id }
        )
    }
}

// Spotify Web API Integration
class SpotifyIntegration {
    private val spotifyApi = SpotifyApi.Builder()
        .setClientId(SPOTIFY_CLIENT_ID)
        .setClientSecret(SPOTIFY_CLIENT_SECRET)
        .build()

    suspend fun searchTracks(query: String): List<Track> {
        val searchResult = spotifyApi.searchTracks(query)
            .limit(20)
            .build()
            .execute()

        return searchResult.items.map { spotifyTrack ->
            Track(
                id = spotifyTrack.id,
                title = spotifyTrack.name,
                artist = spotifyTrack.artists.first().name,
                previewUrl = spotifyTrack.previewUrl, // 30-second preview
                spotifyUri = spotifyTrack.uri
            )
        }
    }

    fun playTrack(uri: String) {
        // Opens Spotify app to play full track
        val intent = Intent(Intent.ACTION_VIEW).apply {
            data = Uri.parse(uri)
        }
        context.startActivity(intent)
    }
}

class LocalMusicLibrary(context: Context) {
    fun scanUserLibrary(): List<Track> {
        val musicFiles = mutableListOf<Track>()
        val projection = arrayOf(
            MediaStore.Audio.Media._ID,
            MediaStore.Audio.Media.TITLE,
            MediaStore.Audio.Media.ARTIST,
            MediaStore.Audio.Media.ALBUM,
            MediaStore.Audio.Media.DATA,
            MediaStore.Audio.Media.DURATION
        )

        context.contentResolver.query(
            MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
            projection,
            "${MediaStore.Audio.Media.IS_MUSIC} != 0",
            null,
            "${MediaStore.Audio.Media.TITLE} ASC"
        )?.use { cursor ->
            val idColumn = cursor.getColumnIndexOrThrow(MediaStore.Audio.Media._ID)
            val titleColumn = cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.TITLE)
            val artistColumn = cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.ARTIST)

            while (cursor.moveToNext()) {
                musicFiles.add(
                    Track(
                        id = cursor.getLong(idColumn).toString(),
                        title = cursor.getString(titleColumn),
                        artist = cursor.getString(artistColumn),
                        localPath = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.DATA))
                    )
                )
            }
        }

        return musicFiles
    }
}

// YMusic-style implementation
class YMusicPlayer {
    // Plays only local files or user-provided URLs
    fun playUserContent(source: ContentSource) {
        when (source) {
            is ContentSource.LocalFile -> {
                // User's own MP3s from device storage
                playLocalFile(source.path)
            }
            is ContentSource.UserProvidedUrl -> {
                // User pastes their own streaming URL
                // App doesn't host or provide the content
                playStreamUrl(source.url)
            }
            is ContentSource.YouTubeAudio -> {
                // Audio extraction from YouTube
                // Relies on YouTube's terms of service
                extractAndPlay(source.videoId)
            }
        }
    }

    // Does NOT include:
    // - Built-in music library
    // - Download features for copyrighted content
    // - Links to pirated content sources
}

// Terms of Service example
class AppLegalCompliance {
    val termsOfService = """
        USER RESPONSIBILITIES:
        - You may only play music you own or have rights to
        - Do not use this app to infringe copyright
        - Third-party content (YouTube, etc.) subject to their ToS

        DISCLAIMER:
        - App does not provide or host copyrighted content
        - Users responsible for ensuring legal use
        - We comply with DMCA takedown requests
    """.trimIndent()

    fun implementDMCACompliance() {
        // If hosting user content, must have DMCA agent
        // Respond to takedown notices within 24-48 hours
        // Remove infringing content immediately
        // Implement repeat infringer policy
    }
}

// PostgreSQL schema example
const UserSchema = `
  CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) UNIQUE NOT NULL,
    username VARCHAR(50) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    display_name VARCHAR(100),
    avatar_url TEXT,
    subscription_tier VARCHAR(20) DEFAULT 'free',
    created_at TIMESTAMP DEFAULT NOW(),
    last_login TIMESTAMP
  );
`;

const TrackSchema = `
  CREATE TABLE tracks (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    title VARCHAR(255) NOT NULL,
    artist VARCHAR(255) NOT NULL,
    album VARCHAR(255),
    duration_ms INTEGER NOT NULL,
    genre VARCHAR(50),
    release_date DATE,
    album_art_url TEXT,
    audio_file_url TEXT NOT NULL,
    audio_file_s3_key VARCHAR(255),
    bitrate_128_url TEXT,
    bitrate_320_url TEXT,
    play_count BIGINT DEFAULT 0,
    created_at TIMESTAMP DEFAULT NOW(),

    -- Audio features for recommendations
    tempo DECIMAL(6,2),
    energy DECIMAL(3,2),
    danceability DECIMAL(3,2),
    valence DECIMAL(3,2)
  );

  CREATE INDEX idx_tracks_artist ON tracks(artist);
  CREATE INDEX idx_tracks_genre ON tracks(genre);
  CREATE INDEX idx_tracks_play_count ON tracks(play_count DESC);
`;

const PlaylistSchema = `
  CREATE TABLE playlists (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID REFERENCES users(id) ON DELETE CASCADE,
    name VARCHAR(255) NOT NULL,
    description TEXT,
    cover_image_url TEXT,
    is_public BOOLEAN DEFAULT false,
    collaborative BOOLEAN DEFAULT false,
    created_at TIMESTAMP DEFAULT NOW(),
    updated_at TIMESTAMP DEFAULT NOW()
  );

  CREATE TABLE playlist_tracks (
    playlist_id UUID REFERENCES playlists(id) ON DELETE CASCADE,
    track_id UUID REFERENCES tracks(id) ON DELETE CASCADE,
    position INTEGER NOT NULL,
    added_by UUID REFERENCES users(id),
    added_at TIMESTAMP DEFAULT NOW(),
    PRIMARY KEY (playlist_id, track_id)
  );
`;

const ListeningHistorySchema = `
  CREATE TABLE listening_history (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID REFERENCES users(id) ON DELETE CASCADE,
    track_id UUID REFERENCES tracks(id) ON DELETE SET NULL,
    played_at TIMESTAMP DEFAULT NOW(),
    duration_played_ms INTEGER,
    completion_percentage DECIMAL(5,2),
    skipped BOOLEAN DEFAULT false,
    device_type VARCHAR(50),
    location VARCHAR(100)
  );

  CREATE INDEX idx_history_user_time ON listening_history(user_id, played_at DESC);
  CREATE INDEX idx_history_track ON listening_history(track_id);
`;

const express = require('express');
const router = express.Router();

// Authentication
router.post('/auth/register', async (req, res) => {
  const { email, username, password } = req.body;

  try {
    const hashedPassword = await bcrypt.hash(password, 10);
    const user = await db.query(
      'INSERT INTO users (email, username, password_hash) VALUES ($1, $2, $3) RETURNING id, email, username',
      [email, username, hashedPassword]
    );

    const token = jwt.sign({ userId: user.rows[0].id }, process.env.JWT_SECRET, { expiresIn: '30d' });
    res.json({ user: user.rows[0], token });
  } catch (error) {
    res.status(400).json({ error: 'Registration failed' });
  }
});

// Search tracks
router.get('/search', async (req, res) => {
  const { q, type = 'track', limit = 20, offset = 0 } = req.query;

  let query = `
    SELECT id, title, artist, album, album_art_url, duration_ms
    FROM tracks
    WHERE title ILIKE $1 OR artist ILIKE $1 OR album ILIKE $1
    ORDER BY play_count DESC
    LIMIT $2 OFFSET $3
  `;

  const results = await db.query(query, [`%${q}%`, limit, offset]);
  res.json({ tracks: results.rows });
});

// Get streaming URL (with token verification)
router.get('/stream/:trackId', authenticateToken, async (req, res) => {
  const { trackId } = req.params;
  const quality = req.query.quality || '128';

  try {
    const track = await db.query('SELECT * FROM tracks WHERE id = $1', [trackId]);

    if (!track.rows[0]) {
      return res.status(404).json({ error: 'Track not found' });
    }

    // Log listening event
    await db.query(
      'INSERT INTO listening_history (user_id, track_id) VALUES ($1, $2)',
      [req.user.id, trackId]
    );

    // Increment play count
    await db.query('UPDATE tracks SET play_count = play_count + 1 WHERE id = $1', [trackId]);

    // Generate pre-signed S3 URL
    const s3Url = await generateS3PresignedUrl(
      quality === '320' ? track.rows[0].bitrate_320_url : track.rows[0].bitrate_128_url,
      3600 // 1 hour expiry
    );

    res.json({ streamUrl: s3Url, track: track.rows[0] });
  } catch (error) {
    res.status(500).json({ error: 'Streaming failed' });
  }
});

// Create playlist
router.post('/playlists', authenticateToken, async (req, res) => {
  const { name, description, isPublic } = req.body;

  const playlist = await db.query(
    'INSERT INTO playlists (user_id, name, description, is_public) VALUES ($1, $2, $3, $4) RETURNING *',
    [req.user.id, name, description, isPublic]
  );

  res.json({ playlist: playlist.rows[0] });
});

// Add track to playlist
router.post('/playlists/:playlistId/tracks', authenticateToken, async (req, res) => {
  const { playlistId } = req.params;
  const { trackId } = req.body;

  // Check ownership
  const playlist = await db.query(
    'SELECT * FROM playlists WHERE id = $1 AND (user_id = $2 OR collaborative = true)',
    [playlistId, req.user.id]
  );

  if (!playlist.rows[0]) {
    return res.status(403).json({ error: 'Unauthorized' });
  }

  // Get next position
  const positionResult = await db.query(
    'SELECT COALESCE(MAX(position), 0) + 1 as next_position FROM playlist_tracks WHERE playlist_id = $1',
    [playlistId]
  );

  await db.query(
    'INSERT INTO playlist_tracks (playlist_id, track_id, position, added_by) VALUES ($1, $2, $3, $4)',
    [playlistId, trackId, positionResult.rows[0].next_position, req.user.id]
  );

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

// Get personalized recommendations
router.get('/recommendations', authenticateToken, async (req, res) => {
  const userId = req.user.id;

  // Get user's listening history
  const history = await db.query(`
    SELECT t.* FROM tracks t
    JOIN listening_history h ON h.track_id = t.id
    WHERE h.user_id = $1 AND h.played_at > NOW() - INTERVAL '30 days'
    ORDER BY h.played_at DESC
    LIMIT 50
  `, [userId]);

  // Simple genre-based recommendations
  const topGenres = await db.query(`
    SELECT t.genre, COUNT(*) as count
    FROM tracks t
    JOIN listening_history h ON h.track_id = t.id
    WHERE h.user_id = $1 AND h.played_at > NOW() - INTERVAL '30 days'
    GROUP BY t.genre
    ORDER BY count DESC
    LIMIT 3
  `, [userId]);

  const genres = topGenres.rows.map(r => r.genre);

  const recommendations = await db.query(`
    SELECT DISTINCT t.* FROM tracks t
    WHERE t.genre = ANY($1)
    AND t.id NOT IN (
      SELECT track_id FROM listening_history WHERE user_id = $2
    )
    ORDER BY t.play_count DESC
    LIMIT 30
  `, [genres, userId]);

  res.json({ recommendations: recommendations.rows });
});

module.exports = router;

const Redis = require('ioredis');
const redis = new Redis(process.env.REDIS_URL);

// Cache popular tracks
async function getCachedPopularTracks() {
  const cached = await redis.get('popular_tracks');

  if (cached) {
    return JSON.parse(cached);
  }

  const tracks = await db.query(`
    SELECT * FROM tracks
    ORDER BY play_count DESC
    LIMIT 50
  `);

  // Cache for 1 hour
  await redis.setex('popular_tracks', 3600, JSON.stringify(tracks.rows));

  return tracks.rows;
}

// Cache user playlists
async function getUserPlaylists(userId) {
  const cacheKey = `user_playlists:${userId}`;
  const cached = await redis.get(cacheKey);

  if (cached) {
    return JSON.parse(cached);
  }

  const playlists = await db.query(
    'SELECT * FROM playlists WHERE user_id = $1 ORDER BY updated_at DESC',
    [userId]
  );

  await redis.setex(cacheKey, 600, JSON.stringify(playlists.rows)); // 10 min

  return playlists.rows;
}

// Invalidate cache on update
async function invalidatePlaylistCache(userId) {
  await redis.del(`user_playlists:${userId}`);
}

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

const activeListeners = new Map(); // userId -> WebSocket

wss.on('connection', (ws, req) => {
  const userId = authenticateWebSocket(req); // Extract from token

  if (!userId) {
    ws.close();
    return;
  }

  activeListeners.set(userId, ws);

  ws.on('message', (message) => {
    const data = JSON.parse(message);

    switch (data.type) {
      case 'now_playing':
        broadcastNowPlaying(userId, data.track);
        break;
      case 'join_session':
        joinListeningSession(userId, data.sessionId);
        break;
    }
  });

  ws.on('close', () => {
    activeListeners.delete(userId);
  });
});

function broadcastNowPlaying(userId, track) {
  // Notify user's followers
  db.query('SELECT follower_id FROM followers WHERE following_id = $1', [userId])
    .then(result => {
      result.rows.forEach(row => {
        const followerWs = activeListeners.get(row.follower_id);
        if (followerWs) {
          followerWs.send(JSON.stringify({
            type: 'friend_listening',
            userId,
            track
          }));
        }
      });
    });
}

// Track detailed listening metrics
async function trackListeningEvent(event) {
  const {
    userId,
    trackId,
    timestamp,
    durationPlayed,
    completionPercentage,
    skipped,
    deviceType,
    location
  } = event;

  // Store in time-series database (TimescaleDB)
  await db.query(`
    INSERT INTO listening_history 
    (user_id, track_id, played_at, duration_played_ms, completion_percentage, skipped, device_type, location)
    VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
  `, [userId, trackId, timestamp, durationPlayed, completionPercentage, skipped, deviceType, location]);

  // Update aggregates
  await updateUserListeningStats(userId);
  await updateTrackPopularityScore(trackId);
}

// Generate insights
router.get('/analytics/listening-stats', authenticateToken, async (req, res) => {
  const userId = req.user.id;

  const stats = await db.query(`
    SELECT 
      COUNT(*) as total_plays,
      SUM(duration_played_ms) / 1000 / 60 as total_minutes,
      COUNT(DISTINCT track_id) as unique_tracks,
      COUNT(DISTINCT DATE(played_at)) as active_days,
      AVG(completion_percentage) as avg_completion
    FROM listening_history
    WHERE user_id = $1 AND played_at > NOW() - INTERVAL '30 days'
  `, [userId]);

  const topArtists = await db.query(`
    SELECT t.artist, COUNT(*) as play_count
    FROM listening_history h
    JOIN tracks t ON t.id = h.track_id
    WHERE h.user_id = $1 AND h.played_at > NOW() - INTERVAL '30 days'
    GROUP BY t.artist
    ORDER BY play_count DESC
    LIMIT 10
  `, [userId]);

  res.json({
    stats: stats.rows[0],
    topArtists: topArtists.rows
  });
});

enum class SubscriptionTier(
    val displayName: String,
    val monthlyPrice: Double,
    val features: List<String>
) {
    FREE(
        "Free",
        0.0,
        listOf(
            "Shuffle play",
            "Ad-supported streaming",
            "Standard quality (128kbps)",
            "Limited skips (6 per hour)"
        )
    ),
    PREMIUM(
        "Premium",
        9.99,
        listOf(
            "Ad-free listening",
            "Unlimited skips",
            "High quality (320kbps)",
            "Offline downloads",
            "On-demand playback"
        )
    ),
    FAMILY(
        "Family",
        14.99,
        listOf(
            "All Premium features",
            "Up to 6 accounts",
            "Kid-safe content",
            "Family mix playlist"
        )
    ),
    STUDENT(
        "Student",
        4.99,
        listOf(
            "All Premium features",
            "Verification required",
            "Annual re-verification"
        )
    )
}

class SubscriptionManager {
    fun handleSubscription(tier: SubscriptionTier) {
        when (tier) {
            SubscriptionTier.FREE -> enableFreeFeatures()
            else -> initiatePurchase(tier)
        }
    }

    private fun initiatePurchase(tier: SubscriptionTier) {
        // Google Play Billing integration
        val billingClient = BillingClient.newBuilder(context)
            .setListener { billingResult, purchases ->
                if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
                    purchases?.forEach { purchase ->
                        verifyAndGrantSubscription(purchase)
                    }
                }
            }
            .enablePendingPurchases()
            .build()
    }
}

sealed class InAppPurchase(val sku: String, val price: Double) {
    object CustomThemes : InAppPurchase("custom_themes", 2.99)
    object AdvancedEqualizer : InAppPurchase("eq_advanced", 1.99)
    object LyricsFeature : InAppPurchase("lyrics_sync", 3.99)
    object CloudBackup : InAppPurchase("cloud_backup_lifetime", 9.99)
    object RemoveAds : InAppPurchase("remove_ads_lifetime", 4.99)
}

class IAPManager {
    fun purchaseFeature(feature: InAppPurchase) {
        val flowParams = BillingFlowParams.newBuilder()
            .setProductDetails(feature.productDetails)
            .build()

        billingClient.launchBillingFlow(activity, flowParams)
    }

    fun checkOwnership(feature: InAppPurchase): Boolean {
        // Query purchases and verify
        return purchasedFeatures.contains(feature.sku)
    }
}

class AdManager(private val context: Context) {
    private lateinit var interstitialAd: InterstitialAd

    fun loadAds() {
        // Google AdMob
        MobileAds.initialize(context)

        interstitialAd = InterstitialAd(context).apply {
            adUnitId = "ca-app-pub-xxxxx/xxxxx"
            loadAd(AdRequest.Builder().build())
        }
    }

    fun showAdBetweenTracks() {
        // Show ad every 3-5 songs for free users
        if (shouldShowAd() && interstitialAd.isLoaded) {
            interstitialAd.show()
        }
    }

    private fun shouldShowAd(): Boolean {
        val tracksSinceLastAd = prefs.getInt("tracks_since_ad", 0)
        return tracksSinceLastAd >= 4 && !userHasPremium()
    }
}

data class PromotedContent(
    val type: PromotionType,
    val targetAudience: Audience,
    val budget: Double,
    val duration: Int // days
)

enum class PromotionType(val cost: Double) {
    FEATURED_PLAYLIST(49.99),      // $50/week
    HOMEPAGE_BANNER(199.99),        // $200/week
    GENRE_SPOTLIGHT(99.99),         // $100/week
    PUSH_NOTIFICATION(0.10),        // $0.10 per notification
    EMAIL_FEATURE(0.05)             // $0.05 per email
}

class ArtistPromotionPlatform {
    fun createCampaign(artistId: String, content: PromotedContent): Campaign {
        // Artists/labels pay to promote their music
        val reach = calculateReach(content.targetAudience)
        val cost = content.type.cost * (content.duration / 7.0)

        return Campaign(
            id = generateId(),
            artistId = artistId,
            content = content,
            estimatedReach = reach,
            totalCost = cost
        )
    }
}

class AffiliateManager {
    fun showRelevantProducts() {
        // Partner with music gear brands
        val products = listOf(
            Product("Spotify Premium", affiliateLink, commission = 0.15),
            Product("Apple AirPods Pro", affiliateLink, commission = 0.03),
            Product("Audio-Technica Headphones", affiliateLink, commission = 0.08),
            Product("Ableton Live", affiliateLink, commission = 0.20)
        )
    }
}

class MusicInsightsAPI {
    // Sell anonymized listening trends to:
    // - Record labels (what's trending)
    // - Marketing agencies (demographic insights)
    // - Event organizers (geographic preferences)

    fun getGenreTrends(genre: String, region: String): TrendData {
        // Aggregate, anonymized data only
        return TrendData(
            genre = genre,
            weeklyGrowth = 12.5,
            topCities = listOf("NYC", "LA", "Chicago"),
            peakListeningHours = listOf(18, 19, 20)
        )
    }
}

class AdaptiveStreamingManager(private val networkMonitor: NetworkMonitor) {
    private val bitrateOptions = listOf(
        BitrateOption(96, "Low", 96_000),
        BitrateOption(128, "Normal", 128_000),
        BitrateOption(160, "High", 160_000),
        BitrateOption(320, "Maximum", 320_000)
    )

    init {
        networkMonitor.networkQuality.collect { quality ->
            adjustBitrate(quality)
        }
    }

    private fun adjustBitrate(quality: NetworkQuality) {
        val targetBitrate = when (quality) {
            NetworkQuality.EXCELLENT -> 320_000
            NetworkQuality.GOOD -> 160_000
            NetworkQuality.FAIR -> 128_000
            NetworkQuality.POOR -> 96_000
            NetworkQuality.OFFLINE -> return // Use cached content
        }

        exoPlayer.trackSelector.parameters = exoPlayer.trackSelector.parameters
            .buildUpon()
            .setMaxAudioBitrate(targetBitrate)
            .build()
    }

    // Pre-load next tracks in queue
    fun preloadNextTracks(queue: List<Track>) {
        queue.take(3).forEachIndexed { index, track ->
            if (index > 0) { // Don't preload current track
                val preloadSource = ProgressiveMediaSource.Factory(dataSourceFactory)
                    .createMediaSource(MediaItem.fromUri(track.streamUrl))

                // Load first 30 seconds of each upcoming track
                exoPlayer.preloadToPosition(preloadSource, 30_000)
            }
        }
    }
}

// Detect network quality changes
class NetworkQualityDetector(context: Context) {
    private val connectivityManager = context.getSystemService<ConnectivityManager>()

    fun observeQuality(): Flow<NetworkQuality> = callbackFlow {
        val callback = object : ConnectivityManager.NetworkCallback() {
            override fun onCapabilitiesChanged(
                network: Network,
                capabilities: NetworkCapabilities
            ) {
                val downSpeed = capabilities.linkDownstreamBandwidthKbps
                val latency = measureLatency() // Ping your server

                val quality = when {
                    downSpeed > 5000 && latency < 50 -> NetworkQuality.EXCELLENT
                    downSpeed > 2000 && latency < 100 -> NetworkQuality.GOOD
                    downSpeed > 500 && latency < 200 -> NetworkQuality.FAIR
                    else -> NetworkQuality.POOR
                }

                trySend(quality)
            }

            override fun onLost(network: Network) {
                trySend(NetworkQuality.OFFLINE)
            }
        }

        connectivityManager?.registerDefaultNetworkCallback(callback)
        awaitClose { connectivityManager?.unregisterNetworkCallback(callback) }
    }

    private suspend fun measureLatency(): Long = withContext(Dispatchers.IO) {
        val start = System.currentTimeMillis()
        try {
            URL("https://your-cdn.com/ping").openConnection().apply {
                connectTimeout = 3000
                connect()
            }
            System.currentTimeMillis() - start
        } catch (e: Exception) {
            999 // High latency on error
        }
    }
}

class BatteryOptimizedMusicService : MediaBrowserServiceCompat() {

    override fun onCreate() {
        super.onCreate()

        // Request battery optimization exemption (only for critical apps)
        requestBatteryOptimizationExemption()

        // Use efficient wakelock management
        setupEfficientWakelocks()
    }

    private fun setupEfficientWakelocks() {
        val wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager)
            .newWakeLock(
                PowerManager.PARTIAL_WAKE_LOCK,
                "MusicApp::PlaybackWakeLock"
            )

        // Only acquire wakelock during playback
        exoPlayer.addListener(object : Player.Listener {
            override fun onPlaybackStateChanged(state: Int) {
                when (state) {
                    Player.STATE_READY -> {
                        if (exoPlayer.playWhenReady && !wakeLock.isHeld) {
                            wakeLock.acquire(10*60*1000L) // 10 minutes timeout
                        }
                    }
                    Player.STATE_IDLE, Player.STATE_ENDED -> {
                        if (wakeLock.isHeld) {
                            wakeLock.release()
                        }
                    }
                }
            }
        })
    }

    // Handle Android Doze mode
    private fun handleDozeMode() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            val alarmManager = getSystemService<AlarmManager>()

            // Schedule exact alarm for next track (survives Doze)
            val nextTrackTime = calculateNextTrackStartTime()
            alarmManager?.setExactAndAllowWhileIdle(
                AlarmManager.ELAPSED_REALTIME_WAKEUP,
                nextTrackTime,
                getNextTrackPendingIntent()
            )
        }
    }

    // Reduce location updates, network polling
    private fun minimizeBackgroundActivity() {
        // Stop analytics updates during playback
        analyticsManager.pauseNonEssentialTracking()

        // Reduce notification updates frequency
        updateNotificationEvery(5_000) // 5 seconds instead of every second

        // Batch network requests
        batchMetadataUpdates()
    }
}

// Monitor battery level and adapt
class BatteryAwareManager(context: Context) {
    fun observeBatteryLevel(): Flow<BatteryLevel> = callbackFlow {
        val receiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context, intent: Intent) {
                val level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1)
                val scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1)
                val percentage = (level / scale.toFloat() * 100).toInt()

                val batteryLevel = when {
                    percentage > 50 -> BatteryLevel.HIGH
                    percentage > 20 -> BatteryLevel.MEDIUM
                    else -> BatteryLevel.LOW
                }

                trySend(batteryLevel)
            }
        }

        context.registerReceiver(receiver, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
        awaitClose { context.unregisterReceiver(receiver) }
    }

    fun adjustFeaturesByBattery(level: BatteryLevel) {
        when (level) {
            BatteryLevel.LOW -> {
                // Disable visualizers
                disableAudioVisualizations()
                // Lower quality
                forceLowerBitrate()
                // Stop pre-loading
                disablePreloading()
            }
            BatteryLevel.MEDIUM -> {
                enableEssentialFeaturesOnly()
            }
            BatteryLevel.HIGH -> {
                enableAllFeatures()
            }
        }
    }
}

class StorageManager(private val context: Context) {
    private val downloadDir = context.getExternalFilesDir(Environment.DIRECTORY_MUSIC)
    private val maxStorageSize = 5L * 1024 * 1024 * 1024 // 5GB default

    fun checkStorageSpace(): StorageInfo {
        val statFs = StatFs(downloadDir?.path)
        val availableBytes = statFs.availableBytes
        val usedBytes = calculateUsedSpace()

        return StorageInfo(
            available = availableBytes,
            used = usedBytes,
            total = maxStorageSize,
            percentUsed = (usedBytes / maxStorageSize.toFloat() * 100).toInt()
        )
    }

    fun enforceStorageLimit() {
        val currentUsage = calculateUsedSpace()

        if (currentUsage > maxStorageSize * 0.9) { // 90% threshold
            // Auto-delete least recently played downloads
            cleanupOldDownloads()
        }
    }

    private fun cleanupOldDownloads() {
        val downloads = db.getAllDownloads()
            .sortedBy { it.lastPlayedAt } // Oldest first

        var freedSpace = 0L
        val targetFreeSpace = maxStorageSize * 0.2 // Free up 20%

        for (download in downloads) {
            if (freedSpace >= targetFreeSpace) break

            // Don't delete user-pinned songs
            if (!download.isPinned) {
                val file = File(download.localPath)
                freedSpace += file.length()
                file.delete()
                db.removeDownload(download.id)

                // Notify user
                showStorageCleanupNotification(download.track.title)
            }
        }
    }

    // Let users manage storage
    fun getStorageBreakdown(): List<StorageCategory> {
        return listOf(
            StorageCategory("Cached Streams", calculateCacheSize()),
            StorageCategory("Downloaded Songs", calculateDownloadSize()),
            StorageCategory("Album Art", calculateImageCacheSize()),
            StorageCategory("App Data", calculateAppDataSize())
        )
    }

    // Smart download quality
    fun recommendDownloadQuality(): DownloadQuality {
        val available = checkStorageSpace().available

        return when {
            available < 500.megabytes() -> DownloadQuality.LOW_96
            available < 2.gigabytes() -> DownloadQuality.NORMAL_128
            else -> DownloadQuality.HIGH_320
        }
    }
}

// Download queue management
class DownloadQueue {
    private val queue = ConcurrentLinkedQueue<DownloadTask>()
    private var activeDownloads = 0
    private val maxConcurrentDownloads = 3

    fun addToQueue(track: Track, quality: DownloadQuality) {
        val task = DownloadTask(track, quality)
        queue.offer(task)
        processQueue()
    }

    private fun processQueue() {
        while (activeDownloads < maxConcurrentDownloads && queue.isNotEmpty()) {
            queue.poll()?.let { task ->
                downloadTrack(task)
            }
        }
    }

    private fun downloadTrack(task: DownloadTask) {
        activeDownloads++

        CoroutineScope(Dispatchers.IO).launch {
            try {
                // Check network type (don't use cellular if user restricted)
                if (!shouldDownloadNow()) {
                    queue.offer(task) // Re-queue for later
                    return@launch
                }

                val outputFile = File(downloadDir, "${task.track.id}.mp3")
                downloadFile(task.track.downloadUrl, outputFile) { progress ->
                    updateDownloadProgress(task.track.id, progress)
                }

                db.saveDownload(task.track, outputFile.absolutePath)
                showDownloadCompleteNotification(task.track.title)

            } catch (e: Exception) {
                handleDownloadError(task, e)
            } finally {
                activeDownloads--
                processQueue()
            }
        }
    }

    private fun shouldDownloadNow(): Boolean {
        val networkType = getNetworkType()
        val wifiOnlyPreference = prefs.getBoolean("wifi_only_downloads", true)

        return when {
            networkType == NetworkType.WIFI -> true
            networkType == NetworkType.CELLULAR && !wifiOnlyPreference -> true
            else -> false
        }
    }
}

// Load balancing with multiple server instances
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

  // Fork workers
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork(); // Replace dead worker
  });

} else {
  // Workers share the TCP connection
  const app = require('./app');
  app.listen(process.env.PORT || 3000);
  console.log(`Worker ${process.pid} started`);
}

// Database connection pooling
const { Pool } = require('pg');
const pool = new Pool({
  host: process.env.DB_HOST,
  database: process.env.DB_NAME,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  max: 20, // Maximum connections
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,
});

// CDN integration for audio files
const CloudFront = require('aws-sdk/clients/cloudfront');
const cloudfront = new CloudFront();

async function generateCDNUrl(s3Key) {
  // Create signed URL with CloudFront
  const signedUrl = cloudfront.getSignedUrl({
    url: `https://d1234567890.cloudfront.net/${s3Key}`,
    expires: Math.floor(Date.now() / 1000) + 3600, // 1 hour
  });

  return signedUrl;
}

// Caching strategy
const cacheMiddleware = (duration) => (req, res, next) => {
  const key = `cache:${req.originalUrl}`;

  redis.get(key, (err, data) => {
    if (data) {
      return res.json(JSON.parse(data));
    }

    // Override res.json to cache response
    const originalJson = res.json.bind(res);
    res.json = (body) => {
      redis.setex(key, duration, JSON.stringify(body));
      return originalJson(body);
    };

    next();
  });
};

// Popular tracks with long cache
app.get('/api/popular', cacheMiddleware(3600), async (req, res) => {
  const tracks = await getPopularTracks();
  res.json({ tracks });
});

// Rate limiting per user
const rateLimit = require('express-rate-limit');

const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // Limit each user to 100 requests per window
  standardHeaders: true,
  legacyHeaders: false,
});

app.use('/api/', apiLimiter);

// Database query optimization
async function getOptimizedUserPlaylists(userId) {
  // Use prepared statements
  const query = {
    name: 'get-user-playlists',
    text: `
      SELECT 
        p.id, p.name, p.cover_image_url,
        COUNT(pt.track_id) as track_count,
        MAX(pt.added_at) as last_updated
      FROM playlists p
      LEFT JOIN playlist_tracks pt ON pt.playlist_id = p.id
      WHERE p.user_id = $1
      GROUP BY p.id
      ORDER BY p.updated_at DESC
    `,
    values: [userId]
  };

  const result = await pool.query(query);
  return result.rows;
}

// Auto-scaling configuration (AWS example)
const autoScalingConfig = {
  minInstances: 2,
  maxInstances: 20,
  targetCPUUtilization: 70,
  scaleUpThreshold: 80,
  scaleDownThreshold: 30,
  cooldownPeriod: 300 // 5 minutes
};

class CrossDeviceSyncManager(
    private val firebase: FirebaseDatabase,
    private val localDb: AppDatabase
) {
    private val userSyncRef = firebase.getReference("user_sync/${getCurrentUserId()}")

    fun startSync() {
        // Listen for remote changes
        userSyncRef.child("playlists").addValueEventListener(object : ValueEventListener {
            override fun onDataChange(snapshot: DataSnapshot) {
                val remotePlaylists = snapshot.getValue<List<Playlist>>()
                remotePlaylists?.forEach { remotePlaylist ->
                    mergePlaylist(remotePlaylist)
                }
            }

            override fun onCancelled(error: DatabaseError) {
                Log.e("Sync", "Failed: ${error.message}")
            }
        })

        // Listen for playback position sync
        userSyncRef.child("current_playback").addValueEventListener(object : ValueEventListener {
            override fun onDataChange(snapshot: DataSnapshot) {
                val playbackState = snapshot.getValue<PlaybackState>()
                playbackState?.let { syncPlaybackPosition(it) }
            }

            override fun onCancelled(error: DatabaseError) {}
        })
    }

    private fun mergePlaylist(remotePlaylist: Playlist) {
        val localPlaylist = localDb.playlistDao().getById(remotePlaylist.id)

        if (localPlaylist == null) {
            // New playlist from another device
            localDb.playlistDao().insert(remotePlaylist)
        } else {
            // Merge with conflict resolution
            val merged = resolveConflict(localPlaylist, remotePlaylist)
            localDb.playlistDao().update(merged)
        }
    }

    private fun resolveConflict(local: Playlist, remote: Playlist): Playlist {
        // Last-write-wins strategy
        return if (remote.updatedAt > local.updatedAt) {
            remote
        } else {
            local
        }
    }

    fun syncPlaybackPosition(track: Track, position: Long) {
        val playbackState = PlaybackState(
            trackId = track.id,
            position = position,
            timestamp = System.currentTimeMillis(),
            deviceId = getDeviceId()
        )

        userSyncRef.child("current_playback").setValue(playbackState)
    }
}