serverrdj.js

const express = require('express');
const WebSocket = require('ws');
const axios = require('axios');
const xml2js = require('xml2js');
const path = require('path');
require('dotenv').config();
const config = require('./config/server.config');

const app = express();
const parser = new xml2js.Parser({ explicitArray: false });

const radioDjBase = config.radiodjBaseUrl;

function buildRadioDjUrl(endpoint, queryParams = {}) {
    const params = new URLSearchParams();
    if (config.radiodjAuth) {
        params.set('auth', config.radiodjAuth);
    }
    Object.entries(queryParams).forEach(([key, value]) => {
        if (value !== undefined && value !== null) {
            params.set(key, String(value));
        }
    });
    const query = params.toString();
    return query ? `${radioDjBase}${endpoint}?${query}` : `${radioDjBase}${endpoint}`;
}

if (!config.radiodjAuth) {
    console.warn('⚠️ RADIODJ_AUTH non impostato: se RadioDJ richiede auth, configura il file .env.');
}

app.use(express.static(path.join(__dirname, 'public')));
app.listen(config.httpPort, () => console.log(`🌐 HTTP su http://localhost:${config.httpPort}`));

const wss = new WebSocket.Server({ port: config.wsPort }, () => console.log(`📡 WS su ws://localhost:${config.wsPort}`));

wss.on('connection', ws => {
    console.log('💻 Client connesso');

    const interval = setInterval(async () => {
        try {
            const nowPlayingRes = await axios.get(buildRadioDjUrl('/np'));
            const nowPlayingData = await parser.parseStringPromise(nowPlayingRes.data);

            if (!nowPlayingData || !nowPlayingData.SongData || !nowPlayingData.SongData.Title) {
                ws.send(JSON.stringify({ status: 'NO_TRACK' }));
                return;
            }

            const track = nowPlayingData.SongData;

            if (config.debugRest) {
                console.log('🔎 DEBUG NOWPLAYING KEYS:', Object.keys(track || {}));
                console.log('🔎 DEBUG NOWPLAYING RAW:', track);
            }

            // Recupera le prossime 4 tracce
            const nextTracks = [];
            for (let i = 0; i < config.nextTracksCount; i++) {
                try {
                    const res = await axios.get(buildRadioDjUrl('/pitem', { arg: i }));
                    const parsed = await parser.parseStringPromise(res.data);
                    const song = parsed?.SongData;

                    if (config.debugRest) {
                        console.log(`🔎 DEBUG NEXT SONG ${i} KEYS:`, Object.keys(song || {}));
                        console.log(`🔎 DEBUG NEXT SONG ${i} RAW:`, song);
                    }

                    if (song && song.Artist && song.Title) {
                        const title = song.Title;
                        const artist = song.Artist;
                        const cueIntro = song.CueIntro ? formatTime(song.CueIntro) : '--:--';
                        const duration = song.Duration ? formatTime(song.Duration) : '--:--';
                        const swName = (song.SwName || '').toUpperCase();
                        const trackTypeRaw = song.TrackType || song.SubCategory || song.Subcategory || '';
                        const trackType = String(trackTypeRaw).toUpperCase();
                        const isSweep = swName.includes('SWEEP') || trackType === 'JINGLE' || trackType === 'SWEEP';
                        const category = song.CatName || song.Category || song.Cat || null;
                        const subcategory = song.SubCategory || song.Subcategory || song.TrackType || null;

                        nextTracks.push({ artist, title, intro: cueIntro, duration, isSweep, category, subcategory });
                    } else {
                        nextTracks.push({ title: '---', artist: '---', intro: '--:--', duration: '--:--', isSweep: false, category: null, subcategory: null });
                    }
                } catch (err) {
                    console.error(`❌ Errore traccia ${i}:`, err.message);
                    nextTracks.push({ title: '---', artist: '---', intro: '--:--', duration: '--:--', isSweep: false, category: null, subcategory: null });
                }
            }

            // Calcolo preciso dell'intro countdown (senza parse/format doppi)
            const cueIntroRaw = parseFloat(track.CueIntro) || 0;
            const durationSec = parseFloat(track.Duration) || 0;
            const remainingSec = parseFloat(track.Remaining) || 0;

            let introCountdownSec = remainingSec - (durationSec - cueIntroRaw);
            if (introCountdownSec < 0) introCountdownSec = 0;

            // Payload completo
            const payload = {
                status: 'OK',
                timestamp: Date.now(),
                artist: track.Artist || '---',
                title: track.Title || '---',
                album: track.Album || '---',
                year: track.Year || '---',
                category: track.CatName || track.Category || track.Cat || null,
                subcategory: track.SubCategory || track.Subcategory || track.TrackType || null,
                intro: formatTime(introCountdownSec),
                cueIntroRaw: cueIntroRaw,
                introCountdownSec: Math.round(introCountdownSec),
                elapsed: formatTime(track.Elapsed),
                remaining: formatTime(track.Remaining),
                duration: formatTime(track.Duration),
                sentAt: Date.now(),
                nextTracks
            };

            ws.send(JSON.stringify(payload));
        } catch (err) {
            console.error('❌ Errore REST:', err.message);
        }
    }, config.pollMs);

    ws.on('close', () => {
        clearInterval(interval);
        console.log('🔌 Client disconnesso');
    });
});

// Format mm:ss da secondi
function formatTime(value) {
    if (value === null || value === undefined) return '--:--';
    // Se è già una stringa formattata tipo mm:ss, restituiscila
    if (typeof value === 'string' && value.includes(':')) return value;
    const n = Number(value);
    if (!Number.isFinite(n)) return '--:--';
    const sec = Math.max(0, Math.floor(n));
    const min = Math.floor(sec / 60);
    const rem = sec % 60;
    return `${min}:${rem.toString().padStart(2, '0')}`;
}