/* -*-c++-*-
 * TutorialLibrary - This source file (.h & .cpp) - Using 'The MIT License'
 * Copyright (C) 2006-2008, Alion Science and Technology Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 * @author Curtiss Murphy
 * @author Chris Osborn
 */

#include <sstream>

#include "MyGameEntryPoint.h"
#include "InputComponent.h"
#include "HUDComponent.h"
#include "TargetChanged.h"
#include "TankActor.h"

#ifdef HLA
#  include <dtHLAGM/hlacomponent.h>
#  include <dtHLAGM/hlacomponentconfig.h>
#endif

#include <dtGame/gamemanager.h>
#include <dtGame/defaultmessageprocessor.h>
#include <dtGame/gameapplication.h>
#include <dtGame/exceptionenum.h>
#include <dtGame/binarylogstream.h>
#include <dtGame/logtag.h>
#include <dtGame/logkeyframe.h>
#include <dtGame/logstatus.h>
#include <dtGame/loggermessages.h>
#include <dtGame/logcontroller.h>
#include <dtGame/serverloggercomponent.h>

#include <dtCore/camera.h>
#include <dtCore/flymotionmodel.h>
#include <dtCore/camera.h>
#include <dtCore/keyboard.h>
#include <dtCore/globals.h>
#include <dtCore/deltawin.h>
#include <dtCore/scene.h>

#include <dtDAL/project.h>
#include <dtDAL/resourcedescriptor.h>

#include <osg/ArgumentParser>
#include <osg/ApplicationUsage>

#include <iostream>

//////////////////////////////////////////////////////////////////////////
extern "C" TUTORIAL_TANK_EXPORT dtGame::GameEntryPoint* CreateGameEntryPoint()
{
   return new MyGameEntryPoint;
}

//////////////////////////////////////////////////////////////////////////
extern "C" TUTORIAL_TANK_EXPORT void DestroyGameEntryPoint(dtGame::GameEntryPoint* entryPoint)
{
   delete entryPoint;
}


//////////////////////////////////////////////////////////////////////////
MyGameEntryPoint::~MyGameEntryPoint()
{
}

//////////////////////////////////////////////////////////////////////////
void MyGameEntryPoint::Initialize(dtGame::GameApplication& app, int argc, char** argv)
{
   osg::ArgumentParser parser(&argc, argv);

   parser.getApplicationUsage()->addCommandLineOption("-h or --help","Display command line options");
   parser.getApplicationUsage()->addCommandLineOption("--mapName", "The name of the map to load in. This must be a map that is located within the project path specified");
   parser.getApplicationUsage()->addCommandLineOption("--startPlayback", "Set this with a 1 if you want to run in playback mode.  You need to have previously recorded or it won't do anything.");

   if (parser.read("-h") || parser.read("--help") || parser.read("-?") || parser.read("--?") ||
      parser.argc() == 0)
   {
      parser.getApplicationUsage()->write(std::cerr);
      throw dtUtil::Exception(dtGame::ExceptionEnum::GAME_APPLICATION_CONFIG_ERROR, "Command Line Error.", __FILE__, __LINE__);
   }

   mMapName.reserve(512);

   if (!parser.read("--mapName", mMapName))
   {
      mMapName = "mapone";
   }

   // Start in Playback mode or not.
   int tempValue = 0;
   if (!parser.read("--startPlayback", tempValue))
   {
      mInPlaybackMode = false;
   }
   else
   {
      mInPlaybackMode = (tempValue == 1) ? true : false;
      if (mInPlaybackMode)
      {
         LOG_ERROR("NOTE - Enabling Playback mode. If you have not already done so, please consider using a different map without the tank actor in it ('--mapName mapone_playback'). Playback will not be able to control a local instance of the tank properly.");
      }
   }
   //  --startPlayback 1 --mapName mapone_playback
}

