/* -*-c++-*-
   * Delta3D Open Source Game and Simulation Engine
   * Copyright (C) 2006, Alion Science and Technology, BMH Operation
   *
   * 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
   *
   * William E. Johnson II
   */
  
  include <fireFighter/hatchactor.h>
  include <fireFighter/gamelevelactor.h>
  include <fireFighter/entityactorregistry.h>
  include <dtAudio/audiomanager.h>
  include <dtGame/gamemanager.h>
  include <dtGame/basemessages.h>
  include <dtGame/invokable.h>
  include <dtDAL/gameeventmanager.h>
  include <dtDAL/actorproperty.h>
  include <dtDAL/enginepropertytypes.h>
  include <fireFighter/messagetype.h>
  include <osg/MatrixTransform>
  
  using dtCore::RefPtr;
  
  static osg::Node* FindNamedNode(const std::string& searchName, osg::Node* currNode)
  {
     osg::Group* currGroup = NULL;
     osg::Node*  foundNode = NULL;
  
     // check to see if we have a valid (non-NULL) node.
     // if we do have a null node, return NULL.
     if (currNode == NULL)
     {
        return NULL;
     }
  
     // We have a valid node, check to see if this is the node we
     // are looking for. If so, return the current node.
     if (currNode->getName() == searchName)
     {
        return currNode;
     }
  
     // We have a valid node, but not the one we are looking for.
     // Check to see if it has children (non-leaf node). If the node
     // has children, check each of the child nodes by recursive call.
     // If one of the recursive calls returns a non-null value we have
     // found the correct node, so return this node.
     // If we check all of the children and have not found the node,
     // return NULL
     currGroup = currNode->asGroup(); // returns NULL if not a group.
     if (currGroup != NULL)
     {
        for (unsigned int i = 0; i < currGroup->getNumChildren(); i++)
        {
           foundNode = FindNamedNode(searchName, currGroup->getChild(i));
           if (foundNode != NULL)
           {
              return foundNode; // found a match!
           }
        }
        return NULL; // We have checked each child node - no match found.
     }
     else
     {
        return NULL; // leaf node, no match
     }
  }
  
  
//////////////////////////////////////////


  HatchActorProxy::HatchActorProxy()
  {
  
  }
  
  HatchActorProxy::~HatchActorProxy()
  {
  
  }
  
  void HatchActorProxy::BuildPropertyMap()
  {
     GameItemActorProxy::BuildPropertyMap();
  }
  
  void HatchActorProxy::BuildInvokables()
  {
     GameItemActorProxy::BuildInvokables();
  }
  
  
