/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "plClothingSDLModifier.h"
#include "plAvatarClothing.h"
#include "plClothingLayout.h"
#include "plArmatureMod.h"

#include "../pnSceneObject/plSceneObject.h"
#include "../pnMessage/plSDLModifierMsg.h"
#include "../plSDL/plSDL.h"
#include "../pnKeyedObject/plKeyImp.h"

// static vars
char plClothingSDLModifier::kStrItem[]="item";
char plClothingSDLModifier::kStrTint[]="tint";
char plClothingSDLModifier::kStrTint2[]="tint2";
char plClothingSDLModifier::kStrWardrobe[]="wardrobe";
char plClothingSDLModifier::kStrSkinTint[]="skinTint";
char plClothingSDLModifier::kStrFaceBlends[]="faceBlends";
char plClothingSDLModifier::kStrAppearance[]="appearance";
char plClothingSDLModifier::kStrClothingDescName[]="clothingItem";
char plClothingSDLModifier::kStrAppearanceDescName[]="appearanceOptions";
char plClothingSDLModifier::kStrLinkInAnim[] = "linkInAnim";

//
// init latest data
//
plClothingSDLModifier::plClothingSDLModifier() :
	fClothingOutfit(nil)
{
}

//
// find armature mod and cache it's clothingOutfit	
//
plClothingOutfit* plClothingSDLModifier::GetClothingOutfit()
{
	if (fClothingOutfit)
		return fClothingOutfit;

	int i;
	plSceneObject* target = GetTarget();
	hsAssert(target, "plClothingSDLModifier: nil target");
	for (i=0;i<target->GetNumModifiers();i++)
	{
		const plArmatureMod* am = plArmatureMod::ConvertNoRef(target->GetModifier(i));
		if (am)
		{
			fClothingOutfit=am->GetClothingOutfit();
			break;
		}
	}

	return fClothingOutfit;
}

void plClothingSDLModifier::PutCurrentStateIn(plStateDataRecord* dstState)
{
	IPutCurrentStateIn(dstState);
}

//
// get current state from clothingOutfit and put it in dstState
//
void plClothingSDLModifier::IPutCurrentStateIn(plStateDataRecord* dstState)
{
	plSceneObject* sobj=GetTarget();
	hsAssert(sobj, "plClothingSDLModifier, nil target");
	
	plClothingOutfit* clothing = GetClothingOutfit();
	hsAssert(clothing, "nil clothingOutfit");
	
	hsTArray<plStateDataRecord*> SDRs;
	hsTArray<plClothingItem*> items=clothing->GetItemList();
	hsTArray<plClothingItemOptions*> options=clothing->GetOptionList();
	
	plSDStateVariable* clothesStateDesc = dstState->FindSDVar(kStrWardrobe);	// find clothes list
	int itemCount=items.GetCount();
	int optionsCount = options.GetCount();
	hsAssert(optionsCount==itemCount, "number of items should match number of options according to clothing.sdl"); 
	
	if (clothesStateDesc->GetCount() != itemCount)
		clothesStateDesc->Alloc(itemCount);		// set appropriate list size

	int lowerCount = (itemCount <= optionsCount ? itemCount : optionsCount);
	int i;
	for(i = 0; i < lowerCount; i++)
	{
		plClosetItem closetItem;
		closetItem.fItem = items[i];
		closetItem.fOptions = *options[i];

		PutSingleItemIntoSDR(&closetItem, clothesStateDesc->GetStateDataRecord(i));
		SDRs.Append(clothesStateDesc->GetStateDataRecord(i));
	}

	// skin tint
	plSDStateVariable* appearanceStateDesc = dstState->FindSDVar(kStrAppearance); // for skin tint
	UInt8 skinTint[3];
	skinTint[0] = (UInt8)(clothing->fSkinTint.r * 255);
	skinTint[1] = (UInt8)(clothing->fSkinTint.g * 255);
	skinTint[2] = (UInt8)(clothing->fSkinTint.b * 255);
	appearanceStateDesc->GetStateDataRecord(0)->FindVar(kStrSkinTint)->Set(skinTint);

	plSimpleStateVariable* faceBlends = appearanceStateDesc->GetStateDataRecord(0)->FindVar(kStrFaceBlends);
	int numBlends = plClothingElement::kLayerSkinLast - plClothingElement::kLayerSkinFirst;
	if (faceBlends->GetCount() != numBlends)
		faceBlends->Alloc(numBlends);
	for(i = 0; i < numBlends; i++)
		faceBlends->Set((UInt8)(clothing->fSkinBlends[i] * 255), i);

	SDRs.Append(appearanceStateDesc->GetStateDataRecord(0));

	// This logically belongs in the avatar.sdl file, but clothing.sdl is already broadcast to
	// other players when you join an age, and I don't want to broadcast all of avatar.sdl for
	// just this one value.
	plSimpleStateVariable *var = dstState->FindVar(kStrLinkInAnim);
	if (var)
		var->Set(clothing->fAvatar->fLinkInAnimKey);	
}

