/** 
 * @file llcallfloater.cpp
 * @author Mike Antipov
 * @brief Voice Control Panel in a Voice Chats (P2P, Group, Nearby...).
 *
 * $LicenseInfo:firstyear=2009&license=viewergpl$
 * 
 * Copyright (c) 2009, Linden Research, Inc.
 * 
 * Second Life Viewer Source Code
 * The source code in this file ("Source Code") is provided by Linden Lab
 * to you under the terms of the GNU General Public License, version 2.0
 * ("GPL"), unless you have obtained a separate licensing agreement
 * ("Other License"), formally executed by you and Linden Lab.  Terms of
 * the GPL can be found in doc/GPL-license.txt in this distribution, or
 * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
 * 
 * There are special exceptions to the terms and conditions of the GPL as
 * it is applied to this Source Code. View the full text of the exception
 * in the file doc/FLOSS-exception.txt in this software distribution, or
 * online at
 * http://secondlifegrid.net/programs/open_source/licensing/flossexception
 * 
 * By copying, modifying or distributing this software, you acknowledge
 * that you have read and understood your obligations described above,
 * and agree to abide by those obligations.
 * 
 * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
 * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
 * COMPLETENESS OR PERFORMANCE.
 * $/LicenseInfo$
 */

#include "llviewerprecompiledheaders.h"

#include "llnotificationsutil.h"
#include "lltrans.h"

#include "llcallfloater.h"

#include "llagent.h"
#include "llagentdata.h" // for gAgentID
#include "llavatariconctrl.h"
#include "llavatarlist.h"
#include "llbottomtray.h"
#include "llimfloater.h"
#include "llfloaterreg.h"
#include "llparticipantlist.h"
#include "llspeakers.h"
#include "lltextutil.h"
#include "lltransientfloatermgr.h"
#include "llviewerwindow.h"
#include "llvoicechannel.h"

static void get_voice_participants_uuids(std::vector<LLUUID>& speakers_uuids);

class LLNonAvatarCaller : public LLAvatarListItem
{
public:
	LLNonAvatarCaller() : LLAvatarListItem(false)
	{

	}
	BOOL postBuild()
	{
		BOOL rv = LLAvatarListItem::postBuild();

		if (rv)
		{
			setOnline(true);
			showLastInteractionTime(false);
			setShowProfileBtn(false);
			setShowInfoBtn(false);
			mAvatarIcon->setValue("Avaline_Icon");
			mAvatarIcon->setToolTip(std::string(""));
		}
		return rv;
	}

	void setName(const std::string& name)
	{
		const std::string& formatted_phone = LLTextUtil::formatPhoneNumber(name);
		LLAvatarListItem::setName(formatted_phone);
	}

	void setSpeakerId(const LLUUID& id) { mSpeakingIndicator->setSpeakerId(id); }
};


static void* create_non_avatar_caller(void*)
{
	return new LLNonAvatarCaller;
}

LLCallFloater::LLAvatarListItemRemoveTimer::LLAvatarListItemRemoveTimer(callback_t remove_cb, F32 period, const LLUUID& speaker_id)
: LLEventTimer(period)
, mRemoveCallback(remove_cb)
, mSpeakerId(speaker_id)
{
}

BOOL LLCallFloater::LLAvatarListItemRemoveTimer::tick()
{
	if (mRemoveCallback)
	{
		mRemoveCallback(mSpeakerId);
	}
	return TRUE;
}

LLVoiceChannel* LLCallFloater::sCurrentVoiceCanel = NULL;

LLCallFloater::LLCallFloater(const LLSD& key)
: LLTransientDockableFloater(NULL, false, key)
, mSpeakerManager(NULL)
, mParticipants(NULL)
, mAvatarList(NULL)
, mNonAvatarCaller(NULL)
, mVoiceType(VC_LOCAL_CHAT)
, mAgentPanel(NULL)
, mSpeakingIndicator(NULL)
, mIsModeratorMutedVoice(false)
, mInitParticipantsVoiceState(false)
, mVoiceLeftRemoveDelay(10)
{
	static LLUICachedControl<S32> voice_left_remove_delay ("VoiceParticipantLeftRemoveDelay", 10);
	mVoiceLeftRemoveDelay = voice_left_remove_delay;

	mFactoryMap["non_avatar_caller"] = LLCallbackMap(create_non_avatar_caller, NULL);
	LLVoiceClient::getInstance()->addObserver(this);
	LLTransientFloaterMgr::getInstance()->addControlView(this);
}

