/* -*-c++-*-
   * testAAR - testaarinput (.h & .cpp) - Using 'The MIT License'
   * Copyright (C) 2005-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.
   *
   * This software was developed by Alion Science and Technology Corporation under
   * circumstances in which the U. S. Government may have rights in the software.
   *
   * Christopher DuBuc
   * William E. Johnson II
   */
  
  include <testaarinput.h>
  include <testaarmessagetypes.h>
  include <testaarmessageprocessor.h>
  include <testaargameevent.h>
  include <testaarhud.h>
  
  include <dtUtil/macros.h>
  include <dtABC/application.h>
  include <dtCore/camera.h>
  include <dtCore/system.h>
  include <dtGame/gamemanager.h>
  include <dtGame/actorupdatemessage.h>
  include <dtGame/logcontroller.h>
  include <dtGame/serverloggercomponent.h>
  include <dtGame/basemessages.h>
  include <dtGame/logtag.h>
  include <dtLMS/lmscomponent.h>
  include <dtDAL/gameevent.h>
  
  include <iostream>
  
  
//////////////////////////////////////////////////////////////


  TestAARInput::TestAARInput(const std::string& name, dtGame::LogController& logCtrl, TestAARHUD& hudComp)
     : dtGame::BaseInputComponent(name)
     , mKeyIsPressed(false)
     , mSimSpeedFactor(1.0)
     , mHudGUI(&hudComp)
     , mLogController(&logCtrl)
  {
  
  }
  
  
//////////////////////////////////////////////////////////////////


  TestAARInput::~TestAARInput()
  {
  
  }
  
  
