/* -*-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.
*
* Curtiss Murphy
*/
#include "testgamepropertyproxy.h"
#include <dtDAL/enginepropertytypes.h>
#include <dtActors/deltaobjectactorproxy.h>
#include <dtCore/scene.h>
#include <dtCore/object.h>
#include <dtUtil/log.h>
#include <sstream>

using namespace dtCore;
using namespace dtDAL;
using namespace dtActors;

const std::string TestGamePropertyProxy::GROUPNAME("Example Game Properties");

IMPLEMENT_ENUM(TestGamePropertyActor::TestEnum);
TestGamePropertyActor::TestEnum TestGamePropertyActor::TestEnum::OPTION1("My First Option");
TestGamePropertyActor::TestEnum TestGamePropertyActor::TestEnum::OPTION2("Cool Stuff");
TestGamePropertyActor::TestEnum TestGamePropertyActor::TestEnum::OPTION3("123");
TestGamePropertyActor::TestEnum TestGamePropertyActor::TestEnum::OPTION4("Why a spoon cousin?  Because it'll hurt more.");
TestGamePropertyActor::TestEnum TestGamePropertyActor::TestEnum::OPTION5("733T H@X0R !N D37T@3D!");
TestGamePropertyActor::TestEnum TestGamePropertyActor::TestEnum::OPTION6("Mind what you have learned, save you it can");


//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
TestGamePropertyActor::TestGamePropertyActor(dtGame::GameActorProxy& proxy):
   dtGame::GameActor(proxy),
   mInt(0),
   mReadOnlyInt(5),
   mFloat(0.0f),
   mDouble(0.0),
   mLong(0),
   mBool(0),
   mString(""),
   mEnum(&TestEnum::OPTION1)
{
}

//////////////////////////////////////////////////////////////////////////////
TestGamePropertyActor::~TestGamePropertyActor()
{
}

//////////////////////////////////////////////////////////////////////////////
void TestGamePropertyActor::OnTickLocal(const dtGame::TickMessage& tickMessage)
{
   //const dtGame::TickMessage &tick =
   //   static_cast<const dtGame::TickMessage&>(tickMessage);

   // increment a message counter
   mInt++;
}

//////////////////////////////////////////////////////////////////////////////
void TestGamePropertyActor::OnTickRemote(const dtGame::TickMessage& tickMessage)
{
   //const dtGame::TickMessage &tick =
   //   static_cast<const dtGame::TickMessage&>(tickMessage);

   // increment a message counter
   mInt++;
}

void TestGamePropertyActor::ProcessMessage(const dtGame::Message &tickMessage)
{
   //const dtGame::TickMessage &tick =
   //   static_cast<const dtGame::TickMessage&>(tickMessage);

   // increment a message counter
   mInt++;
}


//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
TestGamePropertyProxy::TestGamePropertyProxy() :
   mRegisterListeners(false),
   mWasRemovedFromWorld(false)
{
   //static int count = 0;
   //std::ostringstream ss;

   SetClassName("dtCore::TestGamePropertyProxy");
}