LLCallFloater::~LLCallFloater()
{
	resetVoiceRemoveTimers();

	delete mParticipants;
	mParticipants = NULL;

	mAvatarListRefreshConnection.disconnect();
	mVoiceChannelStateChangeConnection.disconnect();

	// Don't use LLVoiceClient::getInstance() here 
	// singleton MAY have already been destroyed.
	if(LLVoiceClient::getInstance())
	{
		LLVoiceClient::getInstance()->removeObserver(this);
	}
	LLTransientFloaterMgr::getInstance()->removeControlView(this);
}

// virtual
BOOL LLCallFloater::postBuild()
{
	LLTransientDockableFloater::postBuild();
	mAvatarList = getChild<LLAvatarList>("speakers_list");
	mAvatarListRefreshConnection = mAvatarList->setRefreshCompleteCallback(boost::bind(&LLCallFloater::onAvatarListRefreshed, this));

	childSetAction("leave_call_btn", boost::bind(&LLCallFloater::leaveCall, this));

	mNonAvatarCaller = getChild<LLNonAvatarCaller>("non_avatar_caller");
	mNonAvatarCaller->setVisible(FALSE);

	LLView *anchor_panel = LLBottomTray::getInstance()->getChild<LLView>("speak_flyout_btn");

	setDockControl(new LLDockControl(
		anchor_panel, this,
		getDockTongue(), LLDockControl::TOP));

	initAgentData();


	connectToChannel(LLVoiceChannel::getCurrentVoiceChannel());

	return TRUE;
}

// virtual
void LLCallFloater::onOpen(const LLSD& /*key*/)
{
}

// virtual
void LLCallFloater::draw()
{
	// we have to refresh participants to display ones not in voice as disabled.
	// It should be done only when she joins or leaves voice chat.
	// But seems that LLVoiceClientParticipantObserver is not enough to satisfy this requirement.
	// *TODO: mantipov: remove from draw()

	// NOTE: it looks like calling onChange() here is not necessary,
	// but sometime it is not called properly from the observable object.
	// Seems this is a problem somewhere in Voice Client (LLVoiceClient::participantAddedEvent)
//	onChange();

	bool is_moderator_muted = LLVoiceClient::getInstance()->getIsModeratorMuted(gAgentID);

	if (mIsModeratorMutedVoice != is_moderator_muted)
	{
		setModeratorMutedVoice(is_moderator_muted);
	}

	// Need to resort the participant list if it's in sort by recent speaker order.
	if (mParticipants)
		mParticipants->updateRecentSpeakersOrder();

	LLTransientDockableFloater::draw();
}

// virtual
void LLCallFloater::onChange()
{
	if (NULL == mParticipants) return;
	updateParticipantsVoiceState();

	// Add newly joined participants.
	std::vector<LLUUID> speakers_uuids;
	get_voice_participants_uuids(speakers_uuids);
	for (std::vector<LLUUID>::const_iterator it = speakers_uuids.begin(); it != speakers_uuids.end(); it++)
	{
		mParticipants->addAvatarIDExceptAgent(*it);
	}
}

S32 LLCallFloater::notifyParent(const LLSD& info)
{
	if("size_changes" == info["action"])
	{
		reshapeToFitContent();
		return 1;
	}
	return LLDockableFloater::notifyParent(info);
}

//////////////////////////////////////////////////////////////////////////
/// PRIVATE SECTION
//////////////////////////////////////////////////////////////////////////

void LLCallFloater::leaveCall()
{
	LLVoiceChannel* voice_channel = LLVoiceChannel::getCurrentVoiceChannel();
	if (voice_channel)
	{
		voice_channel->deactivate();
	}
}

