import axios from 'axios';
import { db } from './db.js';
import fs from 'fs';
import path from 'path';
// Generate a random local playlist cover image URL
function generateRandomPlaylistImage() {
    try {
        const coversDir = path.join(process.cwd(), 'public', 'playlist-covers');
        console.log(`[PLAYLIST COVER] Looking for images in directory: ${coversDir}`);
        // Check if directory exists
        if (!fs.existsSync(coversDir)) {
            console.log('[PLAYLIST COVER] Directory not found, creating it...');
            fs.mkdirSync(coversDir, { recursive: true });
        }
        // Get all image files from the directory (Spotify only accepts JPEG for cover uploads)
        const files = fs.readdirSync(coversDir).filter(file => {
            const ext = path.extname(file).toLowerCase();
            return ['.jpg', '.jpeg'].includes(ext); // Only JPEG files for Spotify upload
        });
        console.log(`[PLAYLIST COVER] Found ${files.length} image files:`, files);
        // Log file sizes for debugging
        files.forEach(file => {
            const filePath = path.join(coversDir, file);
            const stats = fs.statSync(filePath);
            const sizeKB = (stats.size / 1024).toFixed(2);
            console.log(`[PLAYLIST COVER] File: ${file}, Size: ${sizeKB} KB`);
        });
        if (files.length === 0) {
            console.log('[PLAYLIST COVER] No playlist cover images found in public/playlist-covers/');
            return '/api/placeholder-playlist-cover';
        }
        // Select a random image
        const randomFile = files[Math.floor(Math.random() * files.length)];
        const imageUrl = `/api/playlist-covers/${encodeURIComponent(randomFile)}`;
        console.log(`[PLAYLIST COVER] Selected random playlist cover: ${imageUrl} (from file: ${randomFile})`);
        return imageUrl;
    }
    catch (error) {
        console.error('[PLAYLIST COVER] Error generating random playlist image:', error);
        return '/api/placeholder-playlist-cover';
    }
}
export function getUserTokens(uid) {
    const row = db.db
        .prepare('SELECT access_token, refresh_token, token_expires_at FROM users WHERE id = ?')
        .get(uid);
    if (!row)
        return null;
    return {
        access_token: row.access_token,
        refresh_token: row.refresh_token,
        token_expires_at: row.token_expires_at,
    };
}
export async function ensureValidAccessToken(uid) {
    const tokens = getUserTokens(uid);
    if (!tokens?.access_token) {
        throw new Error('User not authenticated');
    }
    const now = Date.now();
    if (tokens.token_expires_at && tokens.token_expires_at > now + 30000) {
        return tokens.access_token;
    }
    if (!tokens.refresh_token) {
        return tokens.access_token;
    }
    // Refresh token via Spotify
    const clientId = process.env.SPOTIFY_CLIENT_ID || '';
    const clientSecret = process.env.SPOTIFY_CLIENT_SECRET || '';
    const resp = await axios.post('https://accounts.spotify.com/api/token', new URLSearchParams({ grant_type: 'refresh_token', refresh_token: tokens.refresh_token }), {
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
            Authorization: `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString('base64')}`,
        },
    });
    const { access_token, expires_in } = resp.data;
    const token_expires_at = Date.now() + expires_in * 1000 - 60000;
    db.db
        .prepare('UPDATE users SET access_token = ?, token_expires_at = ?, updated_at=? WHERE id = ?')
        .run(access_token, token_expires_at, Date.now(), uid);
    return access_token;
}
export function vibeToTargets(vibe) {
    switch (vibe) {
        case 'energetic':
            return { target_energy: 0.85, target_danceability: 0.7, target_tempo: 130 };
        case 'chill':
            return { target_energy: 0.3, target_danceability: 0.4, target_tempo: 90 };
        case 'happy':
            return { target_valence: 0.85, target_danceability: 0.6 };
        case 'sad':
            return { target_valence: 0.2 };
        case 'party':
            return { target_danceability: 0.85, target_energy: 0.8, target_tempo: 125 };
        case 'focus':
            return { target_energy: 0.4, target_instrumentalness: 0.5 };
        default:
            return {};
    }
}
export async function fetchRecommendations(accessToken, seeds, targets, limit = 25) {
    // Legacy kept for compatibility; prefer fetchSimilarTrackUris below
    return fetchSimilarTrackUris(accessToken, seeds.seed_tracks, seeds.seed_artists, seeds.seed_genres, targets, limit);
}
export async function createSpotifyPlaylist(accessToken, userId, name, description) {
    console.log(`[PLAYLIST CREATION] Creating Spotify playlist: "${name}" for user: ${userId}`);
    const resp = await axios.post(`https://api.spotify.com/v1/users/${encodeURIComponent(userId)}/playlists`, { name, description, public: false }, { headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' } });
    const pl = resp.data;
    console.log(`[PLAYLIST CREATION] Spotify playlist created successfully with ID: ${pl.id}`);
    // Generate a random local playlist cover image
    const imageUrl = generateRandomPlaylistImage();
    // Extract the filename from the imageUrl to use the SAME image for Spotify upload
    const selectedFilename = decodeURIComponent(imageUrl.replace('/api/playlist-covers/', ''));
    console.log(`[PLAYLIST COVER] Selected image for both website and Spotify: ${selectedFilename}`);
    // Get the actual file path for uploading to Spotify (only JPEG files)
    const coversDir = path.join(process.cwd(), 'public', 'playlist-covers');
    const files = fs.readdirSync(coversDir).filter(file => {
        const ext = path.extname(file).toLowerCase();
        return ['.jpg', '.jpeg'].includes(ext); // Only JPEG files for Spotify upload
    });
    if (files.length > 0) {
        // Find the specific file that was selected for the website
        const selectedFile = files.find(file => file === selectedFilename);
        if (selectedFile) {
            const imagePath = path.join(coversDir, selectedFile);
            const stats = fs.statSync(imagePath);
            const fileSizeKB = (stats.size / 1024).toFixed(2);
            console.log(`[PLAYLIST COVER] Using SAME image for Spotify upload: ${selectedFile} (${fileSizeKB} KB)`);
            // Upload the SAME cover image to Spotify
            const uploadSuccess = await uploadPlaylistCover(accessToken, pl.id, imagePath);
            if (uploadSuccess) {
                console.log(`[PLAYLIST COVER] ✅ Successfully uploaded SAME cover image to Spotify playlist ${pl.id}`);
            }
            else {
                console.log(`[PLAYLIST COVER] ❌ Failed to upload ${selectedFile} to Spotify, but website will still show it`);
            }
        }
        else {
            console.log(`[PLAYLIST COVER] ⚠️  Could not find selected file ${selectedFilename} for Spotify upload`);
            console.log(`[PLAYLIST COVER] ✅  WEBSITE COVER: Random cover image will still be displayed on your website.`);
        }
    }
    return { id: pl.id, url: pl.external_urls?.spotify, imageUrl };
}
export async function addTracks(accessToken, playlistId, trackUris) {
    if (!trackUris.length)
        return;
    await axios.post(`https://api.spotify.com/v1/playlists/${encodeURIComponent(playlistId)}/tracks`, { uris: trackUris }, { headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' } });
}
// Upload a playlist cover image to Spotify
export async function uploadPlaylistCover(accessToken, playlistId, imagePath) {
    try {
        console.log(`[PLAYLIST COVER] Attempting to upload cover image for playlist ${playlistId} from path: ${imagePath}`);
        // Check if file exists
        if (!fs.existsSync(imagePath)) {
            console.error(`[PLAYLIST COVER] Image file not found: ${imagePath}`);
            return false;
        }
        // Read the image file
        let imageBuffer = fs.readFileSync(imagePath);
        let fileSize = imageBuffer.length;
        console.log(`[PLAYLIST COVER] Original image file size: ${fileSize} bytes (${(fileSize / 1024).toFixed(2)} KB)`);
        // Check if we need to compress the image
        // We need to account for base64 encoding overhead (33% increase)
        // So we want the original file to be under ~190 KB to stay under 256 KB when base64 encoded
        const maxOriginalSize = 190 * 1024; // 190 KB
        if (fileSize > maxOriginalSize) {
            console.log(`[PLAYLIST COVER] Image too large (${(fileSize / 1024).toFixed(2)} KB), attempting to compress...`);
            // For now, let's skip files that are too large and try a different one
            console.error(`[PLAYLIST COVER] Image file too large for Spotify upload: ${fileSize} bytes (max ~190 KB to account for base64 overhead)`);
            return false;
        }
        // Convert to base64
        let base64Image = imageBuffer.toString('base64');
        const base64Size = base64Image.length;
        console.log(`[PLAYLIST COVER] Base64 length: ${base64Size} characters (${(base64Size / 1024).toFixed(2)} KB)`);
        // Ensure we don't have any data URL prefix
        if (base64Image.startsWith('data:')) {
            base64Image = base64Image.split(',')[1] || base64Image;
            console.log(`[PLAYLIST COVER] Removed data URL prefix from base64`);
        }
        // Final check - ensure base64 size is reasonable
        if (base64Size > 300 * 1024) { // 300 KB base64 limit
            console.error(`[PLAYLIST COVER] Base64 encoded image too large: ${base64Size} characters`);
            return false;
        }
        // Determine content type based on file extension
        const ext = path.extname(imagePath).toLowerCase();
        let contentType = 'image/jpeg'; // default
        switch (ext) {
            case '.png':
                contentType = 'image/png';
                break;
            case '.gif':
                contentType = 'image/gif';
                break;
            case '.webp':
                contentType = 'image/webp';
                break;
            case '.svg':
                contentType = 'image/svg+xml';
                break;
            case '.jpg':
            case '.jpeg':
                contentType = 'image/jpeg';
                break;
        }
        console.log(`[PLAYLIST COVER] Using content type: ${contentType}`);
        // Check token scopes first
        try {
            console.log(`[PLAYLIST COVER] Checking token scopes...`);
            const meResponse = await axios.get('https://api.spotify.com/v1/me', {
                headers: { 'Authorization': `Bearer ${accessToken}` }
            });
            console.log(`[PLAYLIST COVER] Token is valid for user: ${meResponse.data.display_name}`);
            // Test if we can access the playlist
            const playlistResponse = await axios.get(`https://api.spotify.com/v1/playlists/${playlistId}`, {
                headers: { 'Authorization': `Bearer ${accessToken}` }
            });
            console.log(`[PLAYLIST COVER] Can access playlist: ${playlistResponse.data.name}`);
        }
        catch (error) {
            console.error(`[PLAYLIST COVER] Token validation failed:`, error.response?.data || error.message);
        }
        // Upload to Spotify
        console.log(`[PLAYLIST COVER] Making request to Spotify API: https://api.spotify.com/v1/playlists/${playlistId}/images`);
        console.log(`[PLAYLIST COVER] Access token (first 20 chars): ${accessToken.substring(0, 20)}...`);
        // Try different approaches for image upload
        let response;
        try {
            // Method 1: Standard PUT request (requires ugc-image-upload scope)
            response = await axios.put(`https://api.spotify.com/v1/playlists/${encodeURIComponent(playlistId)}/images`, base64Image, {
                headers: {
                    'Authorization': `Bearer ${accessToken}`,
                    'Content-Type': contentType
                }
            });
        }
        catch (error) {
            if (error.response?.status === 401) {
                console.log(`[PLAYLIST COVER] Method 1 failed with 401, trying alternative approach...`);
                // Method 2: Try with different content type
                try {
                    response = await axios.put(`https://api.spotify.com/v1/playlists/${encodeURIComponent(playlistId)}/images`, base64Image, {
                        headers: {
                            'Authorization': `Bearer ${accessToken}`,
                            'Content-Type': 'image/jpeg' // Force JPEG content type
                        }
                    });
                }
                catch (error2) {
                    console.log(`[PLAYLIST COVER] Method 2 also failed: ${error2.response?.status}`);
                    throw error; // Re-throw original error
                }
            }
            else {
                throw error; // Re-throw if not 401
            }
        }
        console.log(`[PLAYLIST COVER] Successfully uploaded cover image for playlist ${playlistId}, response status: ${response.status}`);
        console.log(`[PLAYLIST COVER] Response headers:`, response.headers);
        return true;
    }
    catch (error) {
        console.error(`[PLAYLIST COVER] Failed to upload cover image for playlist ${playlistId}:`);
        console.error(`[PLAYLIST COVER] Error status:`, error.response?.status);
        console.error(`[PLAYLIST COVER] Error data:`, error.response?.data);
        console.error(`[PLAYLIST COVER] Error message:`, error.message);
        return false;
    }
}
// ----- New: Similar tracks without recommendations endpoint -----
async function getRelatedArtists(accessToken, artistId) {
    const resp = await axios.get(`https://api.spotify.com/v1/artists/${encodeURIComponent(artistId)}/related-artists`, {
        headers: { Authorization: `Bearer ${accessToken}` },
    });
    const artists = (resp.data?.artists || []);
    return artists.map(a => a.id).filter(Boolean);
}
async function getArtistTopTracks(accessToken, artistId) {
    const resp = await axios.get(`https://api.spotify.com/v1/artists/${encodeURIComponent(artistId)}/top-tracks?market=from_token`, {
        headers: { Authorization: `Bearer ${accessToken}` },
    });
    const tracks = (resp.data?.tracks || []);
    return tracks.map(t => t.uri || (t.id ? `spotify:track:${t.id}` : null)).filter((u) => !!u);
}
async function searchTracksByGenre(accessToken, genre, limit) {
    const resp = await axios.get('https://api.spotify.com/v1/search', {
        headers: { Authorization: `Bearer ${accessToken}` },
        params: { q: `genre:"${genre}"`, type: 'track', limit: Math.min(limit, 50) },
    });
    const tracks = (resp.data?.tracks?.items || []);
    return tracks.map(t => t.uri || (t.id ? `spotify:track:${t.id}` : null)).filter((u) => !!u);
}
async function filterByTargets(accessToken, trackUris, targets) {
    if (!trackUris.length || Object.keys(targets).length === 0)
        return trackUris;
    const ids = trackUris.map(u => u.split(':').pop()).filter(Boolean);
    const resp = await axios.get('https://api.spotify.com/v1/audio-features', {
        headers: { Authorization: `Bearer ${accessToken}` },
        params: { ids: ids.slice(0, 100).join(',') },
    });
    const features = (resp.data?.audio_features || []);
    const pass = new Set(features
        .filter(f => !!f && (!('target_energy' in targets) || Math.abs(targets.target_energy - f.energy) <= 0.4))
        .filter(f => !('target_danceability' in targets) || Math.abs(targets.target_danceability - f.danceability) <= 0.4)
        .filter(f => !('target_valence' in targets) || Math.abs(targets.target_valence - f.valence) <= 0.5)
        .filter(f => !('target_tempo' in targets) || Math.abs(targets.target_tempo - f.tempo) <= 30)
        .filter(f => !('target_instrumentalness' in targets) || Math.abs(targets.target_instrumentalness - f.instrumentalness) <= 0.5)
        .map(f => f.id));
    return trackUris.filter(u => pass.has(u.split(':').pop()));
}
export async function fetchSimilarTrackUris(accessToken, seedTrackUris, seedArtistIds, seedGenres, targets = {}, limit = 25) {
    const candidateUris = new Set();
    // From seed artists and from artists of seed tracks
    const trackIds = (seedTrackUris || []).map(u => u?.split(':').pop()).filter(Boolean);
    const seedArtistSet = new Set(seedArtistIds || []);
    // If we got tracks, fetch their artists to expand
    if (trackIds.length) {
        const tracksResp = await axios.get('https://api.spotify.com/v1/tracks', {
            headers: { Authorization: `Bearer ${accessToken}` },
            params: { ids: trackIds.slice(0, 50).join(',') },
        });
        const tracks = (tracksResp.data?.tracks || []);
        tracks.forEach(t => (t.artists || []).forEach(a => a?.id && seedArtistSet.add(a.id)));
    }
    // Expand via related artists and take top tracks
    const seedArtists = Array.from(seedArtistSet).slice(0, 10);
    for (const artistId of seedArtists) {
        try {
            const related = (await getRelatedArtists(accessToken, artistId)).slice(0, 10);
            const pool = [artistId, ...related];
            for (const a of pool) {
                const tops = await getArtistTopTracks(accessToken, a);
                tops.forEach(u => candidateUris.add(u));
                if (candidateUris.size >= limit * 4)
                    break;
            }
            if (candidateUris.size >= limit * 4)
                break;
        }
        catch { }
    }
    // Genre-based search fallback
    for (const g of (seedGenres || []).slice(0, 3)) {
        try {
            const found = await searchTracksByGenre(accessToken, g, 50);
            found.forEach(u => candidateUris.add(u));
            if (candidateUris.size >= limit * 4)
                break;
        }
        catch { }
    }
    let uris = Array.from(candidateUris);
    uris = await filterByTargets(accessToken, uris, targets);
    // Shuffle and take limit
    uris.sort(() => Math.random() - 0.5);
    return uris.slice(0, limit);
}