/* -*-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 "KillableTargetActor.h"
#include "TargetChanged.h"
#include <dtDAL/enginepropertytypes.h>
#include <dtGame/gamemanager.h>
#include <dtGame/actorupdatemessage.h>
#include <dtGame/basemessages.h>
#include <dtUtil/log.h>
#include <dtUtil/mathdefines.h>
#include <dtCore/shadermanager.h>
#include <dtCore/shaderparameter.h>
#include <dtCore/shaderparamoscillator.h>
#include <dtCore/scene.h>
#include <osg/Switch>

KillableTargetActor::SwitchVisitor::SwitchVisitor(const std::string& state)
   : osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN)
   , mSwitchState(state)
{
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActor::SwitchVisitor::apply(osg::Switch& switchNode)
{
   for (unsigned i = 0; i < switchNode.getNumChildren(); ++i)
   {
      if (switchNode.getChild(i)->getName() == mSwitchState)
      {
         switchNode.setSingleChildOn(i);
         break;
      }
   }
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActor::SwitchVisitor::SetSwitchState(const std::string& state)
{
   mSwitchState = state;
}

///////////////////////////////////////////////////////////////////////////////
const std::string& KillableTargetActor::SwitchVisitor::GetSwitchState() const
{
   return mSwitchState;
}

///////////////////////////////////////////////////////////////////////////////
KillableTargetActor::KillableTargetActor(dtGame::GameActorProxy& proxy)
   : dtActors::GameMeshActor(proxy)
   , mShaderEffect()
   , mMaxHealth(100)
   , mCurrentHealth(0)
   , mIsTargeted(false)
{
   SetName("KillableTarget");
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActor::OnTickLocal(const dtGame::TickMessage& tickMessage)
{
   //const dtGame::TickMessage& tick = static_cast<const dtGame::TickMessage&>(tickMessage);
   //float deltaSimTime = tick.GetDeltaSimTime();

   // Do something here locally if you want to. Note - if you don't need to do anything
   // here then you should NOT call RegisterForMessages(dtGame::MessageType::TICK_LOCAL, ...)
   // in OnEnteredWorld().
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActor::OnTickRemote(const dtGame::TickMessage& tickMessage)
{
   //const dtGame::TickMessage& tick = static_cast<const dtGame::TickMessage&>(tickMessage);
   //float deltaSimTime = tick.GetDeltaSimTime();

   // Do something here locally if you want to. Note - if you don't need to do anything
   // here then you should NOT call RegisterForMessages(dtGame::MessageType::TICK_REMOTE, ...)
   // in OnEnteredWorld().
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActor::ProcessMessage(const dtGame::Message& message)
{
   // HANDLE GAME EVENT MESSAGE - "TankFired"
   if (message.GetMessageType() == dtGame::MessageType::INFO_GAME_EVENT)
   {
      const dtGame::GameEventMessage& eventMsg =
         static_cast<const dtGame::GameEventMessage&>(message);

      // Note, we are using strings which aren't constants.  In a real application, these
      // event names should be stored in some sort of shared place and should be constants...
      if (eventMsg.GetGameEvent() != 0 && eventMsg.GetGameEvent()->GetName() == "TankFired")
      {
         if (mIsTargeted && mCurrentHealth > 0)
         {
            SetCurrentHealth(GetCurrentHealth() - 25);
         }
      }
      // test our shaders
      else if (eventMsg.GetGameEvent() != 0 && eventMsg.GetGameEvent()->GetName() == "TestShaders")
      {
         // Note, this behavior is now done in the InputComponent.cpp using the new Shader method.
         //dtCore::ShaderManager::GetInstance().Clear();
         //dtCore::ShaderManager::GetInstance().LoadShaderDefinitions("Shaders/TutorialShaderDefs.xml", false);
         //ApplyMyShader();
      }
      // reset me!
      else if (eventMsg.GetGameEvent() != 0 && eventMsg.GetGameEvent()->GetName() == "ResetStuff")
      {
         SetTransform(mOriginalPosition);
         ResetState();
      }
   }
   // HANDLE TARGET CHANGED MESSAGE
   else if (message.GetMessageType() == TutorialMessageType::TANK_TARGET_CHANGED)
   {
      const TargetChangedMessage& targetChanged = static_cast<const TargetChangedMessage&>(message);
      mIsTargeted = (targetChanged.GetNewTargetUniqueId() ==  GetUniqueId());

      if (mIsTargeted && mCurrentHealth > 0)
      {
         // Ahhhh! Get that gun outta my face!
         mCurrentShaderName = "Green";
      }
      else
      {
         //mCurrentShaderName = "Green";
         mCurrentShaderName = "Normal";
      }

      ApplyMyShader();
   }

}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActor::ApplyMyShader()
{
   float prevTime = 0.0, prevX = 0.0, prevY = 0.0, prevZ = 0.0;
   dtCore::ShaderParamOscillator* timerParam = NULL;

   if (mCurrentShader != NULL && mCurrentShader->GetName() == mCurrentShaderName)
   {
      // don't reload stuff or we kill our processing.
      return;
   }

   // if we had a previous shader, then get the current values of our float timers.  Then,
   // after we reassign them, we can put them back where they were.  Avoids 'jumping'
   if (mCurrentShader != NULL)
   {
      // TIME DILATION
      timerParam = dynamic_cast<dtCore::ShaderParamOscillator*> (mCurrentShader->FindParameter("TimeDilation"));
      if (timerParam != NULL)
      {
         prevTime = timerParam->GetValue();
      }

      // X DILATION
      timerParam = dynamic_cast<dtCore::ShaderParamOscillator*> (mCurrentShader->FindParameter("MoveXDilation"));
      if (timerParam != NULL)
      {
         prevX = timerParam->GetValue();
      }

      // Y DILATION
      timerParam = dynamic_cast<dtCore::ShaderParamOscillator*> (mCurrentShader->FindParameter("MoveYDilation"));
      if (timerParam != NULL)
      {
         prevY = timerParam->GetValue();
      }

      // Z DILATION
      timerParam = dynamic_cast<dtCore::ShaderParamOscillator*> (mCurrentShader->FindParameter("MoveZDilation"));
      if (timerParam != NULL)
      {
         prevZ = timerParam->GetValue();
      }
   }

   // clean up any previous shaders, if any
   dtCore::ShaderManager::GetInstance().UnassignShaderFromNode(*GetOSGNode());

   dtCore::ShaderProgram* templateShader = dtCore::ShaderManager::GetInstance().
      FindShaderPrototype(mCurrentShaderName,"TargetShaders");
   if (templateShader != NULL)
   {
      mCurrentShader = dtCore::ShaderManager::GetInstance().
         AssignShaderFromPrototype(*templateShader, *GetOSGNode());

      // Put the shader values back (again, to avoid jumping since we are moving XYZ in our shader)
      // TIME DILATION
      timerParam = dynamic_cast<dtCore::ShaderParamOscillator*> (mCurrentShader->FindParameter("TimeDilation"));
      if (timerParam != NULL)
      {
         timerParam->SetValue(prevTime);
      }

      // X DILATION
      timerParam = dynamic_cast<dtCore::ShaderParamOscillator*> (mCurrentShader->FindParameter("MoveXDilation"));
      if (timerParam != NULL)
      {
         timerParam->SetValue(prevX);
      }

      // Y DILATION
      timerParam = dynamic_cast<dtCore::ShaderParamOscillator*> (mCurrentShader->FindParameter("MoveYDilation"));
      if (timerParam != NULL)
      {
         timerParam->SetValue(prevY);
      }

      // Z DILATION
      timerParam = dynamic_cast<dtCore::ShaderParamOscillator*> (mCurrentShader->FindParameter("MoveZDilation"));
      if (timerParam != NULL)
      {
         timerParam->SetValue(prevZ);
      }
   }
   else
   {
      LOG_ERROR("KillableTargetActor could not load shader for group[TargetShaders] with name [" + mCurrentShaderName + "]");
      mCurrentShader = NULL;
   }
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActor::SetShaderEffect(const std::string& shaderEffect)
{
   mShaderEffect = shaderEffect;
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActor::SetMaxHealth(int maxHealth)
{
   mMaxHealth = maxHealth;
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActor::SetCurrentHealth(int currentHealth)
{
   currentHealth = dtUtil::Max(currentHealth, 0);
   if (currentHealth == 0 && mCurrentHealth > currentHealth && mCurrentHealth != 0)
   {
      mLargeExplosion->SetEnabled(true);
      SwitchVisitor switchVisitor("Destroyed");
      GetOSGNode()->accept(switchVisitor);

      mCurrentShaderName = "Normal";
      ApplyMyShader();
   }
   else if (currentHealth != 0 && mCurrentHealth > currentHealth)
   {
      mSmallExplosion->SetEnabled(true);
   }
   else if (currentHealth > 0 && mCurrentHealth == 0)
   {
      SwitchVisitor switchVisitor("Good");
      GetOSGNode()->accept(switchVisitor);
   }
   mCurrentHealth = currentHealth;

   GetGameActorProxy().NotifyFullActorUpdate();
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActor::OnEnteredWorld()
{
   // Initialize private state
   dtActors::GameMeshActor::OnEnteredWorld();

   // small explosion
   mSmallExplosion = new dtCore::ParticleSystem();
   mSmallExplosion->LoadFile("Particles/explosion_small.osg",true);
   GetGameActorProxy().GetGameManager()->GetScene().AddDrawable(mSmallExplosion.get());
   //AddChild(mSmallExplosion.get());

   // large explosion
   mLargeExplosion = new dtCore::ParticleSystem();
   mLargeExplosion->LoadFile("Particles/explosion_large.osg",true);
   GetGameActorProxy().GetGameManager()->GetScene().AddDrawable(mLargeExplosion.get());
   //AddChild(mLargeExplosion.get());

   GetTransform(mOriginalPosition);
   ResetState();
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActor::ResetState()
{
   mIsTargeted = false;

   // Force the shader to reload
   mCurrentShaderName = "Normal";
   mCurrentShader = NULL;
   //mTextureDilationParam = NULL;
   ApplyMyShader();

   mSmallExplosion->SetEnabled(false);
   mSmallExplosion->SetTransform(mOriginalPosition);
   mLargeExplosion->SetEnabled(false);
   mLargeExplosion->SetTransform(mOriginalPosition);

   SetCurrentHealth(mMaxHealth);
}

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

KillableTargetActorProxy::KillableTargetActorProxy()
{
   SetClassName("KillableTarget");
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActorProxy::BuildPropertyMap()
{
   const std::string GROUP = "KillableTarget";

   dtActors::GameMeshActorProxy::BuildPropertyMap();
   KillableTargetActor& actor = dynamic_cast<KillableTargetActor&>(GetGameActor());

   // override the default behavior on initial creation. This can be overridden by the user in the map
   actor.SetUseCache(false);

   // "Max Health" property
   AddProperty( new dtDAL::IntActorProperty( "Max Health", "Max Health",
      dtDAL::MakeFunctor( actor, &KillableTargetActor::SetMaxHealth ),
      dtDAL::MakeFunctorRet( actor, &KillableTargetActor::GetMaxHealth ),
      "Sets/gets the target max health (i.e. the damaged it can sustain before going boom)", GROUP ) );

   // "Current Health" property
   AddProperty( new dtDAL::IntActorProperty( "Current Health", "Current Health",
      dtDAL::MakeFunctor( actor, &KillableTargetActor::SetCurrentHealth ),
      dtDAL::MakeFunctorRet( actor, &KillableTargetActor::GetCurrentHealth ),
      "Sets/gets the target current health", GROUP ) );
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActorProxy::CreateActor()
{
   KillableTargetActor* actor = new KillableTargetActor(*this);
   SetActor(*actor);
}

///////////////////////////////////////////////////////////////////////////////
void KillableTargetActorProxy::OnEnteredWorld()
{
   // Register for invokables - NEVER register for both Local & Remote ticks!
   // ONLY register for messages you need. With lots of actors, the overhead
   // can hit your performance.
   //if (IsRemote())
      // We don't need a remote tick, so don't register for it! But here is how...
      //RegisterForMessages(dtGame::MessageType::TICK_REMOTE, dtGame::GameActorProxy::TICK_REMOTE_INVOKABLE);
   //else
      // We don't need a local tick, so don't register for it! But here is how...
      //RegisterForMessages(dtGame::MessageType::TICK_LOCAL, dtGame::GameActorProxy::TICK_LOCAL_INVOKABLE);

   // Register for the messages using the default Invokable - ProcessMessage()
   RegisterForMessages(dtGame::MessageType::INFO_GAME_EVENT);
   RegisterForMessages(TutorialMessageType::TANK_TARGET_CHANGED);

   dtActors::GameMeshActorProxy::OnEnteredWorld();
}