#include <cassert>
#include <stack>
#include <iostream>

#include "testaudio.h"

#include <dtAudio/audiomanager.h>
#include <dtAudio/sound.h>
#include <dtAudio/soundeffectbinder.h>
#include <dtCore/camera.h>
#include <dtCore/effectmanager.h>
#include <dtCore/object.h>
#include <dtCore/orbitmotionmodel.h>
#include <dtCore/particlesystem.h>
#include <dtCore/transform.h>
#include <osgGA/GUIEventAdapter>

// name spaces
using namespace   dtCore;
using namespace   dtABC;
using namespace   dtAudio;
using namespace   dtUtil;

IMPLEMENT_MANAGEMENT_LAYER( TestAudioApp )

// static member variables
unsigned int   TestAudioApp::kNumSoundFiles(4L);
const char*    TestAudioApp::kSoundFile[] =
               {
                  "sounds/pow.wav",
                  "sounds/bang.wav",
                  "sounds/helo.wav",
                  "sounds/carhorn.wav"
               };
const char*    TestAudioApp::kGfxFile[kNumGfx] =
               {
                  "models/flatdirt.ive",
                  "models/brdm.ive",
                  "models/uh-1n.ive"
               };
const char*    TestAudioApp::kFxFile[kNumFx] =
               {
                  "effects/explosion.osg",
                  "effects/smoke.osg"
               };

const char*    TestAudioApp::kFxDetonationType[kNumFx] =
               {
                  "HighExplosiveDetonation",
                  "SmokeDetonation"
               };