void LLCallFloater::updateSession()
{
	LLVoiceChannel* voice_channel = LLVoiceChannel::getCurrentVoiceChannel();
	if (voice_channel)
	{
		LL_DEBUGS("Voice") << "Current voice channel: " << voice_channel->getSessionID() << LL_ENDL;

		if (mSpeakerManager && voice_channel->getSessionID() == mSpeakerManager->getSessionID())
		{
			LL_DEBUGS("Voice") << "Speaker manager is already set for session: " << voice_channel->getSessionID() << LL_ENDL;
			return;
		}
		else
		{
			mSpeakerManager = NULL;
		}
	}

	const LLUUID& session_id = voice_channel->getSessionID();
	LL_DEBUGS("Voice") << "Set speaker manager for session: " << session_id << LL_ENDL;

	LLIMModel::LLIMSession* im_session = LLIMModel::getInstance()->findIMSession(session_id);
	if (im_session)
	{
		mSpeakerManager = LLIMModel::getInstance()->getSpeakerManager(session_id);
		switch (im_session->mType)
		{
		case IM_NOTHING_SPECIAL:
		case IM_SESSION_P2P_INVITE:
			mVoiceType = VC_PEER_TO_PEER;

			if (!im_session->mOtherParticipantIsAvatar)
			{
				mVoiceType = VC_PEER_TO_PEER_AVALINE;
			}
			break;
		case IM_SESSION_CONFERENCE_START:
		case IM_SESSION_GROUP_START:
		case IM_SESSION_INVITE:
			if (gAgent.isInGroup(session_id))
			{
				mVoiceType = VC_GROUP_CHAT;
			}
			else
			{
				mVoiceType = VC_AD_HOC_CHAT;				
			}
			break;
		default:
			llwarning("Failed to determine voice call IM type", 0);
			mVoiceType = VC_GROUP_CHAT;
			break;
		}
	}

	if (NULL == mSpeakerManager)
	{
		// by default let show nearby chat participants
		mSpeakerManager = LLLocalSpeakerMgr::getInstance();
		LL_DEBUGS("Voice") << "Set DEFAULT speaker manager" << LL_ENDL;
		mVoiceType = VC_LOCAL_CHAT;
	}

	updateTitle();
	
	//hide "Leave Call" button for nearby chat
	bool is_local_chat = mVoiceType == VC_LOCAL_CHAT;
	childSetVisible("leave_call_btn", !is_local_chat);
	
	refreshParticipantList();
	updateAgentModeratorState();

	//show floater for voice calls
	if (!is_local_chat)
	{
		LLIMFloater* im_floater = LLIMFloater::findInstance(session_id);
		bool show_me = !(im_floater && im_floater->getVisible());
		if (show_me) 
		{
			setVisible(true);
		}
	}
}

void LLCallFloater::refreshParticipantList()
{
	bool non_avatar_caller = VC_PEER_TO_PEER_AVALINE == mVoiceType;

	if (non_avatar_caller)
	{
		LLIMModel::LLIMSession* session = LLIMModel::instance().findIMSession(mSpeakerManager->getSessionID());
		mNonAvatarCaller->setSpeakerId(session->mOtherParticipantID);
		mNonAvatarCaller->setName(session->mName);
	}

	mNonAvatarCaller->setVisible(non_avatar_caller);
	mAvatarList->setVisible(!non_avatar_caller);

	if (!non_avatar_caller)
	{
		mParticipants = new LLParticipantList(mSpeakerManager, mAvatarList, true, mVoiceType != VC_GROUP_CHAT && mVoiceType != VC_AD_HOC_CHAT);
		mParticipants->setValidateSpeakerCallback(boost::bind(&LLCallFloater::validateSpeaker, this, _1));

		if (LLLocalSpeakerMgr::getInstance() == mSpeakerManager)
		{
			mAvatarList->setNoItemsCommentText(getString("no_one_near"));
		}

		// we have to made delayed initialization of voice state of participant list.
		// it will be performed after first LLAvatarList refreshing in the onAvatarListRefreshed().
		mInitParticipantsVoiceState = true;
	}
}

void LLCallFloater::onAvatarListRefreshed()
{
	if (mInitParticipantsVoiceState)
	{
		initParticipantsVoiceState();
		mInitParticipantsVoiceState = false;
	}
	else
	{
		updateParticipantsVoiceState();
	}
}

