/*
 * Copyright (C) 2022 jimj316
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package moe.nekojimi.chords;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.function.Consumer;

/**
 *
 * @author jimj316
 */
public class QueueManager implements Consumer<Track>
{

    private Track restartingTrack = null;
    private final PriorityQueue<Track> jukeboxQueue = new PriorityQueue<>();
    private Playlist playlist;
    private MusicHandler handler;

    public QueueManager()
    {
//        jukeboxQueue = new LinkedList<>();
    }

    @Override
    public void accept(Track t)
    {
        jukeboxQueue.add(t);

        if (!handler.isPlaying() || handler.getCurrentTrack() == null)
            handler.playNext();

        if (handler.isPlaying() != (handler.getCurrentTrack() == null))
            System.err.println("WARNING: handler isPlaying violates contract! Something dumb going on!");
    }

    /**
     * Called by the music handler when the current track has ended, or if
     * playNext is called with nothing playing.
     *
     * @return the next track to play, or null to stop playing.
     */
    public Track nextTrackNeeded()
    {
        // if we're restarting the current track: store, clear, and return it
        if (restartingTrack != null)
        {
            Track ret = restartingTrack;
            restartingTrack = null;
            return ret;
        }
        // if there's anything in the queue, play that first
        if (!jukeboxQueue.isEmpty())
        {
            return jukeboxQueue.poll();
        }
        // otherwise if there's a playlist, shuffle from that
        else if (playlist != null)
        {
            return playlist.getNextTrack();
        }
        // otherwise stop playing
        else
            return null;
    }

    public MusicHandler getHandler()
    {
        return handler;
    }

    public void addTrack(Track track)
    {
        System.out.println("Track added to queue: " + track.getLocation().getAbsolutePath());
        jukeboxQueue.add(track);

    }

    public boolean removeTrack(int i)
    {
        try
        {
            return jukeboxQueue.remove((Track) jukeboxQueue.toArray()[i]);
        } catch (ArrayIndexOutOfBoundsException ex)
        {
            return false;
        }
    }

    public boolean removeTrack(Track track)
    {
        return jukeboxQueue.remove(track);
    }

    public void setHandler(MusicHandler handler)
    {
        this.handler = handler;
        handler.setQueueManager(this);
    }

    public Queue<Track> getJukeboxQueue()
    {
        return jukeboxQueue;
    }

    public Playlist getPlaylist()
    {
        return playlist;
    }

    public void setPlaylist(Playlist playlist)
    {
        this.playlist = playlist;
    }

    public boolean restartTrack()
    {
        restartingTrack = handler.getCurrentTrack();
        if (restartingTrack != null)
        {
            handler.playNext();
            return true;
        } else
            return false;
    }
}