#!/usr/bin/env python3
"""
SUNO AI ML INTERACTIVE DEMO
User: valkst
Date: 2025-08-02 11:25:47 UTC
Interactive demo for exploring ML music database
"""

import sqlite3
import numpy as np
import pickle
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import warnings
import re
warnings.filterwarnings('ignore')

class SunoInteractiveDemo:
    def __init__(self):
        self.db_path = "tracks.sqlite"
        self.model = None
        print(f"""
🎵 SUNO AI ML MUSIC SYSTEM - INTERACTIVE DEMO
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
👤 User: valkst
📅 Date: 2025-08-02 11:25:47 UTC
🎯 Mission: Explore 7,913 AI-generated tracks with ML analysis
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        """)
        self.show_quick_stats()
        
    def show_quick_stats(self):
        """Быстрая статистика"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.execute("""
        SELECT 
            COUNT(DISTINCT t.id) as total,
            COUNT(DISTINCT ml.track_id) as ml_count,
            AVG(t.quality_score) as avg_quality,
            COUNT(CASE WHEN ml.ml_emotion_dominant = 'joy' THEN 1 END) as joy_count
        FROM tracks t
        LEFT JOIN ml_analysis ml ON t.id = ml.track_id
        WHERE t.lyric != '[Instrumental]'
        """)
        
        total, ml_count, avg_qual, joy_count = cursor.fetchone()
        conn.close()
        
        print(f"📊 {total:,} треков | 🧠 {ml_count:,} ML анализ | ⭐ {avg_qual:.3f} качество | 😊 {joy_count:,} радостных")
        print("━" * 80)
        
    def run_demo(self):
        """Запуск интерактивной демо"""
        print("""