// static
void LLCallFloater::sOnCurrentChannelChanged(const LLUUID& /*session_id*/)
{
	LLVoiceChannel* channel = LLVoiceChannel::getCurrentVoiceChannel();

	// *NOTE: if signal was sent for voice channel with LLVoiceChannel::STATE_NO_CHANNEL_INFO
	// it sill be sent for the same channel again (when state is changed).
	// So, lets ignore this call.
	if (channel == sCurrentVoiceCanel) return;

	LLCallFloater* call_floater = LLFloaterReg::getTypedInstance<LLCallFloater>("voice_controls");

	call_floater->connectToChannel(channel);
}

void LLCallFloater::updateTitle()
{
	LLVoiceChannel* voice_channel = LLVoiceChannel::getCurrentVoiceChannel();
	std::string title;
	switch (mVoiceType)
	{
	case VC_LOCAL_CHAT:
		title = getString("title_nearby");
		break;
	case VC_PEER_TO_PEER:
	case VC_PEER_TO_PEER_AVALINE:
		{
			title = voice_channel->getSessionName();

			if (VC_PEER_TO_PEER_AVALINE == mVoiceType)
			{
				title = LLTextUtil::formatPhoneNumber(title);
			}

			LLStringUtil::format_map_t args;
			args["[NAME]"] = title;
			title = getString("title_peer_2_peer", args);
		}
		break;
	case VC_AD_HOC_CHAT:
		title = getString("title_adhoc");
		break;
	case VC_GROUP_CHAT:
		{
			LLStringUtil::format_map_t args;
			args["[GROUP]"] = voice_channel->getSessionName();
			title = getString("title_group", args);
		}
		break;
	}

	setTitle(title);
}

void LLCallFloater::initAgentData()
{
	mAgentPanel = getChild<LLPanel> ("my_panel");

	if ( mAgentPanel )
	{
		mAgentPanel->childSetValue("user_icon", gAgentID);

		std::string name;
		gCacheName->getFullName(gAgentID, name);
		mAgentPanel->childSetValue("user_text", name);

		mSpeakingIndicator = mAgentPanel->getChild<LLOutputMonitorCtrl>("speaking_indicator");
		mSpeakingIndicator->setSpeakerId(gAgentID);
	}
}

void LLCallFloater::setModeratorMutedVoice(bool moderator_muted)
{
	mIsModeratorMutedVoice = moderator_muted;

	if (moderator_muted)
	{
		LLNotificationsUtil::add("VoiceIsMutedByModerator");
	}
	mSpeakingIndicator->setIsMuted(moderator_muted);
}

void LLCallFloater::updateAgentModeratorState()
{
	std::string name;
	gCacheName->getFullName(gAgentID, name);

	if(gAgent.isInGroup(mSpeakerManager->getSessionID()))
	{
		// This method can be called when LLVoiceChannel.mState == STATE_NO_CHANNEL_INFO
		// in this case there are no any speakers yet.
		if (mSpeakerManager->findSpeaker(gAgentID))
		{
			// Agent is Moderator
			if (mSpeakerManager->findSpeaker(gAgentID)->mIsModerator)

			{
				const std::string moderator_indicator(LLTrans::getString("IM_moderator_label")); 
				name += " " + moderator_indicator;
			}
		}
	}
	mAgentPanel->childSetValue("user_text", name);
}

static void get_voice_participants_uuids(std::vector<LLUUID>& speakers_uuids)
{
	// Get a list of participants from VoiceClient
       std::set<LLUUID> participants;
       LLVoiceClient::getInstance()->getParticipantList(participants);
	
	for (std::set<LLUUID>::const_iterator iter = participants.begin();
		 iter != participants.end(); ++iter)
	{
		speakers_uuids.push_back(*iter);
	}

}