//////////////////////////////////////////


  
  HatchActor::HatchActor(dtGame::GameActorProxy& proxy)
     : GameItemActor(proxy)
     , mHatchNode(NULL)
     , mGameMapLoaded(false)
  {
  
  }
  
  HatchActor::~HatchActor()
  {
  
  }
  
  void HatchActor::OnEnteredWorld()
  {
     GameItemActor::OnEnteredWorld();
  
     dtGame::Invokable* invoke = new dtGame::Invokable("MapLoaded",
        dtDAL::MakeFunctor(*this, &HatchActor::OnMapLoaded));
  
     GetGameActorProxy().AddInvokable(*invoke);
  
     GetGameActorProxy().RegisterForMessages(dtGame::MessageType::INFO_MAP_LOADED, "MapLoaded");
     GetGameActorProxy().RegisterForMessages(dtGame::MessageType::INFO_MAP_UNLOADED, "MapLoaded");
  }
  
  void HatchActor::Activate(bool enable)
  {
     GameItemActor::Activate(enable);
  
     // If we are in STAGE, we have a NULL game manager. So peace out of here
     if (GetGameActorProxy().IsInSTAGE())
     {
        return;
     }
  
     if (mHatchNode != NULL)
     {
        // Open or close the door
        osg::Matrix rotMat;
        const float deg = IsActivated() ? -105.0f : 105.0f;
  
        rotMat.makeRotate(
           osg::DegreesToRadians(0.0f), osg::Vec3(1.0f, 0.0f, 0.0f),
           osg::DegreesToRadians(0.0f), osg::Vec3(0.0f, 1.0f, 0.0f),
           osg::DegreesToRadians(deg),  osg::Vec3(0.0f, 0.0f, 1.0f));
  
        mHatchNode->preMult(rotMat);
     }
  
     if (mGameMapLoaded && !IsActivated())
     {
        PlayItemUseSnd();
     }
  
     // Special case. Since Activate(bool) is a property that is utilized in
     // STAGE, this function is called once on startup to initialize the
     // properties. When this happens, the game manager has not be initialized
     // or something. It comes back with a weird memory address and outright
     // crashes. This doesn't occur in other versions of Activate(bool) because
     // the base class version does not send a message. That behavior is handled
     // in the player class.
     if (mGameMapLoaded)
     {
        dtGame::GameManager& mgr = *GetGameActorProxy().GetGameManager();
  
        RefPtr<dtGame::Message> msg =
           mgr.GetMessageFactory().CreateMessage(enable ? MessageType::ITEM_ACTIVATED :
                                                          MessageType::ITEM_DEACTIVATED);
  
        msg->SetAboutActorId(GetUniqueId());
        mgr.SendMessage(*msg);
     }
  
     const std::string& name = "OpenHatch";
  
     // No event, peace out
     if (!IsActivated())
     {
        return;
     }
  
     dtDAL::GameEvent* event = dtDAL::GameEventManager::GetInstance().FindEvent(name);
     if (event == NULL)
     {
        throw dtUtil::Exception("Failed to find the game event: " + name, __FILE__, __LINE__);
     }
  
     dtGame::GameManager& mgr = *GetGameActorProxy().GetGameManager();
     RefPtr<dtGame::Message> msg =
        mgr.GetMessageFactory().CreateMessage(dtGame::MessageType::INFO_GAME_EVENT);
  
     dtGame::GameEventMessage& gem = static_cast<dtGame::GameEventMessage&>(*msg);
     gem.SetGameEvent(*event);
     mgr.SendMessage(gem);
  }
  
  void HatchActor::OnMapLoaded(const dtGame::Message& msg)
  {
     if (msg.GetMessageType() == dtGame::MessageType::INFO_MAP_LOADED)
     {
        const dtGame::MapMessage& mlm = static_cast<const dtGame::MapMessage&>(msg);
        std::vector<std::string> mapNames;
        mlm.GetMapNames(mapNames);
        if (!mapNames.empty() && mapNames[0] == "GameMap")
        {
           mGameMapLoaded = true;
           // Find the game level actor and search with its node
           std::vector<dtDAL::ActorProxy*> proxies;
           GetGameActorProxy().GetGameManager()->FindActorsByType(*EntityActorRegistry::TYPE_GAME_LEVEL_ACTOR, proxies);
           GameLevelActor* gla = dynamic_cast<GameLevelActor*>(proxies[0]->GetActor());
           if (gla == NULL)
           {
              LOG_ERROR("Failed to find the game level actor in the map. Unable to open or close the hatch door");
           }
           else
           {
              osg::Node* hatchNode = FindNamedNode("HatchEngr", gla->GetOSGNode());
              mHatchNode = dynamic_cast<osg::MatrixTransform*>(hatchNode);
              if (mHatchNode == NULL)
              {
                 LOG_ERROR("Failed to find the hatch node in the game level.");
              }
           }
        }
     }
     else if (msg.GetMessageType() == dtGame::MessageType::INFO_MAP_UNLOADED)
     {
        const dtGame::MapMessage& mlm = static_cast<const dtGame::MapMessage&>(msg);
        std::vector<std::string> mapNames;
        mlm.GetMapNames(mapNames);
        if (!mapNames.empty() && mapNames[0] == "GameMap")
        {
           mGameMapLoaded = false;
        }
     }
     else
     {
        LOG_ERROR("Received a message of incorrect type: " + msg.GetMessageType().GetName());
     }
  }