// TestAI.cpp : defines the implementation of the application
#if defined (WIN32) || defined (_WIN32) || defined (__WIN32__)
   #pragma warning(push)
   #pragma warning(disable : 4005)
#endif

#include "testai.h"
#include <dtCore/camera.h>
#include <dtCore/globals.h>
#include <dtCore/transform.h>
#include <dtDAL/map.h>
#include <dtDAL/project.h>
#include <dtDAL/exceptionenum.h>
#include <dtUtil/macros.h>

#include <dtAI/waypoint.h>
#include <dtAI/waypointmanager.h>

#include <dtUtil/mathdefines.h>
#include <dtUtil/log.h>
#include <dtUtil/fileutils.h>
#include <osg/MatrixTransform>

#if defined (WIN32) || defined (_WIN32) || defined (__WIN32__)
   #pragma warning(pop)
#endif

using namespace dtCore;
using namespace dtABC;
using namespace dtDAL;
using namespace dtAI;

TestAI::TestAI(const std::string& pMapFilename, const std::string& configFilename)
   : Application(configFilename)
   , mMapFilename(pMapFilename)
   , mCharacter(0)
{
   // Generating a default config file if there isn't one already
   if (!dtUtil::FileUtils::GetInstance().FileExists(configFilename))
   {
      GenerateDefaultConfigFile();
   }
}

TestAI::~TestAI()
{

}

void TestAI::Config()
{
   Application::Config();

   // initialize the Waypoint Helper
   WaypointManager::GetInstance();
   GetScene()->AddDrawable(&WaypointManager::GetInstance());

   // set the waypoint manager to not (redundantly) delete waypoints
   dtAI::WaypointManager::GetInstance().SetDeleteOnClear(false);

   LoadDemoMap(mMapFilename);

   // turn on viewing of waypoints
   WaypointManager::GetInstance().SetDrawWaypoints(true);

   // by default we wont draw the navmesh
   mDrawNavMesh = false;
   WaypointManager::GetInstance().SetDrawNavMesh(mDrawNavMesh, true);

   // set camera offset
   dtCore::Transform trans;
   trans.SetTranslation(-1.0f, 5.5f, 1.5f);
   trans.SetRotation(180.0f, -2.0f, 0.0f);
   GetCamera()->SetTransform(trans);

   // this is needed so OSG knows which camera can generate events
   GetCamera()->GetOSGCamera()->setAllowEventFocus(true);

   // create overhead camera and disable it by default
   dtCore::View *overheadView = new dtCore::View("overhead view");
   overheadView->SetScene( GetScene() );
   AddView( *overheadView );

   mOverheadCamera = new dtCore::Camera();
   mOverheadCamera->SetWindow(GetWindow());
   mOverheadCamera->SetEnabled(false);
   overheadView->SetCamera( mOverheadCamera.get() );

   // this is needed so OSG knows which camera can generate events
   mOverheadCamera->GetOSGCamera()->setAllowEventFocus(false);

   // set overhead camera offset
   trans.SetTranslation(0.0f, -5.0f, 70.0f);
   trans.SetRotation(0.0f, -90.f, 0.0f);
   trans.Get(mCameraOffset);
   mOverheadCamera->GetMatrixNode()->setMatrix(mCameraOffset);

   // get the first waypoint to spawn the character at
   const WaypointManager::WaypointMap& pContainer = WaypointManager::GetInstance().GetWaypoints();
   if (pContainer.empty())
   {
      LOG_ERROR("Map '" + mMapFilename + "' does not have any valid waypoints");
      exit(1);
   }
   WaypointManager::WaypointMap::const_iterator iter = pContainer.begin();
   const Waypoint* pWaypoint = (*iter).second;

   // spawn our character
   mCharacter = new dtAI::AICharacter(GetScene(), pWaypoint, "demoMap/SkeletalMeshes/marine.xml", 3);

   // add the two Cameras as children so they get moved along with the character
   mCharacter->GetCharacter()->AddChild( GetCamera() );
   mCharacter->GetCharacter()->AddChild( mOverheadCamera.get() );

   GoToWaypoint(1);

   // seed the random generator
   srand(4);

   CreateHelpLabel();
}

