#include "phononplayer.h"
#include <QtPlugin>
#include <QCoreApplication>

AudioPlayer *PhononPlayerFactory::create(QObject *parent)
{
  return new PhononPlayer(parent);
}

Q_EXPORT_PLUGIN2(phononplayer, PhononPlayerFactory)

/* --------------------------------------------------------------- */

PhononPlayer::PhononPlayer(QObject *parent)
  : AudioPlayer(parent)
{
  m_working = AudioManager::isWorking();
  m_player = new Phonon::MediaObject(this);
  m_output = new Phonon::AudioOutput(Phonon::MusicCategory, this);
  Phonon::createPath(m_player, m_output);
}

bool PhononPlayer::isWorking() const
{
  return m_working;
}

void PhononPlayer::setMuted(bool mute)
{
  if (!isWorking())
    return;
  m_output->setMuted(mute);
}

bool PhononPlayer::isMuted() const
{
  return m_output->isMuted();
}

void PhononPlayer::play()
{
  m_player->play();
}

void PhononPlayer::play(Sound::Type sound)
{
  if (!m_working)
    return;
  m_player->setCurrentSource(Phonon::MediaSource(AudioManager::self()->sound(sound)));
  play();
}

bool PhononPlayer::isPlaying()
{
  return m_player->state() == Phonon::PlayingState;
}

void PhononPlayer::enqueue(Sound::Type sound)
{
  m_player->enqueue(Phonon::MediaSource(AudioManager::self()->sound(sound)));
}

void PhononPlayer::pause()
{
  m_player->pause();
}

bool PhononPlayer::isPaused()
{
  return m_player->state() == Phonon::PausedState;
}

void PhononPlayer::stop()
{
  m_player->stop();
}

bool PhononPlayer::isStopped()
{
  return m_player->state() == Phonon::StoppedState;
}

void PhononPlayer::clear()
{
  m_player->clear();
}

void PhononPlayer::clearQueue()
{
  m_player->clearQueue();
}

void PhononPlayer::setPrefinishMark(qint32 msecToEnd)
{
  connect(m_player, SIGNAL(prefinishMarkReached(qint32)), this, SLOT(prefinishMarkReached_ex(qint32)), Qt::UniqueConnection);
  m_player->setPrefinishMark(msecToEnd);
}

/* this is a simple hack to check if phonon can actually play sounds.. */
void PhononPlayer::test(QFile *testsound, qint32 length)
{
  m_player->stop();
  m_output->setVolume(0);
  m_player->setCurrentSource(Phonon::MediaSource(testsound));
  connect(m_player, SIGNAL(stateChanged(Phonon::State, Phonon::State)), this, SLOT(stateChanged_ex(Phonon::State, Phonon::State)));
  m_player->play();

  QTimer timer;
  timer.setSingleShot(true);
  connect(&timer, SIGNAL(timeout()), this, SLOT(testFinished()));
  timer.start(length);
  while(timer.isActive())
  {
    qApp->processEvents();
    Sleeper::msleep(1);
  }
  clear();
}

void PhononPlayer::prefinishMarkReached_ex(qint32 mark)
{
  emit prefinishMarkReached(mark);
}

void PhononPlayer::finished_ex()
{
  emit finished();
}

void PhononPlayer::stateChanged_ex(Phonon::State newstate, Phonon::State oldstate)
{
  if (newstate == Phonon::PlayingState)
    m_player->pause();
  if (oldstate == Phonon::PlayingState && newstate == Phonon::PausedState)
    m_player->stop();
  else if (oldstate == Phonon::PausedState && newstate == Phonon::StoppedState)
  {
    m_working = true;
    m_player->stop();
    m_output->setVolume(1);
    qDebug() << "Sound is working for you!";
    disconnect(m_player, SIGNAL(stateChanged(Phonon::State, Phonon::State)), this, SLOT(stateChanged_ex(Phonon::State, Phonon::State)));
  }
}

void PhononPlayer::testFinished()
{
  if (!m_working)
    qWarning() << "There's no sound for you :(";
  disconnect(m_player, SIGNAL(stateChanged(Phonon::State, Phonon::State)), this, SLOT(stateChanged_ex(Phonon::State, Phonon::State)));
}

/* --------------------------------------------------------------- */

void PhononPlayer::Sleeper::sleep(unsigned long secs)
{
  QThread::sleep(secs);
}

void PhononPlayer::Sleeper::msleep(unsigned long msecs)
{
  QThread::msleep(msecs);
}

void PhononPlayer::Sleeper::usleep(unsigned long usecs)
{
  QThread::usleep(usecs);
}