/*
 * Simple sound playback using ALSA API and libasound.
 *
 * Compile:
 * $ cc -o play sound_playback.c -lasound
 * 
 * Usage:
 * $ ./play <sample_rate> <channels> <seconds> < <file>
 * 
 * Examples:
 * $ ./play 44100 2 5 < /dev/urandom
 * $ ./play 22050 1 8 < /path/to/file.wav
 *
 * Copyright (C) 2009 Alessandro Ghedini <al3xbio@gmail.com>
 * --------------------------------------------------------------
 * "THE BEER-WARE LICENSE" (Revision 42):
 * Alessandro Ghedini wrote this file. As long as you retain this
 * notice you can do whatever you want with this stuff. If we
 * meet some day, and you think this stuff is worth it, you can
 * buy me a beer in return.
 * --------------------------------------------------------------
 */

#include <alsa/asoundlib.h>
#include <stdio.h>

#include <fstream>

#include "src/WavFile.h"

#include <future>
#include <thread>
#include <chrono>
#include <queue>

#define PCM_DEVICE "default"

std::deque<std::string> queue;
std::mutex queueMutex;

static std::string getInput()
{

  std::cout << "starting input thread" << std::endl;
  while (true)
  {
    std::string result;
    std::getline(std::cin, result);
    {
      std::lock_guard<std::mutex> guard(queueMutex);
      std::cout << "adding to queue" << std::endl;
      queue.push_back(result);
    }
  }
}

int main(int argc, char **argv)
{
  std::ifstream wavFileStream("test.wav", std::ios::binary);
  WavFile wav(wavFileStream);
  wavFileStream.close();
  std::cout << "Wav samples " << wav.size() << std::endl;

  unsigned int pcm, tmp, dir;
  snd_pcm_t *pcm_handle;
  snd_pcm_hw_params_t *params;
  snd_pcm_uframes_t frames;
  char *buff;
  int buff_size, loops;

  /* Open the PCM device in playback mode */
  if (pcm = snd_pcm_open(&pcm_handle, PCM_DEVICE,
                         SND_PCM_STREAM_PLAYBACK, 0) < 0)
    printf("ERROR: Can't open \"%s\" PCM device. %s\n",
           PCM_DEVICE, snd_strerror(pcm));

  /* Allocate parameters object and fill it with default values*/
  snd_pcm_hw_params_alloca(&params);

  snd_pcm_hw_params_any(pcm_handle, params);

  /* Set parameters */
  if (pcm = snd_pcm_hw_params_set_access(pcm_handle, params,
                                         SND_PCM_ACCESS_RW_INTERLEAVED) < 0)
    printf("ERROR: Can't set interleaved mode. %s\n", snd_strerror(pcm));

  if (pcm = snd_pcm_hw_params_set_format(pcm_handle, params,
                                         SND_PCM_FORMAT_S16_LE) < 0)
    printf("ERROR: Can't set format. %s\n", snd_strerror(pcm));

  if (pcm = snd_pcm_hw_params_set_channels(pcm_handle, params, wav.channels()) < 0)
    printf("ERROR: Can't set channels number. %s\n", snd_strerror(pcm));

  snd_pcm_hw_params_set_buffer_size(pcm_handle, params, 2 * 2048);

  unsigned int rate = wav.sampleRate();
  if (pcm = snd_pcm_hw_params_set_rate_near(pcm_handle, params, &rate, 0) < 0)
    printf("ERROR: Can't set rate. %s\n", snd_strerror(pcm));

  /* Write parameters */
  if (pcm = snd_pcm_hw_params(pcm_handle, params) < 0)
    printf("ERROR: Can't set harware parameters. %s\n", snd_strerror(pcm));

  /* Resume information */
  printf("PCM name: '%s'\n", snd_pcm_name(pcm_handle));

  printf("PCM state: %s\n", snd_pcm_state_name(snd_pcm_state(pcm_handle)));

  snd_pcm_hw_params_get_channels(params, &tmp);

  printf("channels: %i ", tmp);

  if (tmp == 1)
    printf("(mono)\n");
  else if (tmp == 2)
    printf("(stereo)\n");

  snd_pcm_hw_params_get_rate(params, &tmp, 0);
  printf("rate: %d bps\n", tmp);

  /* Allocate buffer to hold single period */
  snd_pcm_hw_params_get_period_size(params, &frames, 0);

  buff_size = frames * wav.channels() * 2 /* 2 -> sample size */;
  buff = (char *)malloc(buff_size);
  std::cout << "Buffer size " << buff_size << " frames " << frames << std::endl;

  snd_pcm_hw_params_get_period_time(params, &tmp, NULL);

  std::thread inputThread(getInput);
  bool playing = true;

  size_t wavFilePosition = 0;
  while (wavFilePosition < wav.size())
  {
    {
      std::lock_guard<std::mutex> guard(queueMutex);
      if (queue.size() > 0)
      {
        queue.pop_back();
        std::cout << "Toggling" << std::endl;
        //snd_pcm_drain(pcm_handle);
        std::cout << "Done" << std::endl;
        playing = !playing;
        if (playing)
        {
          std::cout << "continuing at " << wavFilePosition << std::endl;
          snd_pcm_pause(pcm_handle, 0);
          //snd_pcm_prepare(pcm_handle);
        }
        else
          snd_pcm_pause(pcm_handle, 1);
      }
    }

    if (!playing)
      continue;
    size_t dataToWrite = std::min(size_t(buff_size), wav.size() - wavFilePosition);
    int framesToWrite = dataToWrite / wav.channels() / 2;
    if (pcm = snd_pcm_writei(pcm_handle, wav[wavFilePosition], framesToWrite) == -EPIPE)
    {
      std::cout << "XRUN at wav position " << wavFilePosition << std::endl;
      snd_pcm_prepare(pcm_handle);
    }
    else if (pcm < 0)
      printf("ERROR. Can't write to PCM device. %s\n", snd_strerror(pcm));

    wavFilePosition += dataToWrite;
  }

  std::cout << "done filling buffer" << std::endl;
  snd_pcm_drain(pcm_handle);
  snd_pcm_close(pcm_handle);
  free(buff);

  return 0;
}