/*
  * Delta3D Open Source Game and Simulation Engine
  * Copyright (C) 2009 MOVES Institute
  *
  * This library is free software; you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation; either version 2.1 of the License, or (at your option)
  * any later version.
  *
  * This library is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; if not, write to the Free Software Foundation, Inc.,
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
  * Michael Guerrero
  */
  
  include <proceduralanimationactor.h>
  
  include <dtCore/transform.h>
  include <dtDAL/enginepropertytypes.h>
  include <dtGame/basemessages.h>
  include <dtGame/gameactor.h>
  include <dtGame/messagetype.h>
  include <dtGame/gamemanager.h>
  include <dtUtil/mathdefines.h>
  
  include <dtAnim/animationhelper.h>
  include <dtAnim/cal3dmodelwrapper.h>
  include <dtAnim/posemeshdatabase.h>
  include <dtAnim/posemath.h>
  
  include <cassert>
  
  
////////////////////////////////////////////////////


  // Proxy code
  
////////////////////////////////////////////////////


  ProceduralAnimationActorProxy::ProceduralAnimationActorProxy()
  {
     SetClassName("ProceduralAnimationActor");
  }
  
  
//////////////////////////////////////////////////////////////////////////


  ProceduralAnimationActorProxy::~ProceduralAnimationActorProxy()
  {
  }
  
  
//////////////////////////////////////////////////////////////////////////


  void ProceduralAnimationActorProxy::BuildInvokables()
  {
     dtAnim::AnimationGameActorProxy::BuildInvokables();
  }
  
  
//////////////////////////////////////////////////////////////////////////


  void ProceduralAnimationActorProxy::BuildPropertyMap()
  {
     dtAnim::AnimationGameActorProxy::BuildPropertyMap();
  }
  
  
//////////////////////////////////////////////////////////////////////////


  void ProceduralAnimationActorProxy::CreateActor()
  {
     ProceduralAnimationActor* pActor = new ProceduralAnimationActor(*this);
     SetActor(*pActor);
  }
  
  
////////////////////////////////////////////////////


  // Actor code
  
////////////////////////////////////////////////////


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


  ProceduralAnimationActor::ProceduralAnimationActor(ProceduralAnimationActorProxy& proxy)
     : AnimationGameActor(proxy)
     , mMode(MODE_AIM)
     , mPoseMeshDatabase(NULL)
     , mPoseMeshUtil(NULL)
     , mBlendTime(0.3f)
     , mCurrentTarget(NULL)
  {
     memset(mMarinePoseData.mPoseMeshes, 0, sizeof(dtAnim::PoseMesh*) * ProceduralAnimationData::PMP_TOTAL);
  
     // Initialize ik target data
     for (size_t partIndex = ProceduralAnimationData::PMP_FIRST;
        partIndex < ProceduralAnimationData::PMP_TOTAL;
        ++partIndex)
     {
        mMarinePoseData.mTargetTriangles[partIndex].mIsInside = false;
        mMarinePoseData.mTargetTriangles[partIndex].mTriangleID = -1;
     }
  }
  
  
//////////////////////////////////////////////////////////////////////////


  ProceduralAnimationActor::~ProceduralAnimationActor()
  {
  }
  
  
//////////////////////////////////////////////////////////////////////////


  void ProceduralAnimationActor::OnEnteredWorld()
  {
     AnimationGameActor::OnEnteredWorld();
  
     // Make sure we receive the tick messages
     GetGameActorProxy().RegisterForMessages(dtGame::MessageType::TICK_LOCAL,
        dtGame::GameActorProxy::TICK_LOCAL_INVOKABLE);
  }
  
  
//////////////////////////////////////////////////////////////////////////


  void ProceduralAnimationActor::SetPoseMeshDatabase(dtAnim::PoseMeshDatabase* poseMeshDatabase)
  {
     // Is there any reason to set this a second time?
     assert(!mPoseMeshDatabase);
  
     mPoseMeshDatabase = poseMeshDatabase;
  
     // Make sure we have a utility to use on the posemesh data
     if (!mPoseMeshUtil.valid())
     {
        mPoseMeshUtil = new dtAnim::PoseMeshUtility;
     }
  
     // Get access to each individual part
     AssemblePoseData();
  }
  
  