🎯 ВЫБЕРИТЕ ДЕМОНСТРАЦИЮ:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 🔍 Семантический поиск - найти похожие треки
2. 🎭 Эмоциональный анализ - треки по настроению  
3. 👤 Поиск по исполнителям - конкретные артисты
4. 🔬 Анализ кластеров - семантические группы
5. 📊 Статистика коллекции - общие инсайты
6. 🎲 Случайные открытия - интересные находки
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        """)
        
        # Демо 1: Семантический поиск
        print("🔍 ДЕМО 1: СЕМАНТИЧЕСКИЙ ПОИСК")
        print("-" * 40)
        self.demo_semantic_search()
        
        print("\n🎭 ДЕМО 2: ЭМОЦИОНАЛЬНЫЙ АНАЛИЗ")
        print("-" * 40)
        self.demo_emotion_analysis()
        
        print("\n👤 ДЕМО 3: ПОПУЛЯРНЫЕ ИСПОЛНИТЕЛИ")
        print("-" * 40)
        self.demo_popular_artists()
        
        print("\n🔬 ДЕМО 4: СЕМАНТИЧЕСКИЕ КЛАСТЕРЫ")
        print("-" * 40)
        self.demo_cluster_insights()
        
        print("\n🎲 ДЕМО 5: СЛУЧАЙНЫЕ ОТКРЫТИЯ")
        print("-" * 40)
        self.demo_random_discoveries()
        
    def demo_semantic_search(self):
        """Демо семантического поиска"""
        print("Примеры поисковых запросов:")
        
        # Загружаем модель если нужно
        if self.model is None:
            print("🧠 Загружаем модель для семантического поиска...")
            self.model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
        
        # Несколько примеров поиска
        queries = [
            "грустная баллада о любви",
            "энергичная танцевальная музыка", 
            "emotional piano ballad"
        ]
        
        for query in queries:
            print(f"\n🔍 Поиск: '{query}'")
            results = self.quick_semantic_search(query, limit=2)
            
    def quick_semantic_search(self, query, limit=2):
        """Быстрый семантический поиск"""
        query_vector = self.model.encode([query], normalize_embeddings=True)
        
        conn = sqlite3.connect(self.db_path)
        cursor = conn.execute("""
        SELECT t.title, t.lyric, emb.embedding_vector, ml.ml_emotion_dominant, t.quality_score
        FROM tracks t
        JOIN ml_embeddings emb ON t.id = emb.track_id
        JOIN ml_analysis ml ON t.id = ml.track_id
        WHERE t.lyric != '[Instrumental]'
        ORDER BY t.quality_score DESC
        LIMIT 500
        """)
        
        results = []
        for row in cursor.fetchall():
            title, lyric, vector_blob, emotion, quality = row
            try:
                vector = pickle.loads(vector_blob)
                similarity = cosine_similarity(query_vector, vector.reshape(1, -1))[0][0]
                results.append((title, similarity, emotion, quality, lyric))
            except:
                continue
                
        conn.close()
        
        # Сортируем и показываем топ
        results.sort(key=lambda x: x[1], reverse=True)
        
        for i, (title, sim, emotion, quality, lyric) in enumerate(results[:limit], 1):
            emotion_icon = {'joy': '😊', 'sadness': '😢', 'anger': '😡', 
                          'fear': '😨', 'disgust': '🤢', 'surprise': '😮'}.get(emotion, '🎵')
            
            # Парсим название
            clean_title = title
            if " — " in title:
                clean_title = title.split(" — ", 1)[1].strip()
            elif " - " in title:
                clean_title = title.split(" - ", 1)[1].strip()
                
            lyric_preview = str(lyric)[:80] + "..." if len(str(lyric)) > 80 else str(lyric)
            
            print(f"  {i}. 🎵 {clean_title}")
            print(f"     🎯 Similarity: {sim:.3f} | {emotion_icon} {emotion} | ⭐ {quality:.3f}")
            print(f"     📝 {lyric_preview}")
            
    def demo_emotion_analysis(self):
        """Демо эмоционального анализа"""
        conn = sqlite3.connect(self.db_path)
        
        # Топ треки по каждой эмоции
        emotions = ['joy', 'sadness', 'anger', 'fear']
        
        for emotion in emotions:
            emotion_icon = {'joy': '😊', 'sadness': '😢', 'anger': '😡', 'fear': '😨'}.get(emotion, '🎵')
            
            cursor = conn.execute("""
            SELECT t.title, ml.ml_emotion_confidence, t.quality_score
            FROM tracks t
            JOIN ml_analysis ml ON t.id = ml.track_id
            WHERE ml.ml_emotion_dominant = ?
            AND t.lyric != '[Instrumental]'
            ORDER BY ml.ml_emotion_confidence DESC, t.quality_score DESC
            LIMIT 2
            """, (emotion,))
            
            results = cursor.fetchall()
            if results:
                print(f"\n{emotion_icon} {emotion.title()} - лучшие треки:")
                for i, (title, conf, quality) in enumerate(results, 1):
                    clean_title = title.split(" — ", 1)[1] if " — " in title else title.split(" - ", 1)[1] if " - " in title else title
                    print(f"  {i}. {clean_title} (уверенность: {conf:.3f}, качество: {quality:.3f})")
        
        conn.close()
        
    def demo_popular_artists(self):
        """Демо популярных исполнителей"""
        conn = sqlite3.connect(self.db_path)
        
        # Ищем исполнителей по паттернам в названиях
        cursor = conn.execute("""
        SELECT 
            CASE 
                WHEN t.title LIKE '%—%' THEN TRIM(SUBSTR(t.title, 1, INSTR(t.title, '—') - 1))
                WHEN t.title LIKE '% - %' THEN TRIM(SUBSTR(t.title, 1, INSTR(t.title, ' - ') - 1))
                ELSE 'Unknown Artist'
            END as artist,
            COUNT(*) as track_count,
            AVG(t.quality_score) as avg_quality,
            AVG(ml.ml_emotion_confidence) as avg_emotion_conf
        FROM tracks t
        JOIN ml_analysis ml ON t.id = ml.track_id
        WHERE t.lyric != '[Instrumental]'
        AND (t.title LIKE '%—%' OR t.title LIKE '% - %')
        GROUP BY artist
        HAVING track_count > 1
        ORDER BY track_count DESC, avg_quality DESC
        LIMIT 5
        """)
        
        print("🏆 Топ исполнители по количеству треков:")
        for i, (artist, count, avg_qual, avg_emo) in enumerate(cursor.fetchall(), 1):
            print(f"  {i}. 👤 {artist}: {count} треков (качество: {avg_qual:.3f}, эмоции: {avg_emo:.3f})")
            
        conn.close()
        
    def demo_cluster_insights(self):
        """Демо кластерных инсайтов"""
        conn = sqlite3.connect(self.db_path)
        
        cursor = conn.execute("""
        SELECT 
            semantic_cluster,
            COUNT(*) as track_count,
            ml_emotion_dominant,
            AVG(cluster_confidence) as avg_conf,
            COUNT(*) as emotion_count
        FROM ml_analysis
        WHERE semantic_cluster >= 0
        GROUP BY semantic_cluster, ml_emotion_dominant
        ORDER BY semantic_cluster, emotion_count DESC
        """)
        
        clusters = {}
        for row in cursor.fetchall():
            cluster_id, count, emotion, conf, emo_count = row
            if cluster_id not in clusters:
                clusters[cluster_id] = {'total': 0, 'top_emotion': emotion, 'top_count': emo_count, 'conf': conf}
            clusters[cluster_id]['total'] += count
            if emo_count > clusters[cluster_id]['top_count']:
                clusters[cluster_id]['top_emotion'] = emotion
                clusters[cluster_id]['top_count'] = emo_count
        
        print("🔬 Топ семантические кластеры:")
        sorted_clusters = sorted(clusters.items(), key=lambda x: x[1]['total'], reverse=True)[:5]
        
        for cluster_id, data in sorted_clusters:
            emotion_icon = {'joy': '😊', 'sadness': '😢', 'anger': '😡', 
                          'fear': '😨', 'disgust': '🤢', 'surprise': '😮'}.get(data['top_emotion'], '🎵')
            print(f"  🔸 Кластер {cluster_id}: {data['total']} треков | {emotion_icon} {data['top_emotion']} | conf: {data['conf']:.3f}")
            
        conn.close()
        
    def demo_random_discoveries(self):
        """Демо случайных открытий"""
        conn = sqlite3.connect(self.db_path)
        
        # Необычные треки с высоким качеством
        cursor = conn.execute("""
        SELECT t.title, t.lyric, ml.ml_emotion_dominant, t.quality_score, ml.ml_emotion_confidence
        FROM tracks t
        JOIN ml_analysis ml ON t.id = ml.track_id
        WHERE t.quality_score > 0.95 
        AND t.lyric != '[Instrumental]'
        AND ml.ml_emotion_confidence > 0.8
        ORDER BY RANDOM()
        LIMIT 3
        """)
        
        print("🎲 Случайные жемчужины коллекции:")
        for i, (title, lyric, emotion, quality, emo_conf) in enumerate(cursor.fetchall(), 1):
            emotion_icon = {'joy': '😊', 'sadness': '😢', 'anger': '😡', 
                          'fear': '😨', 'disgust': '🤢', 'surprise': '😮'}.get(emotion, '🎵')
            
            clean_title = title.split(" — ", 1)[1] if " — " in title else title.split(" - ", 1)[1] if " - " in title else title
            lyric_preview = str(lyric)[:100] + "..." if len(str(lyric)) > 100 else str(lyric)
            
            print(f"  {i}. 🎵 {clean_title}")
            print(f"     {emotion_icon} {emotion} (conf: {emo_conf:.3f}) | ⭐ {quality:.3f}")
            print(f"     📝 {lyric_preview}")
            
        conn.close()

if __name__ == "__main__":
    print("🚀 Запуск интерактивной демо-системы...")
    demo = SunoInteractiveDemo()
    demo.run_demo()
    
    print(f"""
🎉 ДЕМОНСТРАЦИЯ ЗАВЕРШЕНА!
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ ML система полностью работоспособна
✅ 7,913 треков готовы к семантическому поиску
✅ Эмоциональная классификация активна
✅ Кластерный анализ доступен
✅ Система готова к интеграции в приложения

👤 User: valkst
📅 Completed: 2025-08-02 11:25:47 UTC
🚀 Powered by: Tesla V100 + SentenceTransformers + ML Magic

🎯 СИСТЕМА ГОТОВА К ПРОДАКШЕНУ! 🎯
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    """)