PlayerAudio.cpp

#include "PlayerAudio.h"

PlayerAudio::PlayerAudio() 
    : resamplingSource(&transportSource, false, 2),
      isPaused(false), 
      islooping(false),
      abLoopEnabled(false),
      abLoopPointA(0.0),
      abLoopPointB(0.0),
      currentPlaylistIndex(-1),
      shouldAutoAdvance(false)
{
    formatManager.registerBasicFormats();
}

PlayerAudio::~PlayerAudio()
{
    transportSource.setSource(nullptr);
}

void PlayerAudio::prepareToPlay(int samplesPerBlockExpected, double sampleRate)
{
    transportSource.prepareToPlay(samplesPerBlockExpected, sampleRate);
    resamplingSource.prepareToPlay(samplesPerBlockExpected, sampleRate);
}

void PlayerAudio::getNextAudioBlock(const juce::AudioSourceChannelInfo& bufferToFill)
{
    resamplingSource.getNextAudioBlock(bufferToFill);
    
    if (abLoopEnabled && readerSource != nullptr)
    {
        double currentPos = transportSource.getCurrentPosition();
        if (currentPos >= abLoopPointB)
        {
            transportSource.setPosition(abLoopPointA);
        }
    }
    
    // Auto-advance to next track when current track finishes
    if (!abLoopEnabled && !islooping && readerSource != nullptr)
    {
        double currentPos = transportSource.getCurrentPosition();
        double length = getLengthInSeconds();
        
        // Check if track has finished (position at or past end)
        if (length > 0.0 && currentPos >= length - 0.1)
        {
            if (!shouldAutoAdvance && hasNext())
            {
                shouldAutoAdvance = true;
                // Schedule playNext on message thread to avoid audio thread issues
                juce::MessageManager::callAsync([this]() {
                    if (hasNext()) {
                        playNext();
                    }
                });
            }
        }
        else if (currentPos < length - 0.5)
        {
            // Reset flag when position is not near the end
            shouldAutoAdvance = false;
        }
    }
}

void PlayerAudio::releaseResources()
{
    resamplingSource.releaseResources();
    transportSource.releaseResources();
}

void PlayerAudio::loadAudioFile(const juce::File& file)
{
    // Clear playlist when loading a single file
    playlist.clear();
    currentPlaylistIndex = -1;
    shouldAutoAdvance = false;
    
    loadFileInternal(file);
}

void PlayerAudio::loadFileInternal(const juce::File& file)
{
    if (file.existsAsFile())
    {
        currentFilename = file.getFileName();
        currentMetadata = Metadata();
        
        TagLib::FileRef fileRef(file.getFullPathName().toRawUTF8());
        if (!fileRef.isNull() && fileRef.tag())
        {
            TagLib::Tag* tag = fileRef.tag();
            currentMetadata.title = juce::String(tag->title().toCString(true));
            currentMetadata.artist = juce::String(tag->artist().toCString(true));
            currentMetadata.album = juce::String(tag->album().toCString(true));
            currentMetadata.genre = juce::String(tag->genre().toCString(true));
            currentMetadata.comment = juce::String(tag->comment().toCString(true));
            currentMetadata.year = tag->year();
            currentMetadata.track = tag->track();
        }
        
        // Load audio file for playback using JUCE
        if (auto* reader = formatManager.createReaderFor(file))
        {
            transportSource.stop();
            transportSource.setSource(nullptr);
            readerSource.reset();

            readerSource = std::make_unique<juce::AudioFormatReaderSource>(reader, true);

            transportSource.setSource(readerSource.get(), 0, nullptr, reader->sampleRate);
            
            readerSource->setLooping(islooping);
            
            isPaused = false;
            abLoopEnabled = false;
            abLoopPointA = 0.0;
            abLoopPointB = getLengthInSeconds();
        }
    }
    else
    {
        // Clear metadata if file doesn't exist
        currentMetadata = Metadata();
        currentFilename = juce::String();
    }
}

void PlayerAudio::play()
{
    if (readerSource != nullptr)
    {
        transportSource.start();
        isPaused = false;
    }
}

void PlayerAudio::pause()
{
    if (transportSource.isPlaying())
    {
        transportSource.stop();
        isPaused = true;
    }
}

void PlayerAudio::stop()
{
    transportSource.stop();
    transportSource.setPosition(0.0);
    isPaused = false;
}

void PlayerAudio::goToStart()
{
    transportSource.setPosition(0.0);
}

void PlayerAudio::goToEnd()
{
    if (readerSource != nullptr)
    {
        double lengthInSeconds = getLengthInSeconds();
        transportSource.setPosition(lengthInSeconds);
    }
}

void PlayerAudio::setGain(float gain)
{
    transportSource.setGain(gain);
}

void PlayerAudio::setPosition(double positionInSeconds)
{
    transportSource.setPosition(positionInSeconds);
}

void PlayerAudio::setLooping(bool shouldLoop)
{
    islooping = shouldLoop;
    if (readerSource != nullptr)
    {
        readerSource->setLooping(shouldLoop);
    }
}

void PlayerAudio::setSpeed(double speed)
{
    resamplingSource.setResamplingRatio(speed);
}

void PlayerAudio::setABLoopPoints(double pointA, double pointB)
{
    if (pointA < pointB && pointB <= getLengthInSeconds())
    {
        abLoopPointA = pointA;
        abLoopPointB = pointB;
        abLoopEnabled = true;
    }
}

void PlayerAudio::clearABLoop()
{
    abLoopEnabled = false;
    abLoopPointA = 0.0;
    abLoopPointB = getLengthInSeconds();
}

bool PlayerAudio::isPlaying() const
{
    return transportSource.isPlaying();
}

bool PlayerAudio::isLooping() const
{
    return islooping;
}

double PlayerAudio::getPosition() const
{
    return transportSource.getCurrentPosition();
}

double PlayerAudio::getLengthInSeconds() const
{
    if (readerSource != nullptr)
    {
        return transportSource.getLengthInSeconds();
    }
    return 0.0;
}

void PlayerAudio::loadPlaylist(const juce::Array<juce::File>& files)
{
    playlist.clear();
    currentPlaylistIndex = -1;
    shouldAutoAdvance = false;
    
    // Filter out invalid files and add to playlist
    for (const auto& file : files)
    {
        if (file.existsAsFile())
        {
            playlist.add(file);
        }
    }
    
    // Load first track if playlist is not empty
    if (playlist.size() > 0)
    {
        setCurrentPlaylistIndex(0);
    }
}

void PlayerAudio::playNext()
{
    if (hasNext())
    {
        setCurrentPlaylistIndex(currentPlaylistIndex + 1);
        play();
    }
}

void PlayerAudio::playPrevious()
{
    if (hasPrevious())
    {
        setCurrentPlaylistIndex(currentPlaylistIndex - 1);
        play();
    }
}

bool PlayerAudio::hasNext() const
{
    return currentPlaylistIndex >= 0 && currentPlaylistIndex < playlist.size() - 1;
}

bool PlayerAudio::hasPrevious() const
{
    return currentPlaylistIndex > 0 && playlist.size() > 0;
}

int PlayerAudio::getPlaylistSize() const
{
    return playlist.size();
}

int PlayerAudio::getCurrentPlaylistIndex() const
{
    return currentPlaylistIndex;
}

void PlayerAudio::setCurrentPlaylistIndex(int index)
{
    if (index >= 0 && index < playlist.size())
    {
        currentPlaylistIndex = index;
        shouldAutoAdvance = false;
        loadFileInternal(playlist[index]);
    }
}