void LLCallFloater::initParticipantsVoiceState()
{
	// Set initial status for each participant in the list.
	std::vector<LLPanel*> items;
	mAvatarList->getItems(items);
	std::vector<LLPanel*>::const_iterator
		it = items.begin(),
		it_end = items.end();


	std::vector<LLUUID> speakers_uuids;
	get_voice_participants_uuids(speakers_uuids);

	for(; it != it_end; ++it)
	{
		LLAvatarListItem *item = dynamic_cast<LLAvatarListItem*>(*it);
		
		if (!item)	continue;
		
		LLUUID speaker_id = item->getAvatarId();

		std::vector<LLUUID>::const_iterator speaker_iter = std::find(speakers_uuids.begin(), speakers_uuids.end(), speaker_id);

		// If an avatarID assigned to a panel is found in a speakers list
		// obtained from VoiceClient we assign the JOINED status to the owner
		// of this avatarID.
		if (speaker_iter != speakers_uuids.end())
		{
			setState(item, STATE_JOINED);
		}
		else
		{
			LLPointer<LLSpeaker> speakerp = mSpeakerManager->findSpeaker(speaker_id);
			// If someone has already left the call before, we create his
			// avatar row panel with HAS_LEFT status and remove it after
			// the timeout, otherwise we create a panel with INVITED status
			if (speakerp.notNull() && speakerp.get()->mHasLeftCurrentCall)
			{
				setState(item, STATE_LEFT);
			}
			else
			{
				setState(item, STATE_INVITED);
			}
		}
	}
}

void LLCallFloater::updateParticipantsVoiceState()
{
	std::vector<LLUUID> speakers_list;

	// Get a list of participants from VoiceClient
	std::vector<LLUUID> speakers_uuids;
	get_voice_participants_uuids(speakers_uuids);

	// Updating the status for each participant already in list.
	std::vector<LLPanel*> items;
	mAvatarList->getItems(items);
	std::vector<LLPanel*>::const_iterator
		it = items.begin(),
		it_end = items.end();

	for(; it != it_end; ++it)
	{
		LLAvatarListItem *item = dynamic_cast<LLAvatarListItem*>(*it);
		if (!item) continue;

		const LLUUID participant_id = item->getAvatarId();
		bool found = false;

		std::vector<LLUUID>::iterator speakers_iter = std::find(speakers_uuids.begin(), speakers_uuids.end(), participant_id);

		LL_DEBUGS("Voice") << "processing speaker: " << item->getAvatarName() << ", " << item->getAvatarId() << LL_ENDL;

		// If an avatarID assigned to a panel is found in a speakers list
		// obtained from VoiceClient we assign the JOINED status to the owner
		// of this avatarID.
		if (speakers_iter != speakers_uuids.end())
		{
			setState(item, STATE_JOINED);

			LLPointer<LLSpeaker> speaker = mSpeakerManager->findSpeaker(participant_id);
			if (speaker.isNull())
				continue;
			speaker->mHasLeftCurrentCall = FALSE;

			speakers_uuids.erase(speakers_iter);
			found = true;
		}

		if (!found)
		{
			// If an avatarID is not found in a speakers list from VoiceClient and
			// a panel with this ID has a JOINED status this means that this person
			// HAS LEFT the call.
			if ((getState(participant_id) == STATE_JOINED))
			{
				setState(item, STATE_LEFT);

				LLPointer<LLSpeaker> speaker = mSpeakerManager->findSpeaker(item->getAvatarId());
				if (speaker.isNull())
				{
					continue;
				}

				speaker->mHasLeftCurrentCall = TRUE;
			}
			// If an avatarID is not found in a speakers list from VoiceClient and
			// a panel with this ID has a LEFT status this means that this person
			// HAS ENTERED session but it is not in voice chat yet. So, set INVITED status
			else if ((getState(participant_id) != STATE_LEFT))
			{
				setState(item, STATE_INVITED);
			}
			else
			{
				llwarns << "Unsupported (" << getState(participant_id) << ") state: " << item->getAvatarName()  << LL_ENDL;
			}
		}
	}
}