TestAudioApp::TestAudioApp(const std::string& configFilename /*= "config.xml"*/)
   : Application(configFilename)
   , mSndGain(1.0f)
   , mSndPitch(1.0f)
   , mLooping(false)
   , mMic(NULL)
   , mOribitMotionModel(NULL)
   , mSmokeCountA(0L)
   , mSmokeCountC(0L)
   , mRecorder(new SoundRecorder())
{
   AddSender(&dtCore::System::GetInstance());

   AudioManager::Instantiate();

   for (unsigned int ii(0L); ii < kNumSoundFiles; ii++)
   {
      AudioManager::GetInstance().LoadFile(kSoundFile[ii]);
   }

   mMic = AudioManager::GetListener();
   assert(mMic);

   SetUpVisuals();

   Camera* cam = GetCamera();
   assert(cam);

   cam->AddChild(mMic);

   Transform transform(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
   mMic->SetTransform(transform, Transformable::REL_CS);

   mSFXBinder  = new dtAudio::SoundEffectBinder;
   assert(mSFXBinder.get());

   if (mFXMgr.get())
   {
      mSFXBinder->Initialize(mFXMgr.get());
      mSFXBinder->AddEffectTypeMapping(kFxDetonationType[EXPLODE], kSoundFile[1L]);
      mSFXBinder->AddEffectTypeRange(kFxDetonationType[EXPLODE], 35.0f);
   }

   CreateHelpLabel();
}



TestAudioApp::~TestAudioApp()
{
   if (mSFXBinder.get())
   {
      mSFXBinder->RemoveEffectTypeRange(kFxDetonationType[EXPLODE]);
      mSFXBinder->RemoveEffectTypeMapping(kFxDetonationType[EXPLODE]);
      mSFXBinder->Shutdown();
      mSFXBinder = NULL;
   }

   StopAllSounds();
   FreeAllStoppedSounds(true);

   for (unsigned int ii(0L); ii < kNumSoundFiles; ii++)
   {
      AudioManager::GetInstance().UnloadFile(kSoundFile[ii]);
   }

   AudioManager::Destroy();

   RemoveSender(&dtCore::System::GetInstance());
}



void TestAudioApp::PreFrame(const double deltaFrameTime)
{
   Application::PreFrame(deltaFrameTime);
   FlushQueuedSounds();
}



void
TestAudioApp::Frame(const double deltaFrameTime)
{
   Application::Frame(deltaFrameTime);
}



void
TestAudioApp::PostFrame(const double deltaFrameTime)
{
   Application::PostFrame(deltaFrameTime);
   FreeAllStoppedSounds();

   MoveTheObject(TRUCK);
   MoveTheObject(HELO);
}


bool TestAudioApp::KeyPressed(const Keyboard* keyboard, int key)
{
   bool verdict = dtABC::Application::KeyPressed(keyboard, key);
   if (verdict == true)
   {
      return verdict;
   }
   osg::Vec3 pos(0.0f, 0.0f, 0.0f);

   switch (key)
   {
      case 'a':
         LoadPlaySound(kSoundFile[0L]);
         verdict = true;
         break;

      case 's':
         mFXMgr->AddDetonation(pos, kFxDetonationType[EXPLODE]);
         verdict = true;
         break;

      case 'd':
         LoadPlaySound(kSoundFile[2L], TRUCK);
         verdict = true;
         break;

      case 'f':
         LoadPlaySound(kSoundFile[3L], HELO);
         verdict = true;
         break;

      case '0':
         ChangeSoundGain(0.0f / 9.0f);
         verdict = true;
         break;

      case '1':
         ChangeSoundGain(1.0f / 9.0f);
         verdict = true;
         break;

      case '2':
         ChangeSoundGain(2.0f / 9.0f);
         verdict = true;
         break;

      case '3':
         ChangeSoundGain(3.0f / 9.0f);
         verdict = true;
         break;

      case '4':
         ChangeSoundGain(4.0f / 9.0f);
         verdict = true;
         break;

      case '5':
         ChangeSoundGain(5.0f / 9.0f);
         verdict = true;
         break;

      case '6':
         ChangeSoundGain(6.0f / 9.0f);
         verdict = true;
         break;

      case '7':
         ChangeSoundGain(7.0f / 9.0f);
         verdict = true;
         break;

      case '8':
         ChangeSoundGain(8.0f / 9.0f);
         verdict = true;
         break;

      case '9':
         ChangeSoundGain(9.0f / 9.0f);
         verdict = true;
         break;

      case '-':
      case osgGA::GUIEventAdapter::KEY_KP_Subtract:
         ChangeSoundPitch(0.9f);
         verdict = true;
         break;

      case '=':
      case osgGA::GUIEventAdapter::KEY_KP_Add:
         ChangeSoundPitch(1.1f);
         verdict = true;
         break;

      case 'l':
         ToggleSoundLooping();
         verdict = true;
         break;

      case osgGA::GUIEventAdapter::KEY_Pause:
         PauseAllSounds();
         verdict = true;
         break;

      case osgGA::GUIEventAdapter::KEY_Return:
      case osgGA::GUIEventAdapter::KEY_KP_Enter:
         RewindAllSounds();
         verdict = true;
         break;

      case ' ':
         StopAllSounds();
         verdict = true;
         break;

      case 'r':
         {
            if (mRecorder->GetState() == SoundRecorder::Recording)
            {
               StopRecording();
            }
            else
            {
               StartRecording();
            }
         verdict = true;
         } break;

      case 'y':
         {
            std::string sfile("soundrecord.xml");
            LOG_INFO("Saving to file: "+ sfile)
            mRecorder->SaveFile(sfile);
            LOG_INFO("...Done saving file: " + sfile)
            verdict = true;
         } break;

      case osgGA::GUIEventAdapter::KEY_F1:
      {
         mLabel->SetActive(!mLabel->GetActive());
         break;
      }
      default:
         break;
   }

   return verdict;
}

void TestAudioApp::LoadPlaySound(const char* fname, unsigned int box /*= 0L*/)
{
   assert( fname );

   Log::GetInstance().LogMessage(Log::LOG_ALWAYS, __FUNCTION__,
      " LoadPlaySound( %s )", fname);

   Sound* snd = AudioManager::GetInstance().NewSound();
   assert(snd);

   snd->LoadFile(fname);
   snd->SetGain(mSndGain);
   snd->SetPitch(mSndPitch);
   snd->SetLooping(mLooping);
   if (box)
   {
      snd->SetRolloffFactor(0.2f);
   }
   snd->Play();
   mQueued.push(snd);

   if (box)
   {
      Object* obj   = mGfxObj[box].get();
      assert(obj);

      obj->AddChild(snd);

      Transform transform(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
      snd->SetTransform(transform, Transformable::REL_CS);

      snd->SetPlayCallback(MakeSmoke, this);
      snd->SetStopCallback(StopSmoke, this);
   }
}

void TestAudioApp::StopAllSounds(void)
{
   Sound* snd(NULL);
   SND_ITR iter;
   for (iter = mActive.begin(); iter != mActive.end(); iter++)
   {
      snd = *iter;
      if (snd == NULL)
      {
         continue;
      }

      if (!snd->IsStopped())
      {
         snd->Stop();

         Log::GetInstance().LogMessage(Log::LOG_ALWAYS, __FUNCTION__,
            " StopAllSounds( %s )", snd->GetFilename() );
      }
   }
}

void
TestAudioApp::FreeAllStoppedSounds(bool forced /*= false*/)
{
   SND_ITR              iter;
   std::stack<SND_ITR>  stk;
   Sound*               snd(NULL);

   for (iter = mActive.begin(); iter != mActive.end(); iter++)
   {
      snd = *iter;
      if (snd == NULL)
      {
         continue;
      }

      if (snd->IsStopped() || forced)
      {
         stk.push(iter);
      }
   }

   while (stk.size())
   {
      iter = stk.top();
      stk.pop();

      snd  = *iter;
      if (snd == NULL)
      {
         continue;
      }

      Log::GetInstance().LogMessage(Log::LOG_ALWAYS, __FUNCTION__,
         " FreeAllStoppedSounds( %s )", snd->GetFilename());

      AudioManager::GetInstance().FreeSound(snd);
      mActive.erase(iter);
   }
}



void
TestAudioApp::FlushQueuedSounds()
{
   Sound* snd(NULL);

   while (mQueued.size())
   {
      snd = mQueued.front();
      if (snd == NULL)
      {
         mQueued.pop();
         continue;
      }

      if (!snd->IsStopped())
      {
         mQueued.pop();
         mActive.push_back(snd);
         continue;
      }

      break;
   }
}



void
TestAudioApp::ChangeSoundGain(float gain)
{
   mSndGain = gain;

   Log::GetInstance().LogMessage(Log::LOG_ALWAYS, __FUNCTION__,
      " ChangeSoundGain( %1.1f )", mSndGain );

   Sound* snd(NULL);
   SND_ITR iter;

   for (iter = mActive.begin(); iter != mActive.end(); iter++)
   {
      snd = *iter;
      assert(snd);

      snd->SetGain(mSndGain);
   }
}



void
TestAudioApp::ChangeSoundPitch(float pitch)
{
   mSndPitch *= pitch;

   Log::GetInstance().LogMessage(Log::LOG_ALWAYS, __FUNCTION__,
      " ChangeSoundPitch( %1.4f )", mSndPitch);

   Sound*  snd(NULL);
   SND_ITR iter;

   for (iter = mActive.begin(); iter != mActive.end(); iter++)
   {
      snd = *iter;
      assert(snd);

      snd->SetPitch(mSndPitch);
   }
}



void
TestAudioApp::ToggleSoundLooping()
{
   mLooping = !mLooping;

   Log::GetInstance().LogMessage(Log::LOG_ALWAYS, __FUNCTION__,
      " ToggleSoundLooping( %d )", (mLooping));

   Sound*  snd(NULL);
   SND_ITR iter;

   for (iter = mActive.begin(); iter != mActive.end(); iter++)
   {
      snd = *iter;
      assert(snd);

      if(! snd->IsStopped())
      {
         snd->SetLooping(mLooping);
      }
   }
}


void
TestAudioApp::PauseAllSounds()
{
   Sound*  snd(NULL);
   SND_ITR iter;
   for (iter = mActive.begin(); iter != mActive.end(); iter++)
   {
      snd = *iter;
      if (snd == NULL)
      {
         continue;
      }

      snd->Pause();

      if (snd->IsPlaying())
      {
         Log::GetInstance().LogMessage(Log::LOG_ALWAYS, __FUNCTION__,
            " PauseAllSounds( %s ) paused", snd->GetFilename());
      }
      else  if (snd->IsPaused())
      {
         Log::GetInstance().LogMessage(Log::LOG_ALWAYS, __FUNCTION__,
            " PauseAllSounds( %s ) un-paused", snd->GetFilename());
      }
   }
}


void
TestAudioApp::RewindAllSounds()
{
   Sound*  snd(NULL);
   SND_ITR iter;
   for (iter = mActive.begin(); iter != mActive.end(); iter++)
   {
      snd = *iter;
      if (snd == NULL)
      {
         continue;
      }

      snd->Rewind();

      Log::GetInstance().LogMessage(Log::LOG_ALWAYS, __FUNCTION__,
         " RewindAllSounds( %s )", snd->GetFilename());
   }
}


void
TestAudioApp::SetUpVisuals()
{
   for (unsigned int ii(0L); ii < kNumGfx; ii++)
   {
      mGfxObj[ii] = LoadGfxFile(kGfxFile[ii]).get();
      assert(mGfxObj[ii].get());
   }

   mFXMgr = LoadFxFile( kFxFile[EXPLODE] ).get();
   assert(mFXMgr.get());

   mPSysA = LoadPSFile( kFxFile[SMOKE] ).get();
   assert(mPSysA.get());

   mGfxObj[TRUCK]->AddChild(mPSysA.get());

   mPSysC = LoadPSFile(kFxFile[SMOKE]).get();
   assert(mPSysC.get());

   mGfxObj[HELO]->AddChild(mPSysC.get());

   InitInputDevices();
   SetUpCamera();
}



dtCore::RefPtr<Object>
TestAudioApp::LoadGfxFile(const char* fname)
{
   if (fname == NULL)
   {
      // no file name, bail...
      return NULL;
   }

   std::string filename = dtCore::FindFileInPathList(fname);
   if (filename == "")
   {
      // still no file name, bail...
      Log::GetInstance().LogMessage( Log::LOG_WARNING,__FUNCTION__,
         "AudioManager: can't load file %s", fname );
      return NULL;
   }


   dtCore::RefPtr<Object> fileobj  = new Object;
   assert(fileobj.valid());


   if (fileobj->LoadFile(filename) == NULL)
   {
      Log::GetInstance().LogMessage(Log::LOG_WARNING,__FUNCTION__,
         "can't load gfx file '%s'", filename.c_str());
      fileobj = 0;
      return 0;
   }

   if (std::string(fname) == kGfxFile[1])
   {
      //rotate BRDM 90 degrees
      Transform trans = Transform(0.0f, 0.0f, 0.0f, 90.0f, 0.0f, 0.0f);
      fileobj->SetTransform(trans);
   }

   // add the object to the scene
   AddDrawable(fileobj.get());

   dtCore::RefPtr<osg::Node> filenode = fileobj->GetOSGNode();
   assert(filenode.valid());

   filenode->setNodeMask(0xFFFFFFFF);
   return fileobj;
}



dtCore::RefPtr<EffectManager>
TestAudioApp::LoadFxFile(const char* fname)
{
   dtCore::RefPtr<EffectManager> effectManager = new EffectManager;
   assert(effectManager.valid());

   effectManager->AddDetonationTypeMapping(
      kFxDetonationType[EXPLODE],
      fname
   );

   AddDrawable(effectManager.get());

   return effectManager;
}



dtCore::RefPtr<ParticleSystem>
TestAudioApp::LoadPSFile(const char* fname)
{
   dtCore::RefPtr<ParticleSystem> particlesystem = new ParticleSystem;

   assert(particlesystem.valid());

   particlesystem->LoadFile(fname, false);

   particlesystem->SetEnabled(false);

   return particlesystem;
}



void
TestAudioApp::InitInputDevices()
{
   mOribitMotionModel = new OrbitMotionModel(GetKeyboard(), GetMouse());
   mOribitMotionModel->SetTarget(GetCamera());
   mOribitMotionModel->SetEnabled(true);
}



void
TestAudioApp::SetUpCamera()
{
   osg::Vec3   pos    (0.0f, -150.0f, 30.0f);
   osg::Vec3   lookat (0.f,     0.f,   0.f);
   osg::Vec3   up     (0.f,     0.f,   1.f);

   Transform   xform;
   xform.Set(pos, lookat, up);

   float dist((lookat - pos).length());

   Camera* cam(GetCamera());
   assert(cam);

   cam->SetTransform(xform);

   mOribitMotionModel->SetDistance(dist);
}



void
TestAudioApp::MoveTheObject(unsigned int obj)
{
   // figure out which vehicle gets what velocity
   static   long              X(0L);
   static   const double      A(1.0f/2500.0f);
   static   const double      C(1.0f/2500.0f);
            double            D((obj==HELO)? C: A);
            double            P(sin( double(X++) * D ));
            double            V(cos( double(X++) * D ));
            unsigned int      I((obj==TRUCK)? 1L: 0L);
            Transform xform;
            osg::Vec3         pos( 0.0f, 0.0f, 0.0f );
            osg::Vec3         vel( 0.0f, 0.0f, 0.0f );
            OBJ_PTR           gfx(mGfxObj[obj]);

   // move the vehicle
   assert(gfx.get());

   gfx->GetTransform(xform);
   xform.GetTranslation(pos);

   pos[I]   = static_cast<double>(P * 50.0f);

   xform.SetTranslation(pos);
   gfx->SetTransform(xform);

   // don't set velocity for TRUCK
   if (obj == TRUCK)
   {
      return;
   }

   // set the velocity for all children of the vehicle
   vel[I] = static_cast<ALfloat>(V * 50.0f);
   Sound* snd(NULL);
   for (unsigned int ii(0L); ii < gfx->GetNumChildren(); ii++)
   {
      snd = dynamic_cast<Sound*>(gfx->GetChild(ii));
      if (snd == NULL)
      {
         continue;
      }

      snd->SetVelocity(vel);
   }
}



void
TestAudioApp::MakeSmoke(dtAudio::Sound* sound, void* param)
{
   assert(sound);
   assert(param);

   sound->SetPlayCallback(NULL, NULL);

   std::string    fname = sound->GetFilename();
   TestAudioApp*  app   = static_cast<TestAudioApp*>(param);

   if (fname == app->kSoundFile[2L])
   {
      assert(app->mPSysA.get());

      app->mSmokeCountA++;

      app->mPSysA->SetEnabled(true);
      return;
   }

   if (fname == app->kSoundFile[3L])
   {
      assert(app->mPSysC.get());

      app->mSmokeCountC++;

      app->mPSysC->SetEnabled(true);
      return;
   }
}



void
TestAudioApp::StopSmoke(dtAudio::Sound* sound, void* param)
{
   assert(sound);
   assert(param);

   sound->SetStopCallback(NULL, NULL);

   std::string    fname = sound->GetFilename();
   TestAudioApp*  app   = static_cast<TestAudioApp*>(param);

   if (fname == app->kSoundFile[2L])
   {
      assert(app->mPSysA.get());

      app->mSmokeCountA--;

      if (app->mSmokeCountA)
      {
         return;
      }

      app->mPSysA->SetEnabled(false);
   }

   if (fname == app->kSoundFile[3L])
   {
      assert(app->mPSysC.get());

      app->mSmokeCountC--;

      if (app->mSmokeCountC)
      {
         return;
      }

      app->mPSysC->SetEnabled(false);
   }
}

void TestAudioApp::StartRecording()
{
   LOG_INFO("Starting Recording.")
   mRecorder->Record();
}

void TestAudioApp::StopRecording()
{
   LOG_INFO("Stopping Recording.")
   mRecorder->Stop();
}

void TestAudioApp::CreateHelpLabel()
{
   mLabel = new LabelActor();
   osg::Vec2 testSize(21.0f, 11.0f);
   mLabel->SetBackSize(testSize);
   mLabel->SetFontSize(0.8f);
   mLabel->SetTextAlignment(LabelActor::AlignmentEnum::LEFT_CENTER);
   mLabel->SetText(CreateHelpLabelText());
   mLabel->SetEnableDepthTesting(false);
   mLabel->SetEnableLighting(false);

   GetCamera()->AddChild(mLabel.get());
   Transform labelOffset(-17.0f, 50.0f, 7.5f, 0.0f, 90.0f, 0.0f);
   mLabel->SetTransform(labelOffset, Transformable::REL_CS);
   AddDrawable(GetCamera());
}

std::string TestAudioApp::CreateHelpLabelText()
{
   std::string testString("");
   testString += "F1: Toggle Help Screen\n";
   testString += "\n";
   testString += "0-9: Change volume\n";
   testString += "+/-: Increase/Decrease pitch\n";
   testString += "a: Play gunfire sound\n";
   testString += "s: Play explosion sound\n";
   testString += "d: Play helicopter hum sound\n";
   testString += "f: Play vehicle horn sound\n";
   testString += "l: Set sounds to loop\n";
   testString += "r: Record sounds\n";
   testString += "y: Save soundrecord.xml\n";
   testString += "Space: Stops all sounds\n";
   testString += "Pause: Pause all sounds\n";

   return testString;
}

int main()
{
   std::string dataPath = dtCore::GetDeltaDataPathList();
   dtCore::SetDataFilePathList(dataPath + ";" +
      dtCore::GetDeltaRootPath() + "/examples/data" + ";");

   RefPtr<TestAudioApp> app = new TestAudioApp("config.xml");

   std::cout << "Key you can push: \n\n";
   std::cout << "0-9 set the gain (volume) of sounds.\n";
   std::cout << "+ and - increase/decrease pitch.\n";
   std::cout << "A plays a 'pow' sound.\n";
   std::cout << "S plays a 'boom' sound.\n";
   std::cout << "D plays a helicopter hum that is attached to the helicopter.\n";
   std::cout << "F plays a horn sounds that is attached to the vehicle.\n";
   std::cout << "L sets sounds to looping.\n";
   std::cout << "Spacebar stops all sounds.\n";
   std::cout << "Esc exits application.\n";

   app->Run();

   return 0;
}