/* -*-c++-*-
  * testGameActorLibrary - 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.
  *
  * This software was developed by Alion Science and Technology Corporation under
  * circumstances in which the U. S. Government may have rights in the software.
  *
  * Matthew W. Campbell
  */
  
  include <testplayer.h>
  include <osg/MatrixTransform>
  include <osgDB/ReadFile>
  
  //#include <dtCore/isector.h>
  
  include <dtDAL/enginepropertytypes.h>
  
  include <dtCore/transform.h>
  include <dtGame/messagetype.h>
  include <dtGame/gamemanager.h>
  include <dtGame/basemessages.h>
  include <dtGame/actorupdatemessage.h>
  include <dtGame/invokable.h>
  
  include <iostream>
  
  
////////////////////////////////////////////////////////////////////////


  TestPlayer::TestPlayer(dtGame::GameActorProxy& proxy): dtGame::GameActor(proxy),
                                                         mIsector(new dtCore::Isector())
  {
     mVelocity = 0.0f;
     mTurnRate = 0.0f;
  }
  
  
////////////////////////////////////////////////////////////////////////


  TestPlayer::~TestPlayer()
  {
     mIsector = NULL;
  }
  
  
////////////////////////////////////////////////////////////////////////


  void TestPlayer::OnTickLocal(const dtGame::TickMessage& tickMessage)
  {
     const dtGame::TickMessage &tick =
        static_cast<const dtGame::TickMessage&>(tickMessage);
  
     HandleTick(tick.GetDeltaSimTime());
  }
  
  
////////////////////////////////////////////////////////////////////////


  void TestPlayer::OnTickRemote(const dtGame::TickMessage& tickMessage)
  {
     const dtGame::TickMessage &tick =
        static_cast<const dtGame::TickMessage&>(tickMessage);
     HandleTick(tick.GetDeltaSimTime());
  }
  
  
////////////////////////////////////////////////////////////////////////


  void TestPlayer::HandleTick(double deltaSimTime, bool forceGroundClamp)
  {
     if (deltaSimTime == 0.0f)
        return;
  
     if (forceGroundClamp || mVelocity > 0.0001f || mVelocity < -0.0001f ||
         mTurnRate > 0.0001f || mTurnRate < -0.0001f)
     {
        dtCore::Transform tx;
        osg::Matrix mat;
        osg::Quat q;
        osg::Vec3 viewDir;
  
        GetTransform(tx);
        tx.GetRotation(mat);
        mat.get(q);
  
        viewDir = q*osg::Vec3(0,-1,0);
  
        //Translate the player along its current view direction based on its
        //current velocity.
        osg::Vec3 pos;
        tx.GetTranslation(pos);
        pos = pos + (viewDir*(mVelocity*deltaSimTime));
  
        // attempt to ground clamp the actor so that he doesn't go through
        // mountains.
        osg::Vec3 intersection;
        mIsector->Reset();
        mIsector->SetScene(GetSceneParent());
        mIsector->SetStartPosition(osg::Vec3(pos.x(),pos.y(),-10000));
        mIsector->SetDirection(osg::Vec3(0,0,1));
        if (mIsector->Update())
        {
           //std::cout << "Got an intersection!" << std::endl;
           osgUtil::IntersectVisitor &iv = mIsector->GetIntersectVisitor();
           osg::Vec3 p = iv.getHitList(mIsector->GetLineSegment())[0].getWorldIntersectPoint();
           pos.z() = p.z() + 1.0f; //2.55f;
        }
  
        osg::Vec3 xyz = GetGameActorProxy().GetRotation();
        xyz[2] += 360.0f*mTurnRate*deltaSimTime;
        if (xyz[2] > 360.0f)
           xyz[2] -= 360.0f;
  
        tx.SetTranslation(pos);
        SetTransform(tx);
        GetGameActorProxy().SetRotation(xyz);
     }
  
  }
  
  
////////////////////////////////////////////////////////////////////////


  void TestPlayer::SetModel(const std::string &fileName)
  {
     if (mModelFile != fileName)
     {
        dtCore::RefPtr<osgDB::ReaderWriter::Options> options = new osgDB::ReaderWriter::Options();
  
        options->setObjectCacheHint(osgDB::ReaderWriter::Options::CACHE_ALL);
        osg::Node *model = osgDB::readNodeFile(fileName,options.get());
        if (model != NULL)
        {
           if (GetMatrixNode()->getNumChildren() != 0)
              GetMatrixNode()->removeChild(0,GetMatrixNode()->getNumChildren());
           GetMatrixNode()->addChild(model);
           mModelFile = fileName;
        }
        else
        {
           LOG_ERROR("Unable to load model file: " + fileName);
        }
  
        //the game manager is not set when this property is first set at map load time.
        if (!IsRemote() && GetGameActorProxy().IsInGM())
        {
           dtCore::RefPtr<dtGame::Message> updateMsg = GetGameActorProxy().GetGameManager()->
              GetMessageFactory().CreateMessage(dtGame::MessageType::INFO_ACTOR_UPDATED);
           dtGame::ActorUpdateMessage *message = static_cast<dtGame::ActorUpdateMessage *> (updateMsg.get());
           GetGameActorProxy().PopulateActorUpdate(*message);
  
           GetGameActorProxy().GetGameManager()->SendMessage(*updateMsg);
        }
     }
  }
  
  