void LLCallFloater::setState(LLAvatarListItem* item, ESpeakerState state)
{
	// *HACK: mantipov: sometimes such situation is possible while switching to voice channel:
/*
	- voice channel is switched to the one user is joining
	- participant list is initialized with voice states: agent is in voice
	- than such log messages were found (with agent UUID)
			- LLVivoxProtocolParser::process_impl: parsing: <Response requestId="22" action="Session.MediaDisconnect.1"><ReturnCode>0</ReturnCode><Results><StatusCode>0</StatusCode><StatusString /></Results><InputXml><Request requestId="22" action="Session.MediaDisconnect.1"><SessionGroupHandle>9</SessionGroupHandle><SessionHandle>12</SessionHandle><Media>Audio</Media></Request></InputXml></Response>
			- LLVoiceClient::sessionState::removeParticipant: participant "sip:x2pwNkMbpR_mK4rtB_awASA==@bhr.vivox.com" (da9c0d90-c6e9-47f9-8ae2-bb41fdac0048) removed.
	- and than while updating participants voice states agent is marked as HAS LEFT
	- next updating of LLVoiceClient state makes agent JOINED
	So, lets skip HAS LEFT state for agent's avatar
*/
	if (STATE_LEFT == state && item->getAvatarId() == gAgentID) return;

	setState(item->getAvatarId(), state);

	switch (state)
	{
	case STATE_INVITED:
		item->setState(LLAvatarListItem::IS_VOICE_INVITED);
		break;
	case STATE_JOINED:
		removeVoiceRemoveTimer(item->getAvatarId());
		item->setState(LLAvatarListItem::IS_VOICE_JOINED);
		break;
	case STATE_LEFT:
		{
			setVoiceRemoveTimer(item->getAvatarId());
			item->setState(LLAvatarListItem::IS_VOICE_LEFT);
		}
		break;
	default:
		llwarns << "Unrecognized avatar panel state (" << state << ")" << llendl;
		break;
	}
}

void LLCallFloater::setVoiceRemoveTimer(const LLUUID& voice_speaker_id)
{

	// If there is already a started timer for the current panel don't do anything.
	bool no_timer_for_current_panel = true;
	if (mVoiceLeftTimersMap.size() > 0)
	{
		timers_map::iterator found_it = mVoiceLeftTimersMap.find(voice_speaker_id);
		if (found_it != mVoiceLeftTimersMap.end())
		{
			no_timer_for_current_panel = false;
		}
	}

	if (no_timer_for_current_panel)
	{
		// Starting a timer to remove an avatar row panel after timeout
		mVoiceLeftTimersMap.insert(timer_pair(voice_speaker_id,
			new LLAvatarListItemRemoveTimer(boost::bind(&LLCallFloater::removeVoiceLeftParticipant, this, _1), mVoiceLeftRemoveDelay, voice_speaker_id)));
	}
}

void LLCallFloater::removeVoiceLeftParticipant(const LLUUID& voice_speaker_id)
{
	if (mVoiceLeftTimersMap.size() > 0)
	{
		mVoiceLeftTimersMap.erase(mVoiceLeftTimersMap.find(voice_speaker_id));
	}

	LLAvatarList::uuid_vector_t& speaker_uuids = mAvatarList->getIDs();
	LLAvatarList::uuid_vector_t::iterator pos = std::find(speaker_uuids.begin(), speaker_uuids.end(), voice_speaker_id);
	if(pos != speaker_uuids.end())
	{
		speaker_uuids.erase(pos);
		mAvatarList->setDirty();
	}
}


void LLCallFloater::resetVoiceRemoveTimers()
{
	if (mVoiceLeftTimersMap.size() > 0)
	{
		for (timers_map::iterator iter = mVoiceLeftTimersMap.begin();
			iter != mVoiceLeftTimersMap.end(); ++iter)
		{
			delete iter->second;
		}
	}
	mVoiceLeftTimersMap.clear();
}

void LLCallFloater::removeVoiceRemoveTimer(const LLUUID& voice_speaker_id)
{
	// Remove the timer if it has been already started
	if (mVoiceLeftTimersMap.size() > 0)
	{
		timers_map::iterator found_it = mVoiceLeftTimersMap.find(voice_speaker_id);
		if (found_it != mVoiceLeftTimersMap.end())
		{
			delete found_it->second;
			mVoiceLeftTimersMap.erase(found_it);
		}
	}
}

bool LLCallFloater::validateSpeaker(const LLUUID& speaker_id)
{
	if (mVoiceType != VC_LOCAL_CHAT)
		return true;

	// A nearby chat speaker is considered valid it it's known to LLVoiceClient (i.e. has enabled voice).
	std::vector<LLUUID> speakers;
	get_voice_participants_uuids(speakers);
	return std::find(speakers.begin(), speakers.end(), speaker_id) != speakers.end();
}

void LLCallFloater::connectToChannel(LLVoiceChannel* channel)
{
	mVoiceChannelStateChangeConnection.disconnect();

	sCurrentVoiceCanel = channel;

	mVoiceChannelStateChangeConnection = sCurrentVoiceCanel->setStateChangedCallback(boost::bind(&LLCallFloater::onVoiceChannelStateChanged, this, _1, _2));

	updateState(channel->getState());
}