////////////////////////////////////////////////////////////////////


  bool TestAARInput::HandleKeyPressed(const dtCore::Keyboard* keyBoard, int key)
  {
     std::ostringstream ss;
     bool handled = true;
  
     switch (key)
     {
        case ' ':
        {
           GetGameManager()->SendMessage(*GetGameManager()->GetMessageFactory().CreateMessage(TestAARMessageType::REQUEST_ALL_CONTROLLER_UPDATES));
        }
        break;
  
        case 'w':
        case 'a':
        case 's':
        case 'd':
        {
           GetGameManager()->SendMessage(*GetGameManager()->GetMessageFactory().CreateMessage(TestAARMessageType::UPDATE_TASK_CAMERA));
        }
        break;
  
        case '0':
        {
           mSimSpeedFactor = 1.0f;
           ss << "Resetting Game Manager Speed to [" << mSimSpeedFactor << "] == Realtime.";
           std::cout << ss.str() << std::endl;
           GetGameManager()->ChangeTimeSettings(GetGameManager()->GetSimulationTime(),
              mSimSpeedFactor, GetGameManager()->GetSimulationClockTime());
        }
        break;
  
        case '1':
        {
           if (mLogController->GetLastKnownStatus().GetStateEnum() == dtGame::LogStateEnumeration::LOGGER_STATE_PLAYBACK)
           {
              GetGameManager()->SendMessage(*GetGameManager()->GetMessageFactory().CreateMessage(TestAARMessageType::RESET));
           }
  
           mLogController->RequestChangeStateToIdle();
           GetGameManager()->SetPaused(false);
        }
        break;
  
        case '2':
        {
           mLogController->RequestChangeStateToRecord();
  
           FireEvent(*TestAARGameEvent::EVENT_START_RECORD);
        }
        break;
  
        case '3':
        {
           //Going from idle mode to playback mode so we need to remove the player..
           if (mLogController->GetLastKnownStatus().GetStateEnum() == dtGame::LogStateEnumeration::LOGGER_STATE_IDLE)
           {
              GetGameManager()->DeleteAllActors();
              dtCore::System::GetInstance().Step();
           }
  
           mLogController->RequestChangeStateToPlayback();
  
           GetGameManager()->SetPaused(false);
        }
        break;
  
        case '-':
        case osgGA::GUIEventAdapter::KEY_KP_Subtract:
        {
           mSimSpeedFactor = mSimSpeedFactor * 0.9f;
           if (mSimSpeedFactor < 0.10f)
           {
              mSimSpeedFactor = 0.10f;
           }
           else
           {
              ss << "Decreasing Game Manager Speed to [" << mSimSpeedFactor << "]X Realtime.";
              std::cout << ss.str() << std::endl;
           }
  
           GetGameManager()->ChangeTimeSettings(GetGameManager()->GetSimulationTime(),
              mSimSpeedFactor, GetGameManager()->GetSimulationClockTime());
        }
        break;
  
        case osgGA::GUIEventAdapter::KEY_KP_Add:
        case '=':
        case '+':
        {
           mSimSpeedFactor = mSimSpeedFactor * 1.20f;
           if (mSimSpeedFactor > 10.0f)
           {
              mSimSpeedFactor = 10.0f;
           }
           else
           {
              ss << "Increasing Game Manager Speed to [" << mSimSpeedFactor << "]X Realtime.";
              std::cout << ss.str() << std::endl;
           }
  
           GetGameManager()->ChangeTimeSettings(GetGameManager()->GetSimulationTime(),
              mSimSpeedFactor, GetGameManager()->GetSimulationClockTime());
        }
        break;
  
        case 'p':
        {
           GetGameManager()->SetPaused(!GetGameManager()->IsPaused());
        }
        break;
  
        case 'b':
        {
           if (mLogController->GetLastKnownStatus().GetStateEnum() != dtGame::LogStateEnumeration::LOGGER_STATE_PLAYBACK)
           {
              dtCore::RefPtr<dtGame::Message> msg = GetGameManager()->GetMessageFactory().CreateMessage(TestAARMessageType::PLACE_ACTOR);
              GetGameManager()->SendMessage(*msg);
           }
        }
        break;
  
        case 'g':
        {
           if (mLogController->GetLastKnownStatus().GetStateEnum() != dtGame::LogStateEnumeration::LOGGER_STATE_PLAYBACK)
           {
              dtCore::RefPtr<dtGame::Message> msg = GetGameManager()->GetMessageFactory().CreateMessage(TestAARMessageType::PLACE_IGNORED_ACTOR);
              GetGameManager()->SendMessage(*msg);
           }
        }
        break;
  
        case 't':
        {
           InsertTag();
        }
        break;
  
        case 'f':
        {
           InsertKeyFrame();
        }
        break;
  
        case 'i':
        {
           SendPlayerUpdateMsg("Velocity", 10.0f);
           FireEvent(*TestAARGameEvent::EVENT_PLAYER_FORWARD);
        }
        break;
  
        case 'k':
        {
           SendPlayerUpdateMsg("Velocity", -10.0f);
           FireEvent(*TestAARGameEvent::EVENT_PLAYER_BACKWARD);
        }
        break;
  
        case 'j':
        {
           SendPlayerUpdateMsg("Turn Rate", 0.25f);
           FireEvent(*TestAARGameEvent::EVENT_PLAYER_LEFT);
        }
        break;
  
        case 'l':
        {
           SendPlayerUpdateMsg("Turn Rate", -0.25f);
           FireEvent(*TestAARGameEvent::EVENT_PLAYER_RIGHT);
        }
        break;
  
        case osgGA::GUIEventAdapter::KEY_F1:
        {
           if (mHudGUI->GetHUDState() == HUDState::HELP)
           {
              mHudGUI->CycleToNextHUDState(); // already in help, so toggle it off
           }
           else
           {
              mHudGUI->SetHUDState(HUDState::HELP);
           }
        }
        break;
  
        case osgGA::GUIEventAdapter::KEY_F2:
        {
           mHudGUI->CycleToNextHUDState();
        }
        break;
  
        case osgGA::GUIEventAdapter::KEY_Return:
        {
  //         GetGameManager()->GetApplication().GetCamera()->SetNextStatisticsType(); TODO
        }
        break;
  
        case 'm':
        {
           GetGameManager()->SendMessage(*GetGameManager()->GetMessageFactory().CreateMessage(TestAARMessageType::PRINT_TASKS));
        }
        break;
  
        case ',':
        {
           GotoPreviousKeyframe();
        }
        break;
  
        case '.':
        {
           GotoNextKeyframe();
        }
        break;
  
        default:
        {
           handled = false;
        }
        break;
     };
  
     if (!handled)
     {
        return GetGameManager()->GetApplication().KeyPressed(keyBoard, key);
     }
  
     return handled;
  }
  
  
////////////////////////////////////////////////////////////////////


  bool TestAARInput::HandleKeyReleased(const dtCore::Keyboard* keyboard, int key)
  {
     bool handled = true;
  
     switch (key)
     {
        case 'i':
        case 'k':
        {
           SendPlayerUpdateMsg("Velocity", 0.0f);
        }
        break;
  
        case 'j':
        case 'l':
        {
           SendPlayerUpdateMsg("Turn Rate", 0.0f);
        }
        break;
  
        default:
        {
           handled = false;
        }
        break;
     }
  
     return handled ? handled : dtGame::BaseInputComponent::HandleKeyReleased(keyboard, key);
  }
  
  
////////////////////////////////////////////////////////////////////


  void TestAARInput::FireEvent(dtDAL::GameEvent& event)
  {
     if (mLogController->GetLastKnownStatus().GetStateEnum() != dtGame::LogStateEnumeration::LOGGER_STATE_PLAYBACK)
     {
        dtCore::RefPtr<dtGame::GameEventMessage> eventMsg;
        GetGameManager()->GetMessageFactory().CreateMessage(dtGame::MessageType::INFO_GAME_EVENT, eventMsg);
  
        eventMsg->SetGameEvent(event);
        GetGameManager()->SendMessage(*eventMsg);
     }
  }
  
  
