server.js

const express = require('express');
const sqlite3 = require('sqlite3').verbose();
const path = require('path');

const app = express();
const port = 3000;

// Configuração do Banco de Dados SQLite
const dbPath = path.resolve(__dirname, 'music.db');
const db = new sqlite3.Database(dbPath, (err) => {
  if (err) {
    console.error('Erro ao abrir o banco de dados:', err.message);
  } else {
    console.log('Conectado ao banco de dados SQLite.');
  }
});

// --- INÍCIO DA ATUALIZAÇÃO PARA O GEMINI ---
require('dotenv').config();
const fetch = require('node-fetch');

// 1. Removido: const { OpenAI } = require('openai');
// 2. Adicionado: Pacote do Google Generative AI
const { GoogleGenerativeAI } = require('@google/generative-ai');

// 3. Removido: const openai = new OpenAI(...)
// 4. Adicionado: Inicialização do cliente Gemini
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
const model = genAI.getGenerativeModel({
  model: "gemini-2.5-flash", // Modelo atualizado, mais rápido e estável
  systemInstruction: "Você é um assistente de música que responde apenas com fatos e curiosidades verificáveis sobre canções. Responda apenas com a lista de curiosidades, numeradas com '1.', '2.', '3.'.",
  generationConfig: {
    temperature: 0.7,
  }
});
// --- FIM DA ATUALIZAÇÃO PARA O GEMINI ---

// Serve os arquivos estáticos da pasta 'public'
app.use(express.static(path.join(__dirname, 'public')));


// Lógica para agrupar as músicas por playlist (função auxiliar)
function groupSongsByPlaylist(rows) {
    const playlistsMap = {};
    let currentPlaylistId = null;
    let playlistIndex = 0;

    rows.forEach(row => {
        // Se a playlist for nova, crie a entrada no mapa
        if (row.playlist_id !== currentPlaylistId) {
            currentPlaylistId = row.playlist_id;
            playlistsMap[row.playlist_name] = {
                name: row.playlist_name,
                songs: []
            };
        }
        
        // Adicionar a música, garantindo que o nome do campo seja 'song' (para o frontend)
        playlistsMap[row.playlist_name].songs.push({
            id: row.song_id.toString(), // O frontend espera string
            name: row.name,
            artist: row.artist,
            cover: row.cover,
            song: row.song_path, // Mapeado de volta para 'song'
            genre: row.genre,
            bpm: row.bpm
        });
    });

    return Object.values(playlistsMap);
}


// Endpoint para obter todas as playlists (principalmente usado pelo frontend)
app.get('/api/playlists', (req, res) => {
  // Consulta SQL: JOIN para ligar playlists e músicas, ordenado para facilitar o agrupamento
  const sql = `
    SELECT p.playlist_id, p.name AS playlist_name, s.* FROM playlists p
    JOIN songs s ON p.playlist_id = s.playlist_id
    ORDER BY p.playlist_id, s.song_id
  `;

  db.all(sql, [], (err, rows) => {
    if (err) {
      console.error(err.message);
      res.status(500).json({ error: 'Erro interno ao consultar o banco de dados.' });
      return;
    }
    
    // Transformar a lista plana de linhas SQL no JSON aninhado que o frontend espera
    const playlistsArray = groupSongsByPlaylist(rows);
    res.json(playlistsArray);
  });
});

// Endpoint para obter as músicas da primeira playlist (mantido por compatibilidade com a rota antiga /api/songs)
app.get('/api/songs', (req, res) => {
    const sql = `
        SELECT s.* FROM songs s
        WHERE s.playlist_id = (SELECT MIN(playlist_id) FROM playlists)
        ORDER BY s.song_id
    `;
    
    db.all(sql, [], (err, rows) => {
        if (err) {
            res.status(500).json({ error: err.message });
            return;
        }

        // Formatar as músicas no objeto esperado
        const songs = rows.map(s => ({
            id: s.song_id.toString(),
            name: s.name,
            artist: s.artist,
            cover: s.cover,
            song: s.song_path,
            genre: s.genre,
            bpm: s.bpm
        }));

        res.json(songs);
    });
});


// Endpoint para obter curiosidades sobre uma música
app.get('/api/curiosities', async (req, res) => {
  const { name, artist } = req.query;

  if (!name || !artist) {
    return res.status(400).json({ error: 'Nome e artista da música são obrigatórios.' });
  }

  try {
    const prompt = `Liste 3 curiosidades interessantes, verificáveis e curtas sobre a música "${name}" do artista "${artist}".`;

    // --- LÓGICA DA API ATUALIZADA ---
    // 5. Chamada da API alterada de OpenAI para Gemini
    const result = await model.generateContent(prompt);
    const response = await result.response;
    const text = response.text();
    
    // 6. Lógica de parsing mantida, pois o systemInstruction do Gemini foi
    //    configurado para formatar a resposta de forma similar.
    const curiosities = text
      .split(/\d+\.\s*/g) // Divide por "1. ", "2. ", etc.
      .filter(text => text.trim() !== '');

    res.json({ name, artist, curiosities });
    // --- FIM DA LÓGICA DA API ATUALIZADA ---

  } catch (error) {
    console.error('Erro ao obter curiosidades:', error);
    res.status(500).json({ error: 'Erro ao buscar curiosidades sobre a música.' });
  }
});




// Endpoint ÚNICO para pesquisar música na API do Deezer
app.get('/api/search_music', async (req, res) => {
  const { query } = req.query;

  if (!query) {
    return res.status(400).json({ error: 'Termo de pesquisa é obrigatório.' });
  }

  console.log(`🔍 Buscando músicas no Deezer para: ${query}`);

  try {
    const fetch = (await import('node-fetch')).default;
    const url = `https://api.deezer.com/search?q=${encodeURIComponent(query)}`;
    const response = await fetch(url, {
      headers: {
        "User-Agent": "Mozilla/5.0 (Node.js Server)"
      }
    });
    const data = await response.json();

    if (!data.data || data.data.length === 0) {
      console.log("Nenhum resultado encontrado para:", query);
      return res.json([]);
    }

    // Mapeia o formato para o frontend
    const results = data.data.slice(0, 10).map(track => ({
      name: track.title,
      artist: track.artist.name,
      cover: track.album?.cover_medium || track.album?.cover || "",
      preview_url: track.preview || "",
      deezer_url: track.link,
      genre: track.genre_id || "Desconhecido",
      bpm: null
    }));

    res.json(results);
  } catch (error) {
    console.error("Erro ao buscar músicas na API Deezer:", error);
    res.status(500).json({ error: "Erro ao buscar músicas na Deezer." });
  }
});




app.listen(port, () => {
  console.log(`Servidor rodando em http://localhost:${port}`);
});