void LLCallFloater::onVoiceChannelStateChanged(const LLVoiceChannel::EState& old_state, const LLVoiceChannel::EState& new_state)
{
	updateState(new_state);
}

void LLCallFloater::updateState(const LLVoiceChannel::EState& new_state)
{
	LL_DEBUGS("Voice") << "Updating state: " << new_state << ", session name: " << sCurrentVoiceCanel->getSessionName() << LL_ENDL;
	if (LLVoiceChannel::STATE_CONNECTED == new_state)
	{
		updateSession();
	}
	else
	{
		reset();
	}
}

void LLCallFloater::reset()
{
	// lets forget states from the previous session
	// for timers...
	resetVoiceRemoveTimers();

	// ...and for speaker state
	mSpeakerStateMap.clear();

	delete mParticipants;
	mParticipants = NULL;
	mAvatarList->clear();

	// update floater to show Loading while waiting for data.
	mAvatarList->setNoItemsCommentText(LLTrans::getString("LoadingData"));
	mAvatarList->setVisible(TRUE);
	mNonAvatarCaller->setVisible(FALSE);

	mSpeakerManager = NULL;
}

void reshape_floater(LLCallFloater* floater, S32 delta_height)
{
	// Try to update floater top side if it is docked(to bottom bar).
	// Try to update floater bottom side or top side if it is un-docked.
	// If world rect is too small, floater will not be reshaped at all.

	LLRect floater_rect = floater->getRect();
	LLRect world_rect = gViewerWindow->getWorldViewRectScaled();

	// floater is docked to bottom bar
	if(floater->isDocked())
	{
		// can update floater top side
		if(floater_rect.mTop + delta_height < world_rect.mTop)
		{
			floater_rect.set(floater_rect.mLeft, floater_rect.mTop + delta_height, 
				floater_rect.mRight, floater_rect.mBottom);
		}
	}
	// floater is un-docked
	else
	{
		// can update floater bottom side
		if( floater_rect.mBottom - delta_height >= world_rect.mBottom )
		{
			floater_rect.set(floater_rect.mLeft, floater_rect.mTop, 
				floater_rect.mRight, floater_rect.mBottom - delta_height);
		}
		// could not update floater bottom side, check if we can update floater top side
		else if( floater_rect.mTop + delta_height < world_rect.mTop )
		{
			floater_rect.set(floater_rect.mLeft, floater_rect.mTop + delta_height, 
				floater_rect.mRight, floater_rect.mBottom);
		}
	}

	floater->reshape(floater_rect.getWidth(), floater_rect.getHeight());
	floater->setRect(floater_rect);
}

void LLCallFloater::reshapeToFitContent()
{
	const S32 ITEM_HEIGHT = getParticipantItemHeight();
	static const S32 MAX_VISIBLE_ITEMS = getMaxVisibleItems();

	static S32 items_pad = mAvatarList->getItemsPad();
	S32 list_height = mAvatarList->getRect().getHeight();
	S32 items_height = mAvatarList->getItemsRect().getHeight();
	if(items_height <= 0)
	{
		// make "no one near" text visible
		items_height = ITEM_HEIGHT + items_pad;
	}
	S32 max_list_height = MAX_VISIBLE_ITEMS * ITEM_HEIGHT + items_pad * (MAX_VISIBLE_ITEMS - 1);
	max_list_height += 2* mAvatarList->getBorderWidth();

	S32 delta = items_height - list_height;	
	// too many items, don't reshape floater anymore, let scroll bar appear.
	if(items_height >  max_list_height)
	{
		delta = max_list_height - list_height;
	}

	reshape_floater(this, delta);
}

S32 LLCallFloater::getParticipantItemHeight()
{
	std::vector<LLPanel*> items;
	mAvatarList->getItems(items);
	if(items.size() > 0)
	{
		return items[0]->getRect().getHeight();
	}
	else
	{
		return getChild<LLPanel>("non_avatar_caller")->getRect().getHeight();
	}
}

S32 LLCallFloater::getMaxVisibleItems()
{
	S32 value = 5; // default value, in case convertToS32() fails.
	LLStringUtil::convertToS32(getString("max_visible_items"), value);
	return value;
}

//EOF