bool TestAI::KeyPressed(const dtCore::Keyboard* keyboard, int key)
{
   switch (key)
   {
   case ' ':
      if (GetCamera()->GetEnabled())
      {
         GetCamera()->SetEnabled(false);
         mOverheadCamera->SetEnabled(true);
         if (mLabel->GetActive())
         {
            GetCamera()->RemoveChild(mLabel.get());
            mOverheadCamera->AddChild(mLabel.get());
         }
      }
      else
      {
         mOverheadCamera->SetEnabled(false);
         GetCamera()->SetEnabled(true);
         if (mLabel->GetActive())
         {
            mOverheadCamera->RemoveChild(mLabel.get());
            GetCamera()->AddChild(mLabel.get());
         }
      }
      return true;

   case 'n':
      mDrawNavMesh = !mDrawNavMesh;
      WaypointManager::GetInstance().SetDrawNavMesh(mDrawNavMesh, true);
      return true;

   case 'a':
      if (mOverheadCamera->GetEnabled())
      {
         mCameraOffset(3,2) -= 1.0f;
         mCameraOffset(3,1) -= 15.5f / 100.0f;
         mOverheadCamera->GetMatrixNode()->setMatrix(mCameraOffset);
      }
      return true;

   case 'z':
      if (mOverheadCamera->GetEnabled())
      {
         mCameraOffset(3,2) += 1.0f;
         mCameraOffset(3,1) += 15.5f / 100.0f;
         mOverheadCamera->GetMatrixNode()->setMatrix(mCameraOffset);
      }
      return true;

   case osgGA::GUIEventAdapter::KEY_Escape:
      Quit();
      return true;

   case osgGA::GUIEventAdapter::KEY_F1:
      mLabel->SetActive(!mLabel->GetActive());
      if (mLabel->GetActive())
      {
         if (GetCamera()->GetEnabled() &&
            GetCamera()->GetChildIndex(mLabel.get()) == GetCamera()->GetNumChildren())
         {
            mOverheadCamera->RemoveChild(mLabel.get());
            GetCamera()->AddChild(mLabel.get());
         }
         else if (mOverheadCamera->GetEnabled() &&
            mOverheadCamera->GetChildIndex(mLabel.get()) == mOverheadCamera->GetNumChildren())
         {
            GetCamera()->RemoveChild(mLabel.get());
            mOverheadCamera->AddChild(mLabel.get());
         }
      }
      return true;

   default:
      break;
   }
   return false;
}

void TestAI::PreFrame( const double deltaFrameTime )
{
   mCharacter->Update(float(deltaFrameTime));

   if (mCharacter->GetCurrentWaypoint() == mCurrentWaypoint)
   {
      // send the character to a random waypoint
      WaypointManager::WaypointMap::size_type pNumWaypoints = WaypointManager::GetInstance().GetWaypoints().size() - 1;
      unsigned pWaypointNum = dtUtil::RandRange(0U, unsigned(pNumWaypoints));
      GoToWaypoint(pWaypointNum);
   }
}

void TestAI::LoadDemoMap(const std::string& pStr)
{
   try
   {
      std::string contextName =  dtCore::GetDeltaRootPath()+"/examples/data/demoMap";
      Project::GetInstance().SetContext(contextName);
      std::string pContext = Project::GetInstance().GetContext();
      Map &myMap = Project::GetInstance().GetMap(pStr);

      // Since we are in an Application we can simply call...
      LoadMap(myMap);
   }
   catch (const dtUtil::Exception&)
   {
      LOG_ERROR("ERROR: Map Not Found");
   }
}

bool TestAI::GoToWaypoint(int pWaypointNum)
{
   // loop through the waypoints and send our character to the one
   // whose index is pWaypointNum in the WaypointMap contained within WaypointManager
   const WaypointManager::WaypointMap& pWaypoints = WaypointManager::GetInstance().GetWaypoints();
   WaypointManager::WaypointMap::const_iterator iter = pWaypoints.begin();
   WaypointManager::WaypointMap::const_iterator endOfMap = pWaypoints.end();

   bool pHasPath = false;

   for (int i = 0; iter != endOfMap; ++i, ++iter)
   {
      if (i == pWaypointNum)
      {
         pHasPath = mCharacter->FindPathAndGoToWaypoint((*iter).second);
         if (pHasPath)
         {
            mCurrentWaypoint = (*iter).second;
            return true;
         }
         break;
      }
   }
   return false;
}

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

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

std::string TestAI::CreateHelpLabelText()
{
   std::string testString("");
   testString += "F1: Toggle Help Screen\n";
   testString += "\n";
   testString += "Space: Toggle overhead/first person camera\n";
   testString += "n: Toggle navmesh\n";
   testString += "a: Zoom in overhead camera\n";
   testString += "z: Zoom out overhead camera\n";

   return testString;
}