void plClothingSDLModifier::PutSingleItemIntoSDR(plClosetItem *item, plStateDataRecord *sdr)
{
	plKey key = item->fItem->GetKey();
	sdr->FindVar(kStrItem)->Set(key);			

	//hsColorRGBA c = item->fOptions.fTint1;
	//hsColorRGBA c2 = item->fOptions.fTint2;
	UInt8 c[3];
	UInt8 c2[3];
	c[0] = (UInt8)(item->fOptions.fTint1.r * 255);
	c[1] = (UInt8)(item->fOptions.fTint1.g * 255);
	c[2] = (UInt8)(item->fOptions.fTint1.b * 255);
	c2[0] = (UInt8)(item->fOptions.fTint2.r * 255);
	c2[1] = (UInt8)(item->fOptions.fTint2.g * 255);
	c2[2] = (UInt8)(item->fOptions.fTint2.b * 255);
	
	sdr->FindVar(kStrTint)->Set(c);
	sdr->FindVar(kStrTint2)->Set(c2);
}

//
// Apply the SDL state that is passed in to the current clothing state.
//
void plClothingSDLModifier::ISetCurrentStateFrom(const plStateDataRecord* srcState)
{
	plSceneObject* sobj=GetTarget();
	hsAssert(sobj, "plClothingSDLModifier, nil target");

	plClothingOutfit* clothing = GetClothingOutfit();
	if( clothing == nil )
	{
		hsAssert(clothing, "nil clothingOutfit");
		return;
	}

	plSDStateVariable* clothesStateDesc = srcState->FindSDVar(kStrWardrobe);	// find clothes list
	int num=clothesStateDesc->GetCount();	// size of clothes list
	bool update=true;

	// We just remove the accessories. Any regular items will be replaced
	// when we try to wear something else in the same category. (And in
	// case the player lies, this guarantees they'll at least be wearing something.)
	clothing->StripAccessories();

	int i;
	for(i=0;i<num;i++)
	{
		// get clothes item from clothes list
		plStateDataRecord* clothingItemState=clothesStateDesc->GetStateDataRecord(i);
		HandleSingleSDR(clothingItemState, clothing);
	}

	plSDStateVariable* appearanceStateDesc = srcState->FindSDVar(kStrAppearance); // for skin tint
	plStateDataRecord* appearanceState = appearanceStateDesc->GetStateDataRecord(0);
	HandleSingleSDR(appearanceState, clothing);

	if (update)
		clothing->ForceUpdate(true /* retry */);

	plSimpleStateVariable *var;
	var = srcState->FindVar(kStrLinkInAnim);
	if (var)
		var->Get(&clothing->fAvatar->fLinkInAnimKey);	
}