////////////////////////////////////////////////////////////////////


  void TestAARInput::GotoPreviousKeyframe()
  {
     const std::vector<dtGame::LogKeyframe>& frames = mLogController->GetLastKnownKeyframeList();
     const dtGame::LogKeyframe* prevFrame = NULL;
  
     for (unsigned int i = 0; i < frames.size(); i ++)
     {
        // Get the oldest frame less than the current sim time.  Allow a 3 second grace period
        // so that we don't have the same problem you do on CD players
        if ((frames[i].GetSimTimeStamp() + 2.25) < GetGameManager()->GetSimulationTime() &&
           (prevFrame == NULL || frames[i].GetSimTimeStamp() > prevFrame->GetSimTimeStamp()))
        {
           prevFrame = &(frames[i]);
        }
     }
  
     // found one, so jump to keyframe
     if (prevFrame != NULL)
     {
        std::ostringstream ss;
        ss << "## Attempting to Jump to Previous Keyframe: [" << prevFrame->GetName() << "] ##";
        std::cout << ss.str() << std::endl;
  
        mLogController->RequestJumpToKeyframe(*prevFrame);
     }
  }
  
  
////////////////////////////////////////////////////////////////////


  void TestAARInput::GotoNextKeyframe()
  {
     const std::vector<dtGame::LogKeyframe>& frames = mLogController->GetLastKnownKeyframeList();
     const dtGame::LogKeyframe* nextFrame = NULL;
  
     for (unsigned int i = 0; i < frames.size(); i ++)
     {
        // Get the first frame older than the current sim time.
        if (frames[i].GetSimTimeStamp() > GetGameManager()->GetSimulationTime() &&
           (nextFrame == NULL || frames[i].GetSimTimeStamp() < nextFrame->GetSimTimeStamp()))
        {
           nextFrame = &(frames[i]);
        }
     }
  
     // found one, so jump to keyframe
     if (nextFrame != NULL)
     {
        std::ostringstream ss;
        ss << "## Attempting to Jump to Next Keyframe: [" << nextFrame->GetName() << "] ##";
        std::cout << ss.str() << std::endl;
  
        mLogController->RequestJumpToKeyframe(*nextFrame);
     }
  }
  
  
////////////////////////////////////////////////////////////////////


  void TestAARInput::InsertTag()
  {
     char clin[100];            // buffer to print
     dtGame::LogTag newTag;
  
     newTag.SetCaptureKeyframe(false);
     newTag.SetDescription("Nifty Tag Description");
     snprintf(clin, 100, "My Tag At [%.2f]", GetGameManager()->GetSimulationTime());
     newTag.SetName(clin);
  
     mLogController->RequestInsertTag(newTag);
     mLogController->RequestServerGetTags();
  }
  
  
////////////////////////////////////////////////////////////////////


  void TestAARInput::InsertKeyFrame()
  {
     char clin[100];            // buffer to print
     dtGame::LogKeyframe newKeyframe;
  
     newKeyframe.SetDescription("Nifty Keyframe Description");
     snprintf(clin, 100, "Frame At [%.2f]", GetGameManager()->GetSimulationTime());
     newKeyframe.SetName(clin);
  
     mLogController->RequestCaptureKeyframe(newKeyframe);
     mLogController->RequestServerGetKeyframes();
  }
  
  
//////////////////////////////////////////////////////////////////


  void TestAARInput::ProcessMessage(const dtGame::Message& message)
  {
     const dtGame::MessageType& type = message.GetMessageType();
  
     if (type == dtGame::MessageType::INFO_ACTOR_DELETED)
     {
        if (mPlayer != NULL && message.GetAboutActorId() == mPlayer->GetId())
        {
           mPlayer = NULL;
        }
     }
  }
  
  
//////////////////////////////////////////////////////////////////


  void TestAARInput::SendPlayerUpdateMsg(const std::string& paramName, const float value)
  {
     if (mPlayer == NULL)
     {
        return;
     }
  
     dtCore::RefPtr<dtGame::Message> msg = GetGameManager()->GetMessageFactory().CreateMessage(dtGame::MessageType::INFO_ACTOR_UPDATED);
     dtGame::ActorUpdateMessage& aum = static_cast<dtGame::ActorUpdateMessage&>(*msg);
     aum.SetAboutActorId(mPlayer->GetId());
     dtGame::MessageParameter* mp = aum.AddUpdateParameter(paramName, dtDAL::DataType::FLOAT);
     static_cast<dtGame::FloatMessageParameter*>(mp)->SetValue(value);
     GetGameManager()->SendMessage(aum);
  }