//////////////////////////////////////////////////////////////////////////////
void TestGamePropertyProxy::BuildPropertyMap()
{
   GameActorProxy::BuildPropertyMap();

   TestGamePropertyActor& actor = static_cast<TestGamePropertyActor &>(GetGameActor());

   AddProperty(new BooleanActorProperty("Test_Boolean", "Test Boolean",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestBool),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestBool),
      "Holds a test Boolean property", GROUPNAME));

   AddProperty(new IntActorProperty("Test_Int", "Test Int",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestInt),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestInt),
      "Holds a test Int property", GROUPNAME));

   dtDAL::IntActorProperty *i = new IntActorProperty("Test_Read_Only_Int", "Test_Read_Only_Int",
      MakeFunctor(actor, &TestGamePropertyActor::SetReadOnlyTestInt),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetReadOnlyTestInt),
      "Holds a test Read Only Int property", GROUPNAME);
   i->SetReadOnly(true);
   AddProperty(i);

   AddProperty(new LongActorProperty("Test_Long", "Test Long",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestLong),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestLong),
      "Holds a test Long property", GROUPNAME));

   AddProperty(new FloatActorProperty("Test_Float", "Test Float",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestFloat),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestFloat),
      "Holds a test Float property", GROUPNAME));

   AddProperty(new DoubleActorProperty("Test_Double", "Test Double",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestDouble),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestDouble),
      "Holds a test Double property", GROUPNAME));

   AddProperty(new Vec3ActorProperty("Test_Vec3", "Test Vector3",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestVec3),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestVec3),
      "Holds a test Vector3 Property", GROUPNAME));

   AddProperty(new Vec2ActorProperty("Test_Vec2", "Test Vector2",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestVec2),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestVec2),
      "Holds a test Vector2 Property", GROUPNAME));

   AddProperty(new Vec4ActorProperty("Test_Vec4", "Test Vector4",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestVec4),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestVec4),
      "Holds a test Vector4 Property", GROUPNAME));

   AddProperty(new Vec3fActorProperty("Test_Vec3f", "Test Vector3f",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestVec3f),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestVec3f),
      "Holds a test Vector3f Property", GROUPNAME));

   AddProperty(new Vec2fActorProperty("Test_Vec2f", "Test Vector2f",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestVec2f),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestVec2f),
      "Holds a test Vector2f Property", GROUPNAME));

   AddProperty(new Vec4fActorProperty("Test_Vec4f", "Test Vector4f",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestVec4f),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestVec4f),
      "Holds a test Vector4f Property", GROUPNAME));

   AddProperty(new Vec3dActorProperty("Test_Vec3d", "Test Vector3d",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestVec3d),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestVec3d),
      "Holds a test Vector3d Property", GROUPNAME));

   AddProperty(new Vec2dActorProperty("Test_Vec2d", "Test Vector2d",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestVec2d),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestVec2d),
      "Holds a test Vector2d Property", GROUPNAME));

   AddProperty(new Vec4dActorProperty("Test_Vec4d", "Test Vector4d",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestVec4d),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestVec4d),
      "Holds a test Vector4d Property", GROUPNAME));

   AddProperty(new StringActorProperty("Test_String", "Test String",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestString),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestString),
      "Holds a test String property (unlimited length)", GROUPNAME));

   StringActorProperty *stringProp = new StringActorProperty("Test_String2", "Test String (max 10)",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestStringWithLength),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestStringWithLength),
      "Holds a test String property with a max length of 10", GROUPNAME);
   stringProp->SetMaxLength(10);
   AddProperty(stringProp);

   AddProperty(new ColorRgbaActorProperty("Test_Color", "Test Color",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestColor),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestColor),
      "Holds a test Color property", GROUPNAME));

   AddProperty(new EnumActorProperty<TestGamePropertyActor::TestEnum>("Test_Enum", "Test Enum",
      MakeFunctor(actor, &TestGamePropertyActor::SetTestEnum),
      MakeFunctorRet(actor, &TestGamePropertyActor::GetTestEnum),
      "Holds a test Enum property", GROUPNAME));

   //AddProperty(new ResourceActorProperty(*this, DataType::SOUND, "Test_Sound_Resource", "Test Sound",
   //   MakeFunctor(actor, &TestGamePropertyActor::SetSoundResourceName),
   //   "An example sound resource property", GROUPNAME));

   //AddProperty(new ResourceActorProperty(*this, DataType::TEXTURE, "Test_Texture_Resource", "Texture",
   //   MakeFunctor(actor, &TestGamePropertyActor::SetTextureResourceName),
   //   "An example texture resource property", GROUPNAME));

   AddProperty(new ActorIDActorProperty(*this, "Test_Actor_Id", "Test Actor Id",
      dtDAL::ActorIDActorProperty::SetFuncType(&actor, &TestGamePropertyActor::SetTestActorId),
      dtDAL::ActorIDActorProperty::GetFuncType(&actor, &TestGamePropertyActor::GetTestActorId),
      "dtCore::Transformable",
      "An example linked actor property", GROUPNAME));

   AddProperty(new GameEventActorProperty(*this, "TestGameEvent", "Test Game Event",
               MakeFunctor(actor, &TestGamePropertyActor::SetTestGameEvent),
               MakeFunctorRet(actor, &TestGamePropertyActor::GetTestGameEvent),
               "Holds a test game event property", GROUPNAME));
}

//////////////////////////////////////////////////////////////////////////////
void TestGamePropertyProxy::CreateActor()
{
   SetActor(*new TestGamePropertyActor(*this));
}

//////////////////////////////////////////////////////////////////////////////
void TestGamePropertyProxy::OnEnteredWorld()
{
   if (mRegisterListeners)
   {
      //Register an invokable for Game Events...
      RegisterForMessages(dtGame::MessageType::INFO_GAME_EVENT);

      // Register an invokable for tick messages. Local or Remote only, not both!
      if (IsRemote())
         RegisterForMessages(dtGame::MessageType::TICK_REMOTE, dtGame::GameActorProxy::TICK_REMOTE_INVOKABLE);
      else
         RegisterForMessages(dtGame::MessageType::TICK_LOCAL, dtGame::GameActorProxy::TICK_LOCAL_INVOKABLE);
   }

   dtGame::GameActorProxy::OnEnteredWorld();
}

//////////////////////////////////////////////////////////////////////////////
void TestGamePropertyProxy::OnRemovedFromWorld()
{
   mWasRemovedFromWorld = true;
}