const { createAudioPlayer, createAudioResource, AudioPlayerStatus, joinVoiceChannel } = require('@discordjs/voice');
const fs = require('fs');

const queueMap = new Map();
const playerMap = new Map();
const currentTrackMap = new Map();
const repeatMap = new Map();

function addToQueue(guildId, filePath, title) {
    if (!queueMap.has(guildId)) {
        queueMap.set(guildId, []);
    }
    queueMap.get(guildId).push({ filePath, title });
}

function getQueue(guildId) {
    return queueMap.get(guildId) || [];
}

function getCurrentTrack(guildId) {
    return currentTrackMap.get(guildId) || null;
}

function toggleRepeat(guildId) {
    const currentRepeat = repeatMap.get(guildId) || false;
    repeatMap.set(guildId, !currentRepeat);
    return !currentRepeat;
}

function playNextInQueue(guildId, voiceChannel) {
    const queue = getQueue(guildId);
    const currentTrack = getCurrentTrack(guildId);

    if (currentTrack) {
        return false;
    }

    if (queue.length === 0) return false;

    const connection = joinVoiceChannel({
        channelId: voiceChannel.id,
        guildId: guildId,
        adapterCreator: voiceChannel.guild.voiceAdapterCreator,
    });

    const audioPlayer = playerMap.get(guildId) || createAudioPlayer();
    playerMap.set(guildId, audioPlayer);

    const trackToPlay = queue.shift();
    currentTrackMap.set(guildId, trackToPlay);

    if (!fs.existsSync(trackToPlay.filePath)) {
        console.error('Audio file not found:', trackToPlay.filePath);
        return false;
    }

    const resource = createAudioResource(trackToPlay.filePath);
    audioPlayer.play(resource);
    connection.subscribe(audioPlayer);

    audioPlayer.on(AudioPlayerStatus.Idle, () => {
        currentTrackMap.delete(guildId);

        if (queue.length > 0) {
            playNextInQueue(guildId, voiceChannel);
        } else {
            connection.destroy();
        }

        fs.unlink(trackToPlay.filePath, (err) => {
            if (err) console.error('Error deleting file:', trackToPlay.filePath, err);
        });
    });

    audioPlayer.on('error', (err) => {
        console.error('AudioPlayer error:', err);
        currentTrackMap.delete(guildId);
        connection.destroy();
    });

    return true;
}

function skipTrack(guildId, voiceChannel) {
    const player = playerMap.get(guildId);
    const queue = getQueue(guildId);
    const repeat = repeatMap.get(guildId);

    if (!player) {
        console.error('No player found for this guild.');
        return;
    }

    currentTrackMap.delete(guildId);

    if (repeat) {
        repeatMap.set(guildId, false);
    }

    player.stop();

    if (queue.length > 0) {
        playNextInQueue(guildId, voiceChannel);
    } else {
        player.stop();
    }
}


module.exports = { addToQueue, getQueue, getCurrentTrack, playNextInQueue, skipTrack, toggleRepeat };