//////////////////////////////////////////////////////////////////////////


  void ProceduralAnimationActor::SetTarget(const dtCore::Transformable* target, osg::Vec3* offset)
  {
     mCurrentTarget = target;
  
     if (offset != NULL)
     {
        mTargetOffset = *offset;
     }
  }
  
  
//////////////////////////////////////////////////////////////////////////


  void ProceduralAnimationActor::SetBlendTime(float blendTime)
  {
     mBlendTime = blendTime;
  }
  
  
//////////////////////////////////////////////////////////////////////////


  void ProceduralAnimationActor::AssemblePoseData()
  {
     mMarinePoseData.mPoseMeshes[ProceduralAnimationData::LEFT_EYE] =
        mPoseMeshDatabase->GetPoseMeshByName("Poses_LeftEye");
  
     mMarinePoseData.mPoseMeshes[ProceduralAnimationData::RIGHT_EYE] =
        mPoseMeshDatabase->GetPoseMeshByName("Poses_RightEye");
  
     mMarinePoseData.mPoseMeshes[ProceduralAnimationData::HEAD] =
        mPoseMeshDatabase->GetPoseMeshByName("Poses_Head");
  
     mMarinePoseData.mPoseMeshes[ProceduralAnimationData::TORSO] =
        mPoseMeshDatabase->GetPoseMeshByName("Poses_Torso");
  
     mMarinePoseData.mPoseMeshes[ProceduralAnimationData::GUN] =
        mPoseMeshDatabase->GetPoseMeshByName("Poses_Gun");
  }
  
  
//////////////////////////////////////////////////////////////////////////


  void ProceduralAnimationActor::OnTickLocal(const dtGame::TickMessage& tickMessage)
  {
     float dt = tickMessage.GetDeltaSimTime();
  
     // inverse kinematics
     TickIK(dt);
  
     // canned animation update
     GetHelper()->GetModelWrapper()->Update(dt);
  }
  
  