//////////////////////////////////////////////////////////////////////////
void MyGameEntryPoint::OnStartup(dtGame::GameApplication& app)
{
   // init our file path so it can find GUI Scheme
   // add extra data paths here if you need them
   std::string dataPath = dtCore::GetDeltaDataPathList();
   dtCore::SetDataFilePathList(dataPath + ";" +
                              dtCore::GetDeltaRootPath() + "/examples/data;" +
                              dtCore::GetDeltaRootPath() + "/examples/data/gui/imagesets;" +
                              dtCore::GetDeltaRootPath() + "/examples/data/gui/schemes;" +
                              dtCore::GetDeltaRootPath() + "/examples/data/gui/fonts;" +
                              dtCore::GetDeltaRootPath() + "/examples/data/gui/looknfeel;");
   LOG_ALWAYS("Path list is: " + dtCore::GetDataFilePathList() );

   dtDAL::Project::GetInstance().SetContext("StageProject");

   // Load the map we created in STAGE.
   app.GetGameManager()->ChangeMap(mMapName);

   // Add Component - DefaultMessageProcessor
   dtGame::DefaultMessageProcessor* dmp = new dtGame::DefaultMessageProcessor("DefaultMessageProcessor");
   app.GetGameManager()->AddComponent(*dmp,dtGame::GameManager::ComponentPriority::HIGHEST);

   // Register our messages with the Game Manager message factory - part 5
   TutorialMessageType::RegisterMessageTypes( app.GetGameManager()->GetMessageFactory() );

   // Add Component - Input Component
   dtCore::RefPtr<InputComponent> inputComp = new InputComponent("InputComponent", mInPlaybackMode);
   app.GetGameManager()->AddComponent(*inputComp, dtGame::GameManager::ComponentPriority::NORMAL);

#ifdef HLA
   // Add Component - HLAComponent
   dtCore::RefPtr<dtHLAGM::HLAComponent> hlaComp = new dtHLAGM::HLAComponent("HLAComponent");
   app.GetGameManager()->AddComponent(*hlaComp, dtGame::GameManager::ComponentPriority::NORMAL);

   //Load HLA Configuration
   dtHLAGM::HLAComponentConfig hlaCC;
   dtDAL::ResourceDescriptor rd("Federations:HLAMapping.xml", "Federations:HLAMapping.xml");
   const std::string mappingPath = dtDAL::Project::GetInstance().GetResourcePath(rd);
   if (!mappingPath.empty())
   {
      hlaCC.LoadConfiguration(*hlaComp, mappingPath);
   }
   else
   {
      std::ostringstream ss;
      ss << "Unable to load HLA Mapping resource " << rd.GetDisplayName();
      throw dtUtil::Exception(dtGame::ExceptionEnum::GAME_APPLICATION_CONFIG_ERROR, ss.str(), __FILE__, __LINE__);
   }

   dtDAL::ResourceDescriptor rd2("Federations:RPR-FOM.fed", "Federations:RPR-FOM.fed");
   const std::string fedPath = dtDAL::Project::GetInstance().GetResourcePath(rd2);

   if (!fedPath.empty())
   {
      hlaComp->JoinFederationExecution("Tutorial", fedPath, "Tank Tutorial");
   }
   else
   {
      std::ostringstream ss;
      ss << "Unable to load HLA Mapping resource " << rd2.GetDisplayName();
      throw dtUtil::Exception(dtGame::ExceptionEnum::GAME_APPLICATION_CONFIG_ERROR, ss.str(), __FILE__, __LINE__);
   }
#endif

   // Add Component - HUD Component
   dtCore::RefPtr<HUDComponent> hudComp = new HUDComponent(app.GetWindow(),
                                                           app.GetKeyboard(),
                                                           app.GetMouse(),
                                                           "HUDComponent");
   app.GetGameManager()->AddComponent(*hudComp, dtGame::GameManager::ComponentPriority::NORMAL);

   // offset our camera a little back and above the tank.
   //dtCore::Transform tx(0.0f, 0.7f, 2.2f, 0.0f, 0.0f, 0.0f);
   //app.GetCamera()->SetTransform(tx);

   app.GetGameManager()->GetScene().UseSceneLight(true);

   // Attach our camera to the tank from the map
   std::vector<dtDAL::ActorProxy*> tanks;
   app.GetGameManager()->FindActorsByName("HoverTank", tanks);
   if (tanks.size() > 0 && tanks[0] != NULL)
   {
      if (mInPlaybackMode)
      {
         LOG_ALWAYS("Error: The tank actor is already loaded into the world during playback.  This will prevent the tank from receiving Playback messages.  Try loading a different map using --mapName <map>");
      }
   }

   // Allow the fly motion model to move the camera around independent of the tank.
   dtCore::FlyMotionModel* fmm = new dtCore::FlyMotionModel(app.GetKeyboard(), app.GetMouse(),
                                                            dtCore::FlyMotionModel::OPTION_USE_CURSOR_KEYS |
                                                            dtCore::FlyMotionModel::OPTION_REQUIRE_MOUSE_DOWN );
   fmm->SetMaximumFlySpeed(15);
   fmm->SetTarget(app.GetCamera());

   app.GetWindow()->SetWindowTitle("Delta3D Tank Tutorial");

   // Add the AAR behaviors.
   dtGame::BinaryLogStream* logStream = new dtGame::BinaryLogStream(app.GetGameManager()->GetMessageFactory());
   mServerLogger = new dtGame::ServerLoggerComponent(*logStream, "ServerLoggerComponent");
   mLogController = new dtGame::LogController("LogController");
   app.GetGameManager()->AddComponent(*mServerLogger, dtGame::GameManager::ComponentPriority::NORMAL);
   app.GetGameManager()->AddComponent(*mLogController, dtGame::GameManager::ComponentPriority::NORMAL);
   if (mInPlaybackMode)
   {
      mLogController->RequestChangeStateToPlayback();
      mLogController->RequestServerGetKeyframes();
   }
   else
   {
      mLogController->RequestSetAutoKeyframeInterval(20.0f);
   }

   // Ignore constant actors from being recorded. This protects them from deletion over
   // ServerLoggerComponent state changes; such as transitions from PLAYBACK to IDLE states.
   //mLogController->RequestAddIgnoredActor(mInputComp->GetTerrainActor().GetId());

   app.GetGameManager()->DebugStatisticsTurnOn(true, true, 30, true);
}