vynl/backend/app/api/endpoints/profile.py

from fastapi import APIRouter, Depends
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.database import get_db
from app.core.security import get_current_user
from app.models.user import User
from app.models.playlist import Playlist
from app.models.track import Track

router = APIRouter(prefix="/profile", tags=["profile"])


def _determine_personality(
    genre_count: int,
    avg_energy: float,
    avg_valence: float,
    avg_acousticness: float,
    energy_variance: float,
    valence_variance: float,
) -> dict:
    """Assign a listening personality based on taste data."""

    # High variance in energy/valence = Mood Listener
    if energy_variance > 0.06 and valence_variance > 0.06:
        return {
            "label": "Mood Listener",
            "description": "Your music shifts with your emotions. You have playlists for every feeling and aren't afraid to go from euphoric highs to contemplative lows.",
            "icon": "drama",
        }

    # Many different genres = Genre Explorer
    if genre_count >= 8:
        return {
            "label": "Genre Explorer",
            "description": "You refuse to be put in a box. Your library is a world tour of sounds, spanning genres most listeners never discover.",
            "icon": "globe",
        }

    # High energy = Energy Seeker
    if avg_energy > 0.7:
        return {
            "label": "Energy Seeker",
            "description": "You crave intensity. Whether it's driving beats, soaring guitars, or thundering bass, your music keeps the adrenaline flowing.",
            "icon": "zap",
        }

    # Low energy + high acousticness = Chill Master
    if avg_energy < 0.4 and avg_acousticness > 0.5:
        return {
            "label": "Chill Master",
            "description": "You've mastered the art of the vibe. Acoustic textures and mellow grooves define your sonic world — your playlists are a warm blanket.",
            "icon": "cloud",
        }

    # Very consistent taste, low variance = Comfort Listener
    if energy_variance < 0.03 and valence_variance < 0.03:
        return {
            "label": "Comfort Listener",
            "description": "You know exactly what you like and you lean into it. Your taste is refined, consistent, and deeply personal.",
            "icon": "heart",
        }

    # Default: Catalog Diver
    return {
        "label": "Catalog Diver",
        "description": "You dig deeper than the singles. Album tracks, B-sides, and deep cuts are your territory — you appreciate the full artistic vision.",
        "icon": "layers",
    }


@router.get("/taste")
async def get_taste_profile(
    user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
):
    """Aggregate all user playlists/tracks into a full taste profile."""
    result = await db.execute(
        select(Playlist).where(Playlist.user_id == user.id)
    )
    playlists = list(result.scalars().all())

    all_tracks = []
    for p in playlists:
        result = await db.execute(select(Track).where(Track.playlist_id == p.id))
        all_tracks.extend(result.scalars().all())

    if not all_tracks:
        return {
            "genre_breakdown": [],
            "audio_features": {
                "energy": 0,
                "danceability": 0,
                "valence": 0,
                "acousticness": 0,
                "avg_tempo": 0,
            },
            "personality": {
                "label": "New Listener",
                "description": "Import some playlists to discover your listening personality!",
                "icon": "music",
            },
            "top_artists": [],
            "track_count": 0,
            "playlist_count": len(playlists),
        }

    # Genre breakdown
    genres_count: dict[str, int] = {}
    for t in all_tracks:
        if t.genres:
            for g in t.genres:
                genres_count[g] = genres_count.get(g, 0) + 1

    total_genre_mentions = sum(genres_count.values()) or 1
    top_genres = sorted(genres_count.items(), key=lambda x: x[1], reverse=True)[:10]
    genre_breakdown = [
        {"name": g, "percentage": round((c / total_genre_mentions) * 100, 1)}
        for g, c in top_genres
    ]

    # Audio features averages + variance
    energies = []
    danceabilities = []
    valences = []
    acousticnesses = []
    tempos = []

    for t in all_tracks:
        if t.energy is not None:
            energies.append(t.energy)
        if t.danceability is not None:
            danceabilities.append(t.danceability)
        if t.valence is not None:
            valences.append(t.valence)
        if t.acousticness is not None:
            acousticnesses.append(t.acousticness)
        if t.tempo is not None:
            tempos.append(t.tempo)

    def avg(lst: list[float]) -> float:
        return round(sum(lst) / len(lst), 3) if lst else 0

    def variance(lst: list[float]) -> float:
        if len(lst) < 2:
            return 0
        m = sum(lst) / len(lst)
        return sum((x - m) ** 2 for x in lst) / len(lst)

    avg_energy = avg(energies)
    avg_danceability = avg(danceabilities)
    avg_valence = avg(valences)
    avg_acousticness = avg(acousticnesses)
    avg_tempo = round(avg(tempos), 0)

    # Personality
    personality = _determine_personality(
        genre_count=len(genres_count),
        avg_energy=avg_energy,
        avg_valence=avg_valence,
        avg_acousticness=avg_acousticness,
        energy_variance=variance(energies),
        valence_variance=variance(valences),
    )

    # Top artists
    artist_count: dict[str, int] = {}
    for t in all_tracks:
        artist_count[t.artist] = artist_count.get(t.artist, 0) + 1
    top_artists_sorted = sorted(artist_count.items(), key=lambda x: x[1], reverse=True)[:8]

    # Find a representative genre for each top artist
    artist_genres: dict[str, str] = {}
    for t in all_tracks:
        if t.artist in dict(top_artists_sorted) and t.genres and t.artist not in artist_genres:
            artist_genres[t.artist] = t.genres[0]

    top_artists = [
        {
            "name": name,
            "track_count": count,
            "genre": artist_genres.get(name, ""),
        }
        for name, count in top_artists_sorted
    ]

    return {
        "genre_breakdown": genre_breakdown,
        "audio_features": {
            "energy": round(avg_energy * 100),
            "danceability": round(avg_danceability * 100),
            "valence": round(avg_valence * 100),
            "acousticness": round(avg_acousticness * 100),
            "avg_tempo": avg_tempo,
        },
        "personality": personality,
        "top_artists": top_artists,
        "track_count": len(all_tracks),
        "playlist_count": len(playlists),
    }