//////////////////////////////////////////////////////////////////////////


  void ProceduralAnimationActor::TickIK(float dt)
  {
     dtCore::Transform targetTransform;
     mCurrentTarget->GetTransform(targetTransform);
  
     // The 2 unit offset here is a crude approximation for this
     osg::Vec3 ownPosition = GetHeadPosition();
  
     // We might want to get a point slightly offset from the base position so add it here
     osg::Vec3 targetPosition = targetTransform.GetTranslation() + mTargetOffset;
  
     // This is the direction from us to the target
     osg::Vec3 lookDirection = targetPosition - ownPosition;
     lookDirection.normalize();
  
     osg::Vec3 actorForward = GetForwardDirection();
  
     if (mMode == MODE_WATCH)
     {
        assert(mCurrentTarget);
  
        float remAzimuth   = 0.0f;
        float remElevation = 0.0f;
  
        // Get the relative azimuth and elevation
        dtAnim::GetCelestialCoordinates(lookDirection, actorForward, remAzimuth, remElevation);
  
        // Get convenient short handles to all of our pose mesh data
        dtAnim::PoseMesh* eyeMesh1  = mMarinePoseData.mPoseMeshes[ProceduralAnimationData::LEFT_EYE];
        dtAnim::PoseMesh* eyeMesh2  = mMarinePoseData.mPoseMeshes[ProceduralAnimationData::RIGHT_EYE];
        dtAnim::PoseMesh* headMesh  = mMarinePoseData.mPoseMeshes[ProceduralAnimationData::HEAD];
        dtAnim::PoseMesh* torsoMesh = mMarinePoseData.mPoseMeshes[ProceduralAnimationData::TORSO];
  
        dtAnim::PoseMesh::TargetTriangle& eyeTarget1  = mMarinePoseData.mTargetTriangles[ProceduralAnimationData::LEFT_EYE];
        dtAnim::PoseMesh::TargetTriangle& eyeTarget2  = mMarinePoseData.mTargetTriangles[ProceduralAnimationData::RIGHT_EYE];
        dtAnim::PoseMesh::TargetTriangle& headTarget  = mMarinePoseData.mTargetTriangles[ProceduralAnimationData::HEAD];
        dtAnim::PoseMesh::TargetTriangle& torsoTarget = mMarinePoseData.mTargetTriangles[ProceduralAnimationData::TORSO];
  
        eyeMesh1->GetTargetTriangleData(remAzimuth, remElevation, eyeTarget1);
        eyeMesh2->GetTargetTriangleData(remAzimuth, remElevation, eyeTarget2);
  
        // The eyes have moved over, does the head need to move after this?
        remAzimuth   -= eyeTarget1.mAzimuth;
        remElevation -= eyeTarget2.mElevation;
  
        // The head has moved over, does the torso need to move
        headMesh->GetTargetTriangleData(remAzimuth, remElevation, headTarget);
  
        remAzimuth   -= headTarget.mAzimuth;
        remElevation -= headTarget.mElevation;
  
        torsoMesh->GetTargetTriangleData(remAzimuth, remElevation, torsoTarget);
  
        // Use the pose mesh util to apply the blends
        mPoseMeshUtil->BlendPoses(eyeMesh1, GetHelper()->GetModelWrapper(), eyeTarget1, mBlendTime);
        mPoseMeshUtil->BlendPoses(eyeMesh2, GetHelper()->GetModelWrapper(), eyeTarget2, mBlendTime);
        mPoseMeshUtil->BlendPoses(headMesh, GetHelper()->GetModelWrapper(), headTarget, mBlendTime);
        mPoseMeshUtil->BlendPoses(torsoMesh, GetHelper()->GetModelWrapper(), torsoTarget, mBlendTime);
     }
     else // we are aiming
     {
        float remAzimuth   = 0.0f;
        float remElevation = 0.0f;
  
        dtAnim::GetCelestialCoordinates(lookDirection, actorForward, remAzimuth, remElevation);
  
        dtAnim::PoseMesh* gunMesh = mMarinePoseData.mPoseMeshes[ProceduralAnimationData::GUN];
        dtAnim::PoseMesh::TargetTriangle& gunTarget = mMarinePoseData.mTargetTriangles[ProceduralAnimationData::GUN];
  
        gunMesh->GetTargetTriangleData(remAzimuth, remElevation, gunTarget);
        mPoseMeshUtil->BlendPoses(gunMesh, GetHelper()->GetModelWrapper(), gunTarget, mBlendTime);
  
        // Only shoot when in sight and standing still
        if (gunTarget.mIsInside)
        {
           // do something here?
        }
        else
        {
           float rotationSign = 1.0f;
  
           // Determine which direction to rotate toward
           if ((lookDirection ^ actorForward).z() > 0.0f)
           {
              rotationSign = -1.0f;
           }
  
           dtCore::Transform currentTransform;
           GetTransform(currentTransform);
  
           osg::Vec3 hpr;
           currentTransform.GetRotation(hpr);
  
           // Start rotating closer to putting the target in reach
           hpr.x() += 100.0f * dt * rotationSign;
           currentTransform.SetRotation(hpr);
           SetTransform(currentTransform);
        }
     }
  }
  
  
//////////////////////////////////////////////////////////////////////////


  void ProceduralAnimationActor::AddedToScene(dtCore::Scene* scene)
  {
     dtAnim::AnimationGameActor::AddedToScene(scene);
  }
  
  
//////////////////////////////////////////////////////////////////////////


  osg::Vec3 ProceduralAnimationActor::GetPoseMeshEndEffectorDirection(const dtAnim::PoseMesh* poseMesh) const
  {
     const dtAnim::Cal3DModelWrapper* modelWrapper = GetHelper()->GetModelWrapper();
  
     // If we have the ik system attached
     if (poseMesh != NULL)
     {
        osg::Quat boneRotation = modelWrapper->GetBoneAbsoluteRotation(poseMesh->GetEffectorID());
        osg::Vec3 nativeBoneForward = poseMesh->GetEffectorForwardAxis();
  
        dtCore::Transform transform;
        GetTransform(transform);
  
        osg::Matrix modelRotation;
        transform.GetRotation(modelRotation);
  
        // Get the direction the head is facing
        osg::Vec3 boneDirection = boneRotation * nativeBoneForward;
        boneDirection = boneDirection * modelRotation;
  
        osg::Quat rotationCorrection(osg::DegreesToRadians(180.0f), osg::Z_AXIS);
        return rotationCorrection * boneDirection;
     }
  
     return GetForwardDirection();
  }
  
  