////////////////////////////////////////////////////////////////////////


  void TestPlayer::SetVelocity(float velocity)
  {
     if (mVelocity != velocity)
     {
        mVelocity = velocity;
        // if local, then we need to do an actor update - let the world know.
        //the game manager is not set when this property is first set at map load time.
        if (!IsRemote() && GetGameActorProxy().IsInGM())
        {
           dtCore::RefPtr<dtGame::Message> updateMsg = GetGameActorProxy().GetGameManager()->
              GetMessageFactory().CreateMessage(dtGame::MessageType::INFO_ACTOR_UPDATED);
           dtGame::ActorUpdateMessage *message = static_cast<dtGame::ActorUpdateMessage *> (updateMsg.get());
           GetGameActorProxy().PopulateActorUpdate(*message);
  
           GetGameActorProxy().GetGameManager()->SendMessage(*updateMsg);
        }
     }
  }
  
  
////////////////////////////////////////////////////////////////////////


  float TestPlayer::GetVelocity() const
  {
     return mVelocity;
  }
  
  
////////////////////////////////////////////////////////////////////////


  void TestPlayer::SetTurnRate(float rate)
  {
     if (mTurnRate != rate)
     {
        mTurnRate = rate;
  
        //the game manager is not set when this property is first set at map load time.
        if (!IsRemote() && GetGameActorProxy().IsInGM())
        {
           dtCore::RefPtr<dtGame::Message> updateMsg = GetGameActorProxy().GetGameManager()->
              GetMessageFactory().CreateMessage(dtGame::MessageType::INFO_ACTOR_UPDATED);
           dtGame::ActorUpdateMessage *message = static_cast<dtGame::ActorUpdateMessage *> (updateMsg.get());
           GetGameActorProxy().PopulateActorUpdate(*message);
  
           GetGameActorProxy().GetGameManager()->SendMessage(*updateMsg);
        }
     }
  }
  
  
////////////////////////////////////////////////////////////////////////


  float TestPlayer::GetTurnRate() const
  {
     return mTurnRate;
  }
  
  
////////////////////////////////////////////////////////////////////////


  
////////////////////////////////////////////////////////////////////////


  
////////////////////////////////////////////////////////////////////////


  TestPlayerProxy::TestPlayerProxy()
  {
     SetClassName("TestPlayer");
     mEnteredBefore = false;
  }
  
  
////////////////////////////////////////////////////////////////////////


  TestPlayerProxy::~TestPlayerProxy()
  {
  }
  
  
////////////////////////////////////////////////////////////////////////


  void TestPlayerProxy::BuildPropertyMap()
  {
     dtGame::GameActorProxy::BuildPropertyMap();
  
     TestPlayer &player = static_cast<TestPlayer &>(GetGameActor());
     AddProperty(new dtDAL::StringActorProperty("mesh","mesh",
        dtDAL::MakeFunctor(player,&TestPlayer::SetModel),
        dtDAL::MakeFunctorRet(player,&TestPlayer::GetModel)));
  
     AddProperty(new dtDAL::FloatActorProperty("velocity","velocity",
        dtDAL::MakeFunctor(player,&TestPlayer::SetVelocity),
        dtDAL::MakeFunctorRet(player,&TestPlayer::GetVelocity)));
  
     AddProperty(new dtDAL::FloatActorProperty("turnrate","turnrate",
        dtDAL::MakeFunctor(player,&TestPlayer::SetTurnRate),
        dtDAL::MakeFunctorRet(player,&TestPlayer::GetTurnRate)));
  }
  
  
////////////////////////////////////////////////////////////////////////


  void TestPlayerProxy::BuildInvokables()
  {
     dtGame::GameActorProxy::BuildInvokables();
  }
  
  
////////////////////////////////////////////////////////////////////////


  void TestPlayerProxy::OnEnteredWorld()
  {
     if (!mEnteredBefore)
     {
        mEnteredBefore = true;
  
        TestPlayer &actor = static_cast<TestPlayer&>(GetGameActor());
  
        //std::cout << "Here in on entered world.  Attempting to ground clamp." << std::endl;
        actor.HandleTick(1.0,true);
  
        //enable receiving tick messages.
        if (IsRemote())
        {
           GetGameManager()->RegisterForMessages(dtGame::MessageType::TICK_REMOTE,
              *this,"Tick Remote");
        }
        else
        {
           GetGameManager()->RegisterForMessages(dtGame::MessageType::TICK_LOCAL,
              *this,"Tick Local");
        }
     }
  }
  
  
////////////////////////////////////////////////////////////////////////


  void TestPlayerProxy::CreateActor()
  {
     SetActor(*new TestPlayer(*this));
  }