/* Copyright (C) 2011 Greg Hendrickson (LordGregGreg Back)
   
   This 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 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 Lesser General Public
   License along with the viewer; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

#include "llviewerprecompiledheaders.h"
#include "lggcontactsets.h"
#include "llsdserialize.h"
#include "llboost.h"
#include "llcontrol.h"
#include "llviewercontrol.h"
#include "llnotifications.h"
#include "lldir.h"
#include "llcallingcard.h"
#include "llavatarnamecache.h"
#include "rlvhandler.h"

LGGContactSets* LGGContactSets::sInstance;

LGGContactSets::LGGContactSets()
{
	sInstance = this;
	sInstance->loadFromDisk();
}

LGGContactSets::~LGGContactSets()
{
	sInstance = NULL;
}

LGGContactSets* LGGContactSets::getInstance()
{
	if(sInstance)return sInstance;
	else
	{
		sInstance = new LGGContactSets();
		return sInstance;
	}
}
LLColor4 LGGContactSets::toneDownColor(LLColor4 inColor, float strength, bool usedForBackground)
{
	if(usedForBackground)
	{
		if(strength<.4f)strength=.4f;
		static LLCachedControl<S32> maxAlphaInt(gSavedSettings,"FSContactSetsMaxColorStrength");
		strength *= ((F32)maxAlphaInt/100.0f);
	}
	

	return LLColor4(LLColor3(inColor),strength);
}
bool LGGContactSets::callbackAliasReset(const LLSD& notification, const LLSD& response)
{
	S32 option = LLNotification::getSelectedOption(notification, response);
	if (option == 0)
	{
		LGGContactSets::getInstance()->clearPseudonym(notification["payload"]["agent_id"].asUUID());
	}
	else
	{

	}
	return false;
}
void LGGContactSets::save()
{
	saveToDisk(mContactSets);
}
std::string LGGContactSets::getFileName()
{
	std::string path=gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "");

	if (!path.empty())
	{
		path = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "settings_friends_groups.xml");
	}
	return path;  
}
std::string LGGContactSets::getOldFileName()
{
	std::string path = gDirUtilp->getOSUserDir()+gDirUtilp->getDirDelimiter()+"SecondLife"+gDirUtilp->getDirDelimiter();
	
	std::string normalPath=gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "");
	//we want to steal the last directory off this one
	std::string userNameDir = normalPath.substr(normalPath.find_last_of(gDirUtilp->getDirDelimiter()));
	path+=userNameDir;

	if (!path.empty())
	{
		path=path+gDirUtilp->getDirDelimiter()+"settings_friends_groups.xml";
	}
	llinfos << "returning a old path name of  "<<path.c_str() << llendl;
	return path;
}
std::string LGGContactSets::getDefaultFileName()
{
	std::string path=gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "");

	if (!path.empty())
	{
		path = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "settings_friends_groups.xml");
	}
	return path;  
}
LLSD LGGContactSets::exportGroup(std::string groupName)
{
	LLSD toReturn;
	if(mContactSets.has(groupName))
	{
		toReturn["groupname"]=groupName;
		toReturn["color"]=mContactSets[groupName]["color"];
		toReturn["notices"]=mContactSets[groupName]["notices"];
		toReturn["friends"]=mContactSets[groupName]["friends"];
	}
	return toReturn;
}
LLSD LGGContactSets::getContactSets()
{
	//loadFromDisk();
	return mContactSets;
}
void LGGContactSets::loadFromDisk()
{
	std::string filename=getFileName();
	if (filename.empty())
	{
		llinfos << "no valid user directory." << llendl; 
	}
	if(!gDirUtilp->fileExists(filename))
	{
		//try to find the phoenix file to load
		std::string phoenixFileName = getOldFileName();
		if(gDirUtilp->fileExists(phoenixFileName))
		{
			LLSD blankllsd;
			llifstream file;
			file.open(phoenixFileName.c_str());
			if (file.is_open())
			{
				LLSDSerialize::fromXMLDocument(blankllsd, file);
			}
			file.close();
			saveToDisk(blankllsd);
		}else
		{
			std::string defaultName = getDefaultFileName();
			llinfos << " user settings file doesnt exist, going to try and read default one from "<<defaultName.c_str()<< llendl;

			if(gDirUtilp->fileExists(defaultName))
			{
				LLSD blankllsd;
				llifstream file;
				file.open(defaultName.c_str());
				if (file.is_open())
				{
					LLSDSerialize::fromXMLDocument(blankllsd, file);
				}
				file.close();
				saveToDisk(blankllsd);
			}else
				saveToDisk(mContactSets);
		}
	}
	else
	{
		llifstream file;
		file.open(filename.c_str());
		if (file.is_open())
		{
			LLSDSerialize::fromXML(mContactSets, file);
		}
		file.close();
	}	
}
void LGGContactSets::saveToDisk(LLSD newSettings)
{
	mContactSets=newSettings;
	std::string filename=getFileName();
	llofstream file;
	file.open(filename.c_str());
	LLSDSerialize::toPrettyXML(mContactSets, file);
	file.close();
}
void LGGContactSets::runTest()
{
	
mContactSets.clear();
}
BOOL LGGContactSets::saveGroupToDisk(std::string groupName, std::string fileName)
{
	if(mContactSets.has(groupName))
	{
		llofstream file;
		file.open(fileName.c_str());
		LLSDSerialize::toPrettyXML(exportGroup(groupName), file);
		file.close();
		return TRUE;
	}
	return FALSE;
}
LLSD LGGContactSets::getExampleLLSD()
{
	LLSD toReturn;

	LLSD listone;
	LLSD listtwo;

	LLSD itemOne;
	itemOne["wrong"]="wrong1";
	itemOne["right"]="right1";
	listone[0]=itemOne;

	LLSD itemTwo;
	itemTwo["wrong"]="wrong2";
	itemTwo["right"]="right2";
	listone[1]=itemTwo;

	toReturn["listOne"]=listone;


	itemOne["wrong"]="secondwrong1";
	itemOne["right"]="secondright1";
	listone[0]=itemOne;

	itemTwo["wrong"]="secondwrong2";
	itemTwo["right"]="secondright2";
	listone[1]=itemTwo;

	toReturn["listTwo"]=listone;	

	return toReturn;
}

LLColor4 LGGContactSets::getGroupColor(std::string groupName)
{
	if(groupName!="" && groupName!="All Sets" && groupName!="All Groups"  && groupName !="globalSettings" && groupName!="No Sets" && groupName!="ReNamed" && groupName!="Non Friends")
		if(mContactSets[groupName].has("color"))
			return LLColor4(mContactSets[groupName]["color"]);
	return getDefaultColor();
};
LLColor4 LGGContactSets::getFriendColor(
	LLUUID friend_id, std::string ignoredGroupName)
{
	LLColor4 toReturn = getDefaultColor();
	if(ignoredGroupName=="No Sets") return toReturn;
	int lowest = 9999;
	std::vector<std::string> groups = getFriendGroups(friend_id);
	for(int i =0;i<(int)groups.size();i++)
	{
		if(groups[i]!=ignoredGroupName)
		{
			int membersNum = getFriendsInGroup(groups[i]).size();
			if(membersNum==0)continue;
			if(membersNum<lowest)
			{
				lowest=membersNum;
				if(mContactSets[groups[i]].has("color"))
				{
					toReturn= LLColor4(mContactSets[groups[i]]["color"]);
					if(isNonFriend(friend_id))toReturn=toneDownColor(toReturn,.8f);
				}
			}
		}
	}
	if(lowest==9999)
	if(isFriendInGroup(friend_id,ignoredGroupName)  && ignoredGroupName!="globalSettings" && ignoredGroupName!="Non Friends" &&ignoredGroupName!="All Sets" &&ignoredGroupName!="All Groups" && ignoredGroupName!="No Sets" &&ignoredGroupName!="ReNamed" &&ignoredGroupName!="")
		if(mContactSets[ignoredGroupName].has("color"))
			return LLColor4(mContactSets[ignoredGroupName]["color"]);
	return toReturn;
}
//handle all settings and rlv that would prevent us from showing the cs color
BOOL LGGContactSets::hasFriendColorThatShouldShow(LLUUID friend_id,bool chat, bool tag, bool radar, bool miniMap)
{
	if(gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))return FALSE;//don't show colors if we cant show names
	static LLCachedControl<bool> sPhoenixColorContactSetsChat(gSavedSettings, "FSContactSetsColorizeChat");
	static LLCachedControl<bool> contactSetsColorizeTag(gSavedSettings,"FSContactSetsColorizeNameTag");
	static LLCachedControl<bool> contactSetsColorizeRadar(gSavedSettings,"FSContactSetsColorizeRadar");
	static LLCachedControl<bool> contactSetsColorizeMiniMap(gSavedSettings,"FSContactSetsColorizeMiniMap");

	if(miniMap&&!contactSetsColorizeMiniMap)return FALSE;
	if(tag&&!contactSetsColorizeTag)return FALSE;
	if(chat &&!(sPhoenixColorContactSetsChat))return FALSE;
	if(radar && !contactSetsColorizeRadar)return FALSE;

	//don't show friend color if they are no longer a friend 
	//(and if are also not on the "non friends" list)
	if( (!LLAvatarTracker::instance().isBuddy(friend_id))
		&&(!isNonFriend(friend_id))) return FALSE;


	if(getFriendColor(friend_id)==getDefaultColor())return FALSE;
	return TRUE;
}
LLColor4 LGGContactSets::getDefaultColor()
{
	LLColor4 toReturn= LLColor4::grey;
	if(mContactSets.has("globalSettings"))
		if(mContactSets["globalSettings"].has("defaultColor"))
			toReturn = LLColor4(mContactSets["globalSettings"]["defaultColor"]);
	return toReturn;
}
void LGGContactSets::setDefaultColor(LLColor4 dColor)
{
	mContactSets["globalSettings"]["defaultColor"]=dColor.getValue();
}
std::vector<std::string> LGGContactSets::getInnerGroups(std::string groupName)
{
	std::vector<std::string> toReturn;
	toReturn.clear();
	static LLCachedControl<bool> useFolders(gSavedSettings, "FSContactSetsShowFolders");
	static LLCachedControl<bool> showOnline(gSavedSettings, "FSContactSetsShowOnline");
	static LLCachedControl<bool> showOffline(gSavedSettings, "FSContactSetsShowOffline");
	
	if(!(useFolders))return toReturn;

	std::set<std::string> newGroups;
	newGroups.clear();
	if(groupName!="All Sets" && getAllGroups(FALSE).size()>0)newGroups.insert("All Sets");
	std::vector<LLUUID> freindsInGroup = getFriendsInGroup(groupName);
	for(int fn = 0; fn<(int)freindsInGroup.size();fn++)
	{
		LLUUID friend_id = freindsInGroup[fn];
		BOOL online = LLAvatarTracker::instance().isBuddyOnline(friend_id);
		if(online && !(showOnline))continue;
		if(!online && !(showOffline))continue;
		
		std::vector<std::string> innerGroups = getFriendGroups(friend_id);
		for(int inIter=0;inIter<(int)innerGroups.size();inIter++)
		{
			std::string innerGroupName = innerGroups[inIter];
			if(groupName!=innerGroupName)
				newGroups.insert(innerGroupName);
		}
	}

	std::copy(newGroups.begin(), newGroups.end(), std::back_inserter(toReturn));
	return toReturn;
}
std::vector<std::string> LGGContactSets::getFriendGroups(LLUUID friend_id)
{
	std::vector<std::string> toReturn;
	toReturn.clear();

	LLSD::map_const_iterator loc_it = mContactSets.beginMap();
	LLSD::map_const_iterator loc_end = mContactSets.endMap();
	for ( ; loc_it != loc_end; ++loc_it)
	{
		const std::string& groupName = (*loc_it).first;
		if(groupName!="" && groupName !="globalSettings" && groupName!="All Sets" && groupName!="All Groups" && groupName!="All Groups"  && groupName!="No Sets" && groupName!="ReNamed" && groupName!="Non Friends" && groupName!="extraAvs" && groupName!="pseudonym")
			if(mContactSets[groupName].has("friends"))
				if(mContactSets[groupName]["friends"].has(friend_id.asString()))
					toReturn.push_back(groupName);
	}
	return toReturn;
}
std::vector<LLUUID> LGGContactSets::getFriendsInGroup(std::string groupName)
{
	std::vector<LLUUID> toReturn;
	toReturn.clear();
	if(groupName=="All Sets")return getFriendsInAnyGroup();
	if(groupName=="No Sets")return toReturn;
	if(groupName=="pseudonym"||groupName=="ReNamed")return getListOfPseudonymAvs();
	if(groupName=="Non Friends")return getListOfNonFriends();

	LLSD friends = mContactSets[groupName]["friends"];	
	LLSD::map_const_iterator loc_it = friends.beginMap();
	LLSD::map_const_iterator loc_end = friends.endMap();
	for ( ; loc_it != loc_end; ++loc_it)
	{
		const LLSD& friendID = (*loc_it).first;

		toReturn.push_back(friendID.asUUID());
	}	

	return toReturn;
}
std::vector<std::string> LGGContactSets::getAllGroups(BOOL extraGroups)
{
	std::vector<std::string> toReturn;
	toReturn.clear();
	if(extraGroups)
	{
		if(getAllGroups(FALSE).size()>0)
		{
			toReturn.push_back("All Sets");
			toReturn.push_back("No Sets");
		}
		if(getListOfPseudonymAvs().size()>0)
			toReturn.push_back("ReNamed");
		if(getListOfNonFriends().size()>0)
			toReturn.push_back("Non Friends");
	}

	LLSD::map_const_iterator loc_it = mContactSets.beginMap();
	LLSD::map_const_iterator loc_end = mContactSets.endMap();
	for ( ; loc_it != loc_end; ++loc_it)
	{
		const std::string& groupName = (*loc_it).first;
		if((groupName!="globalSettings")&&(groupName!="ReNamed")&&(groupName!="All Groups")&&(groupName!="No Groups")&&(groupName!="Non Friends")&&(groupName!="")&&(groupName!="extraAvs")&&(groupName!="pseudonym")&&(groupName!="All Sets")&&groupName!="No Sets")
			toReturn.push_back(groupName);
	}


	return toReturn;
}
std::vector<LLUUID> LGGContactSets::getFriendsInAnyGroup()
{
	std::set<LLUUID> friendsInAnyGroup;
	std::vector<std::string> groups = getAllGroups(FALSE);
	for(int g=0;g<(int)groups.size();g++)
	{
		LLSD friends = mContactSets[groups[g]]["friends"];	
		LLSD::map_const_iterator loc_it = friends.beginMap();
		LLSD::map_const_iterator loc_end = friends.endMap();
		for ( ; loc_it != loc_end; ++loc_it)
		{
			const LLSD& friendID = (*loc_it).first;
			friendsInAnyGroup.insert(friendID);
		}
	}
	return std::vector<LLUUID>(friendsInAnyGroup.begin(),friendsInAnyGroup.end());
}
BOOL LGGContactSets::isFriendInAnyGroup(LLUUID friend_id)
{
	std::vector<std::string> groups = getAllGroups(FALSE);
	for(int g=0;g<(int)groups.size();g++)
	{
		if(mContactSets[groups[g]].has("friends"))
			if(mContactSets[groups[g]]["friends"].has(friend_id.asString()))
				return TRUE;
	}
	return FALSE;
}
BOOL LGGContactSets::isFriendInGroup(LLUUID friend_id, std::string groupName)
{	
	if(groupName=="All Sets") return isFriendInAnyGroup(friend_id);
	if(groupName=="No Sets") return !isFriendInAnyGroup(friend_id);
	if(groupName=="ReNamed") return hasPseudonym(friend_id);
	if(groupName=="Non Friends") return isNonFriend(friend_id);
	if(mContactSets[groupName].has("friends"))
		return mContactSets[groupName]["friends"].has(friend_id.asString());
	return FALSE;
}
BOOL LGGContactSets::notifyForFriend(LLUUID friend_id)
{
	BOOL notify = FALSE;
	std::vector<std::string> groups = getFriendGroups(friend_id);
	for(int i =0;i<(int)groups.size();i++)
	{
		if(mContactSets[groups[i]]["notify"].asBoolean())return TRUE;
	}
	return notify;
}
void LGGContactSets::addFriendToGroup(LLUUID friend_id, std::string groupName)
{
	if(friend_id.notNull() && groupName!="" && groupName != "extraAvs" && groupName!="pseudonym" && groupName !="globalSettings" && groupName!="No Sets" && groupName!="All Sets" && groupName!="All Groups"  && groupName!="ReNamed" && groupName!="Non Friends")
	{
		mContactSets[groupName]["friends"][friend_id.asString()]="";
		save();
	}
}
void LGGContactSets::addNonFriendToList(LLUUID non_friend_id)
{
	mContactSets["extraAvs"][non_friend_id.asString()]="";
	save();
}
void LGGContactSets::removeNonFriendFromList(LLUUID non_friend_id)
{
	if(mContactSets["extraAvs"].has(non_friend_id.asString()))
	{
		mContactSets["extraAvs"].erase(non_friend_id.asString());
		if(!LLAvatarTracker::instance().isBuddy(non_friend_id))
		{
			clearPseudonym(non_friend_id);
			removeFriendFromAllGroups(non_friend_id);
		}
		save();
	}
}
void LGGContactSets::removeFriendFromAllGroups(LLUUID friend_id)
{
	std::vector<std::string> groups = getFriendGroups(friend_id);
	for(int i=0;i<(int)groups.size();i++)
	{
		removeFriendFromGroup(friend_id,groups[i]);
	}
}
BOOL LGGContactSets::isNonFriend(LLUUID non_friend_id)
{
	if(LLAvatarTracker::instance().isBuddy(non_friend_id))return FALSE;
	if(mContactSets["extraAvs"].has(non_friend_id.asString()))return TRUE;
	return FALSE;
}
std::vector<LLUUID> LGGContactSets::getListOfNonFriends()
{
	std::vector<LLUUID> toReturn;
	toReturn.clear();

	LLSD friends = mContactSets["extraAvs"];	
	LLSD::map_const_iterator loc_it = friends.beginMap();
	LLSD::map_const_iterator loc_end = friends.endMap();
	for ( ; loc_it != loc_end; ++loc_it)
	{
		const LLSD& friendID = (*loc_it).first;
		if(friendID.asString()=="friends")
		{
			friends.erase(friendID.asString());
			continue;
		}
		if(friendID.asUUID().notNull())
			if(!LLAvatarTracker::instance().isBuddy(friendID))
				toReturn.push_back(friendID.asUUID());
	}	

	return toReturn;
}
std::vector<LLUUID> LGGContactSets::getListOfPseudonymAvs()
{
	std::vector<LLUUID> toReturn;
	toReturn.clear();

	LLSD friends = mContactSets["pseudonym"];	
	LLSD::map_const_iterator loc_it = friends.beginMap();
	LLSD::map_const_iterator loc_end = friends.endMap();
	for ( ; loc_it != loc_end; ++loc_it)
	{
		const LLSD& friendID = (*loc_it).first;
		if(friendID.asString()=="friends")
		{
			friends.erase(friendID.asString());
			continue;
		}
		if(friendID.asUUID().notNull())
			toReturn.push_back(friendID.asUUID());
	}	

	return toReturn;
}
void LGGContactSets::setPseudonym(LLUUID friend_id, std::string pseudonym)
{
	mContactSets["pseudonym"][friend_id.asString()]=pseudonym;
	save();
}
std::string LGGContactSets::getPseudonym(LLUUID friend_id)
{
	if(mContactSets["pseudonym"].has(friend_id.asString()))
	{
		return mContactSets["pseudonym"][friend_id.asString()];
	}
	return "";
}
void LGGContactSets::clearPseudonym(LLUUID friend_id)
{
	if(mContactSets["pseudonym"].has(friend_id.asString()))
	{
		mContactSets["pseudonym"].erase(friend_id.asString());
		LLAvatarNameCache::fetch(friend_id);//update
		save();
	}
}
BOOL LGGContactSets::hasPseudonym(LLUUID friend_id)
{
	if(getPseudonym(friend_id)!="")return TRUE;
	return FALSE;
}
BOOL LGGContactSets::hasDisplayNameRemoved(LLUUID friend_id)
{
	return (getPseudonym(friend_id)=="--- ---");
}
BOOL LGGContactSets::hasVisuallyDiferentPseudonym(LLUUID friend_id)
{
	return (hasPseudonym(friend_id) && (!hasDisplayNameRemoved(friend_id)));
}
void LGGContactSets::removeDisplayName(LLUUID friend_id)
{
	setPseudonym(friend_id,"--- ---");
}
void LGGContactSets::removeFriendFromGroup(LLUUID friend_id, std::string groupName)
{
	if(groupName=="extraAvs"||groupName=="Non Friends")
	{
		return removeNonFriendFromList(friend_id);
	}
	if(groupName=="ReNamed" || groupName=="pseudonym")
	{
		return clearPseudonym(friend_id);
	}
	if(friend_id.notNull() && groupName!="")
	{	
		if(mContactSets[groupName]["friends"].has(friend_id.asString()))
		{
			mContactSets[groupName]["friends"].erase(friend_id.asString());
			save();
		}
	}
}
bool LGGContactSets::isAGroup(std::string groupName)
{
	if(mContactSets.has(groupName))
	{
		if(mContactSets[groupName].has("color"))
			return TRUE;
	}
	return FALSE;
}
void LGGContactSets::addGroup(std::string groupName)
{

	if(groupName!="")
	{
		mContactSets[groupName]["color"] = LLColor4::red.getValue();
		save();
	}
}
void LGGContactSets::deleteGroup(std::string groupName)
{
	if(mContactSets.has(groupName))
	{
		mContactSets.erase(groupName);
		save();
	}
}
void LGGContactSets::setNotifyForGroup(std::string groupName, BOOL notify)
{
	if(groupName=="All Sets" || groupName =="globalSettings" || groupName == "" || groupName =="No Sets"||groupName=="ReNamed"||groupName=="Non Friends")return;

	if(mContactSets.has(groupName))
	{
		mContactSets[groupName]["notify"]=notify;
		save();
	}
}
BOOL LGGContactSets::getNotifyForGroup(std::string groupName)
{
	if(mContactSets.has(groupName))
	{
		if(mContactSets[groupName].has("notify"))
		{
			return mContactSets[groupName]["notify"].asBoolean();
		}
	}
	return FALSE;
}
void LGGContactSets::setGroupColor(std::string groupName, LLColor4 color)
{
	if(groupName=="All Sets" ||   groupName =="globalSettings" || groupName == "" || groupName =="No Sets"||groupName=="ReNamed"||groupName=="Non Friends")return;

	if(mContactSets.has(groupName))
	{
		mContactSets[groupName]["color"]=color.getValue();
		save();
	}
}