//////////////////////////////////////////////////////////////////////////


  dtAnim::Cal3DModelWrapper* ProceduralAnimationActor::GetModelWrapper()
  {
     return GetHelper()->GetModelWrapper();
  }
  
  
//////////////////////////////////////////////////////////////////////////


  osg::Vec3 ProceduralAnimationActor::GetForwardDirection() const
  {
     dtCore::Transform currentTransform;
     GetTransform(currentTransform);
  
     osg::Matrix matrix;
     currentTransform.Get(matrix);
  
     // Many characters face backwards so we negate the forward direction
     return -osg::Vec3(matrix(1, 0), matrix(1, 1), matrix(1, 2));
  }
  
  
//////////////////////////////////////////////////////////////////////////


  osg::Vec3 ProceduralAnimationActor::GetGazeDirection() const
  {
     dtAnim::PoseMesh* headMesh = mMarinePoseData.mPoseMeshes[ProceduralAnimationData::HEAD];
  
     if (headMesh)
     {
        return GetPoseMeshEndEffectorDirection(headMesh);
     }
     else
     {
        return GetForwardDirection();
     }
  }
  
  
//////////////////////////////////////////////////////////////////////////


  osg::Vec3 ProceduralAnimationActor::GetGunDirection() const
  {
     dtAnim::PoseMesh* gunMesh = mMarinePoseData.mPoseMeshes[ProceduralAnimationData::GUN];
     return GetPoseMeshEndEffectorDirection(gunMesh);
  }
  
  
//////////////////////////////////////////////////////////////////////////


  osg::Vec3 ProceduralAnimationActor::GetGunPosition() const
  {
     const dtAnim::Cal3DModelWrapper* modelWrapper = GetHelper()->GetModelWrapper();
     dtAnim::PoseMesh* gunMesh = mMarinePoseData.mPoseMeshes[ProceduralAnimationData::GUN];
  
     dtCore::Transform transform;
     GetTransform(transform);
  
     osg::Matrix rotation;
     osg::Vec3 translation;
     transform.GetRotation(rotation);
     transform.GetTranslation(translation);
  
     // Get the bone position relative to its root
     osg::Vec3 bonePosition = modelWrapper->GetBoneAbsoluteTranslation(gunMesh->GetEffectorID());
  
     // Get the gun position in the world
     osg::Quat rotationCorrection(osg::DegreesToRadians(180.0f), osg::Z_AXIS);
     bonePosition  = rotationCorrection * (bonePosition * rotation);
     bonePosition += translation;
  
     return bonePosition;
  }
  
  
//////////////////////////////////////////////////////////////////////////


  // This could be more efficient
  osg::Vec3 ProceduralAnimationActor::GetWorldPosition() const
  {
     dtCore::Transform transform;
     GetTransform(transform);
  
     osg::Vec3 translation;
     transform.GetTranslation(translation);
  
     return translation;
  }
  
  
//////////////////////////////////////////////////////////////////////////


  osg::Vec3 ProceduralAnimationActor::GetHeadPosition() const
  {
     const dtAnim::Cal3DModelWrapper* modelWrapper = GetHelper()->GetModelWrapper();
     dtAnim::PoseMesh* headMesh = mMarinePoseData.mPoseMeshes[ProceduralAnimationData::HEAD];
  
     dtCore::Transform transform;
     GetTransform(transform);
  
     osg::Matrix rotation;
     osg::Vec3 translation;
     transform.GetRotation(rotation);
     transform.GetTranslation(translation);
  
     // Get the bone position relative to its root
     osg::Vec3 bonePosition = modelWrapper->GetBoneAbsoluteTranslation(headMesh->GetEffectorID());
  
     // Get the gun position in the world
     bonePosition  = bonePosition * rotation;
     bonePosition += translation;
  
     return bonePosition;
  }
  
  
//////////////////////////////////////////////////////////////////////////