/* -*-c++-*-
   * testAnim - testaniminput (.h & .cpp) - Using 'The MIT License'
   * Copyright (C) 2007-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.
   *
   * Bradley Anderegg
   */
  
  include <testaniminput.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/basemessages.h>
  include <dtAnim/animationhelper.h>
  include <dtUtil/matrixutil.h>
  include <dtCore/transform.h>
  include <osg/Matrix>
  include <osg/Vec3>
  include <dtGame/logtag.h>
  
  
//////////////////////////////////////////////////////////////


  TestAnimInput::TestAnimInput(const std::string &name)
     : dtGame::BaseInputComponent(name)
     , mSpeed(2.0f)
     , mTurnRate(1.01f)
     , mTurnDirection(1.0f)
     , mKeyIsPressed(false)
     , mIsWalking(false)
     , mIsTurning(false)
  {
  
  }
  
  
//////////////////////////////////////////////////////////////////


  TestAnimInput::~TestAnimInput()
  {
  
  }
  
  
////////////////////////////////////////////////////////////////////


  void TestAnimInput::SetSpeed(float speed)
  {
     mSpeed = speed;
  }
  
  
////////////////////////////////////////////////////////////////////


  void TestAnimInput::SetTurnRate(float turn)
  {
     mTurnRate = turn;
  }
  
  
////////////////////////////////////////////////////////////////////


  bool TestAnimInput::HandleKeyPressed(const dtCore::Keyboard *keyBoard, int key)
  {
     bool handled = true;
  
     switch (key)
     {
  
        case osgGA::GUIEventAdapter::KEY_Escape:
           {
              GetGameManager()->GetApplication().Quit();
              return true;
           }
  
        case osgGA::GUIEventAdapter::KEY_Right:
           {
              mIsTurning = true;
              mTurnDirection = -1.0f;
              return false;
           }
        case osgGA::GUIEventAdapter::KEY_Left:
           {
              mIsTurning = true;
              mTurnDirection = 1.0f;
              return false;
           }
        case '\\':
        case osgGA::GUIEventAdapter::KEY_Insert:
           {
  //            GetGameManager()->GetApplication().GetCamera()->SetNextStatisticsType();
              break;
           }
        case osgGA::GUIEventAdapter::KEY_Up:
           {
              if (!mIsWalking)
              {
                 mAnimationHelper->ClearAll(0.25f);
                 mAnimationHelper->PlayAnimation("RunWalk");
                 mIsWalking = true;
              }
              return false;
           }
        case osgGA::GUIEventAdapter::KEY_Page_Up:
           {
              dtCore::Camera* camera = GetGameManager()->GetApplication().GetCamera();
              float oldLODScale = camera->GetLODScale();
              camera->SetLODScale(oldLODScale * 1.1);
              return false;
           }
        case osgGA::GUIEventAdapter::KEY_Page_Down:
           {
              dtCore::Camera* camera = GetGameManager()->GetApplication().GetCamera();
              float oldLODScale = camera->GetLODScale();
              camera->SetLODScale(oldLODScale / 1.1);
              return false;
           }
        default:
           break;
     };
  
     if (!handled)
     {
        return GetGameManager()->GetApplication().KeyPressed(keyBoard, key);
     }
  
     return handled;
  }
  
  
////////////////////////////////////////////////////////////////////


  bool TestAnimInput::HandleKeyReleased(const dtCore::Keyboard* keyboard, int key)
  {
     bool handled = true;
  
     switch (key)
     {
        case osgGA::GUIEventAdapter::KEY_Up:
           {
              mAnimationHelper->ClearAll(0.25f);
              mAnimationHelper->PlayAnimation("Idle");
              mIsWalking = false;
              return false;
           }
        case osgGA::GUIEventAdapter::KEY_Right:
        case osgGA::GUIEventAdapter::KEY_Left:
           {
              mIsTurning = false;
              return false;
           }
        default:
           break;
     };
  
     if (!handled)
     {
        return GetGameManager()->GetApplication().KeyPressed(keyboard, key);
     }
  
     return handled;
  }
  
  
//////////////////////////////////////////////////////////////////


  void TestAnimInput::SetPlayerActor(dtGame::GameActorProxy &gap)
  {
     mPlayer = &gap;
  }
  
  
//////////////////////////////////////////////////////////////////


  void TestAnimInput::SetAnimationHelper(dtAnim::AnimationHelper& pHelper)
  {
     mAnimationHelper = &pHelper;
     mAnimationHelper->ClearAnimation("Idle", 0.25f);
  }
  
  
//////////////////////////////////////////////////////////////////


  void TestAnimInput::ProcessMessage(const dtGame::Message& message)
  {
  
     if (message.GetMessageType() == dtGame::MessageType::TICK_LOCAL)
     {
        const dtGame::TickMessage& mess = static_cast<const dtGame::TickMessage&>(message);
        TickLocal(mess.GetDeltaSimTime());
     }
  }
  
  
//////////////////////////////////////////////////////////////////


  void TestAnimInput::TickLocal(float dt)
  {
  
     dtGame::GameActor* pActor = &mPlayer->GetGameActor();
  
     dtCore::Transform trans;
     osg::Matrix mat;
  
     osg::Vec3 pos, up, forward;
  
     if (mIsWalking || mIsTurning)
     {
        pActor->GetTransform(trans);
        trans.Get(mat);
  
        up = dtUtil::MatrixUtil::GetRow3(mat, 2);
        forward = dtUtil::MatrixUtil::GetRow3(mat, 1);
  
        trans.GetTranslation(pos);
     }
  
     if (mIsTurning)
     {
        const float angle = dt * mTurnRate * mTurnDirection;
  
        trans.GetRotation(mat);
        trans.SetRotation(mat * osg::Matrix::rotate(angle, up));
     }
  
     if (mIsWalking)
     {
        float dist = -1.0f * (mSpeed * dt);
        pos += forward * dist;
  
        trans.SetTranslation(pos);
     }
  
     if (mIsWalking || mIsTurning)
     {
        pActor->SetTransform(trans, dtCore::Transformable::REL_CS);
     }
  }