#ifndef AUDIO_H
#define AUDIO_H

#include "audiointerface.h"
#include <QObject>
#include <QList>
#include <QFile>
#include <QTimer>

namespace Sound
{
  enum Type
  {
    Intro = 0,
    WakaWaka,
    EatingFruit,
    EatingGhost,
    Die,
    Ambient
  };

  const unsigned int length[] = {
    4310, 2090, 570, 570, 1720, 1990
  };
};

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

class NoopAudioPlayer
  : public AudioPlayer
{
  Q_OBJECT
  friend class AudioManager;

public:
  virtual bool isWorking() const;
  virtual void setMuted(bool mute = true);
  virtual bool isMuted() const;
  virtual void play();
  virtual bool isPlaying();
  virtual void pause();
  virtual bool isPaused();
  virtual void stop();
  virtual bool isStopped();
  virtual void clear();
  virtual void clearQueue();
  virtual void setPrefinishMark(qint32 msecToEnd);
  virtual void seek(qint64 time);

protected:
  NoopAudioPlayer(QObject *parent = 0);
  virtual void setWorking(bool working = true);
  virtual void test(QFile *sound, unsigned int length);
  virtual void play(QFile *sound, unsigned int length);
  virtual void setSource(QFile *sound, unsigned int length);
  virtual void enqueue(QFile *sound, unsigned int length);

protected slots:
  virtual void prefinishMarkReached_ex(qint32 mark);

protected:
  bool m_working;
  bool m_muted;
  bool m_playing;
  bool m_paused;
};

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

class FakeAudioPlayer
  : public NoopAudioPlayer
{
  Q_OBJECT
  friend class AudioManager;

protected:
  FakeAudioPlayer(QObject *parent = 0);
  virtual void play(QFile *sound, unsigned int length);

protected slots:
  void finished_ex();

protected:
  QTimer m_timer;
};

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

class GaplessAudioPlayer
  : public QObject
{
  Q_OBJECT

public:
  GaplessAudioPlayer(Sound::Type sound, qint32 mark, QObject *parent = 0);
  bool isWorking() const;
  void setMuted(bool mute = true);
  bool isMuted() const;
  void play();
  void pause();

protected slots:
  void startPlayer1();
  void startPlayer2();

protected:
  bool m_working;
  bool m_paused;
  Sound::Type m_sound;
  AudioPlayer *m_player1;
  AudioPlayer *m_player2;
};

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

class AudioManager
  : public QObject
{
  Q_OBJECT
  friend class GaplessAudioPlayer;

public:
  AudioManager();
  static AudioManager *self();
  static bool isWorking();
  void setMuted(bool mute = true);
  bool isMuted() const;
  void pause();
  void stop();
  void clear();
  void clearQueue() const;

  AudioPlayer *audioPlayer();
  void registerAudioPlayer(AudioPlayer *player);
  void unregisterAudioPlayer(AudioPlayer *player);
  void play(Sound::Type sound, AudioPlayer *player = NULL);
  void setSource(Sound::Type sound, AudioPlayer *player = NULL);
  void enqueue(Sound::Type sound, AudioPlayer *player = NULL);

signals:
  void mutedChanged(bool muted);

private slots:
  void unregisterAudioPlayer_helper(QObject *player);

protected:
  void preload();
  bool tryLoadAudioPlugin(const QString &libraryname);
  AudioPlayer *createAudioPlayer(QObject *parent = 0);
  QFile *sound(Sound::Type sound);
  unsigned int length(Sound::Type sound);

private:
  bool m_muted;
  static bool m_working;
  static AudioManager *m_instance;
  QList<QFile *> m_sounds;
  QList<AudioPlayer *> m_players;
  AudioPlayerFactory *m_factory;
};

#endif // AUDIO_H