void plClothingSDLModifier::HandleSingleSDR(const plStateDataRecord *sdr, plClothingOutfit *clothing /* = nil */, plClosetItem *closetItem /* = nil */)
{
	if (sdr == nil)
		return;

	int i;
	UInt8 tint[3];
	hsScalar tintScalar[3];
	if (!strcmp(sdr->GetDescriptor()->GetName(), kStrClothingDescName))
	{
		// get item from clothesItem
		plSimpleStateVariable* itemVar = sdr->FindVar(kStrItem);
		plClothingItem* clothingItem = nil;	// clothing->GetItemList()[i];
		if (itemVar->IsUsed())
		{
			plKey key;
			itemVar->Get(&key);
			clothingItem = plClothingItem::ConvertNoRef(key ? key->GetObjectPtr() : nil);
			if (clothingItem)
			{
				if (clothing)
					clothing->AddItem(clothingItem, false, false /*bcast */); 
				if (closetItem)
					closetItem->fItem = clothingItem;
			}
		}

		// tints
		if (clothingItem)
		{
			// get item from clothesItem
			plSimpleStateVariable* tintVar = sdr->FindVar(kStrTint);
			if (tintVar->IsUsed())
			{
				tintVar->Get(tint);
				tintScalar[0] = tint[0] / 255.f;
				tintScalar[1] = tint[1] / 255.f;
				tintScalar[2] = tint[2] / 255.f;
				if (clothing)
					clothing->TintItem(clothingItem, tintScalar[0], tintScalar[1], tintScalar[2],
									   false /*update*/, false /*broadcast*/, false /*netForce*/, true, plClothingElement::kLayerTint1);
				if (closetItem)
					closetItem->fOptions.fTint1.Set(tintScalar[0], tintScalar[1], tintScalar[2], 1.f);
			}

			tintVar=sdr->FindVar(kStrTint2);
			if (tintVar->IsUsed())
			{
				tintVar->Get(tint);
				tintScalar[0] = tint[0] / 255.f;
				tintScalar[1] = tint[1] / 255.f;
				tintScalar[2] = tint[2] / 255.f;
				
				if (clothing)
					clothing->TintItem(clothingItem, tintScalar[0], tintScalar[1], tintScalar[2],
									   false /*update*/, false /*broadcast*/, false /*netForce*/, true, plClothingElement::kLayerTint2);
				if (closetItem)
					closetItem->fOptions.fTint2.Set(tintScalar[0], tintScalar[1], tintScalar[2], 1.f);
			}
		}
	}
	else if (!strcmp(sdr->GetDescriptor()->GetName(), kStrAppearanceDescName))
	{
		// skin tints
		plSimpleStateVariable* skinVar = sdr->FindVar(kStrSkinTint);
		if (skinVar->IsUsed())
		{
			skinVar->Get(tint);
			if (clothing)
				clothing->TintSkin(tint[0] / 255.f, tint[1] / 255.f, tint[2] / 255.f, false /* update */, false /*broadcast*/);
		}
		plSimpleStateVariable* faceBlends = sdr->FindVar(kStrFaceBlends);
		if (faceBlends->IsUsed())
		{
			int numBlends = plClothingElement::kLayerSkinLast - plClothingElement::kLayerSkinFirst;
			for(i = 0; i < numBlends && i < faceBlends->GetCount(); i++)
			{
				UInt8 blend;
				faceBlends->Get(&blend, i);
				clothing->fSkinBlends[i] = (hsScalar)blend / 255;
			}
		}		
	}
}

// FINDARMATUREMOD
const plClothingSDLModifier *plClothingSDLModifier::FindClothingSDLModifier(const plSceneObject *obj)
{
	int count = obj->GetNumModifiers();

	for (int i = 0; i < count; i++)
	{
		const plModifier *mod = obj->GetModifier(i);
		const plClothingSDLModifier *sdlMod = plClothingSDLModifier::ConvertNoRef(mod);
		if(sdlMod)
			return sdlMod;
	}
	return nil;
}