#!/usr/bin/env python3
"""
SUNO AI ML API - PRODUCTION READY
User: valkst
Date: 2025-08-02 11:30:32 UTC
Production-ready ML API for Suno AI music collection
"""

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

class SunoMLAPI:
    def __init__(self, db_path="tracks.sqlite"):
        self.db_path = db_path
        self.model = None
        self.stats = self._get_stats()
        
    def _get_stats(self):
        """Получение статистики системы"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.execute("""
        SELECT 
            COUNT(DISTINCT t.id) as total_tracks,
            COUNT(DISTINCT ml.track_id) as ml_tracks,
            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]'
        """)
        stats = cursor.fetchone()
        conn.close()
        return {
            'total_tracks': stats[0],
            'ml_tracks': stats[1],
            'coverage': stats[1] / stats[0] * 100,
            'avg_quality': stats[2],
            'joy_tracks': stats[3]
        }
    
    def _load_model(self):
        """Ленивая загрузка модели"""
        if self.model is None:
            self.model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
    
    def search(self, query, limit=10, min_quality=0.0):
        """Семантический поиск треков"""
        self._load_model()
        
        query_vector = self.model.encode([query], normalize_embeddings=True)
        
        conn = sqlite3.connect(self.db_path)
        cursor = conn.execute("""
        SELECT t.id, t.title, t.lyric, t.tags, emb.embedding_vector,
               ml.ml_emotion_dominant, ml.ml_emotion_confidence, 
               t.quality_score, ml.semantic_cluster, t.audio_url
        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]' AND t.quality_score >= ?
        ORDER BY t.quality_score DESC
        """, (min_quality,))
        
        results = []
        for row in cursor.fetchall():
            try:
                track_id, title, lyric, tags, vector_blob, emotion, emotion_conf, quality, cluster, audio_url = row
                vector = pickle.loads(vector_blob)
                similarity = cosine_similarity(query_vector, vector.reshape(1, -1))[0][0]
                
                results.append({
                    'id': track_id,
                    'title': title,
                    'similarity': float(similarity),
                    'emotion': emotion,
                    'emotion_confidence': float(emotion_conf),
                    'quality': float(quality),
                    'cluster': int(cluster),
                    'audio_url': audio_url,
                    'lyric_preview': str(lyric)[:200] + "..." if len(str(lyric)) > 200 else str(lyric)
                })
            except:
                continue
        
        conn.close()
        
        # Сортируем по similarity
        results.sort(key=lambda x: x['similarity'], reverse=True)
        return results[:limit]
    
    def filter_by_emotion(self, emotion, limit=10, min_confidence=0.5):
        """Фильтр по эмоции"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.execute("""
        SELECT t.id, t.title, t.lyric, ml.ml_emotion_confidence, 
               t.quality_score, t.audio_url
        FROM tracks t
        JOIN ml_analysis ml ON t.id = ml.track_id
        WHERE ml.ml_emotion_dominant = ? 
        AND ml.ml_emotion_confidence >= ?
        AND t.lyric != '[Instrumental]'
        ORDER BY ml.ml_emotion_confidence DESC, t.quality_score DESC
        LIMIT ?
        """, (emotion, min_confidence, limit))
        
        results = []
        for row in cursor.fetchall():
            track_id, title, lyric, conf, quality, audio_url = row
            results.append({
                'id': track_id,
                'title': title,
                'emotion_confidence': float(conf),
                'quality': float(quality),
                'audio_url': audio_url,
                'lyric_preview': str(lyric)[:200] + "..." if len(str(lyric)) > 200 else str(lyric)
            })
        
        conn.close()
        return results
    
    def get_track_info(self, track_id):
        """Полная информация о треке"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.execute("""
        SELECT t.*, ml.*, emb.vector_dimension
        FROM tracks t
        LEFT JOIN ml_analysis ml ON t.id = ml.track_id
        LEFT JOIN ml_embeddings emb ON t.id = emb.track_id
        WHERE t.id = ?
        """, (track_id,))
        
        row = cursor.fetchone()
        conn.close()
        
        if not row:
            return None
            
        # Формируем полную информацию
        columns = [desc[0] for desc in cursor.description]
        track_info = dict(zip(columns, row))
        
        return track_info
    
    def get_stats(self):
        """Статистика системы"""
        return {
            'system_stats': self.stats,
            'timestamp': datetime.now().isoformat(),
            'status': 'operational'
        }

def create_api_demo():
    """Демонстрация API"""
    api = SunoMLAPI()
    
    print("🚀 SUNO ML API - PRODUCTION READY")
    print("=" * 50)
    print(f"📊 Статистика: {api.stats}")
    print()
    
    # Демо поиска
    print("🔍 Демо семантического поиска:")
    results = api.search("грустная песня", limit=3)
    for i, track in enumerate(results, 1):
        print(f"{i}. {track['title']} (similarity: {track['similarity']:.3f})")
    
    print()
    print("🎭 Демо эмоционального фильтра:")
    joy_tracks = api.filter_by_emotion("joy", limit=3)
    for i, track in enumerate(joy_tracks, 1):
        print(f"{i}. {track['title']} (confidence: {track['emotion_confidence']:.3f})")
    
    print()
    print("✅ API готово к продакшену!")

if __name__ == "__main__":
    create_api_demo()