/*

*  Copyright (C) 2020, University of the Basque Country (UPV/EHU)
*
* Contact for licensing options: <licensing-mcpttclient(at)mcopenplatform(dot)com>
*
* This file is part of MCOP MCPTT Client
*
* This 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 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, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
#include "Mcptt.h"

#include "SipSession.h"
//#include "Common.h"

/* ======================== McpttMessage ========================*/
McpttMessage::McpttMessage()
:m_pMessage(tsk_null)
{
}

McpttMessage::McpttMessage(tmcptt_message_t *_message)
{
	m_pMessage = (tmcptt_message_t *)tsk_object_ref(_message);
}

McpttMessage::~McpttMessage()
{
	TSK_OBJECT_SAFE_FREE(m_pMessage);
}


short McpttMessage::getRCode()
{
	return m_pMessage->reason_code;
}

const char* McpttMessage::getPhrase()
{
	return m_pMessage->reason_phrase;
}

const char* McpttMessage::getUser()
{
	return m_pMessage->user;
}

short McpttMessage::getParticipants()
{
	return m_pMessage->participants;
}

short McpttMessage::getTime()
{
	return m_pMessage->time;
}

/* ======================== McpttEvent ========================*/
McpttEvent::McpttEvent(const tmcptt_event_t *_mcpttevent)
{
	this->_event = _mcpttevent;
	if(this->_event && this->_event->message){	
		m_pMessage = new McpttMessage((tmcptt_message_t *)this->_event->message);
	}
	else{
		m_pMessage = tsk_null;
	}
}

McpttEvent::~McpttEvent()
{
	if(m_pMessage){
		delete m_pMessage;
	}
}

tmcptt_event_type_t McpttEvent::getType()
{
	if(this->_event){
		return this->_event->type;
	}
	return tmcptt_event_type_none;
}

const CallSession* McpttEvent::getSipSession()
{
	if(this->_event && this->_event->callback_data){
		return dyn_cast<const CallSession*>((const CallSession*)this->_event->callback_data);
	}
	return tsk_null;
}

const McpttMessage* McpttEvent::getMessage() const
{
	return m_pMessage;
}
/* ======================== McpttMbmsMessage ========================*/
McpttMbmsMessage::McpttMbmsMessage()
:m_pMessage(tsk_null)
{
}

McpttMbmsMessage::McpttMbmsMessage(tmcptt_mbms_message_t *_message)
{
	m_pMessage = (tmcptt_mbms_message_t *)tsk_object_ref(_message);
}

McpttMbmsMessage::~McpttMbmsMessage()
{
	TSK_OBJECT_SAFE_FREE(m_pMessage);
}

const char* McpttMbmsMessage::getGroupId()
{
	return m_pMessage->group_id;
}

const char* McpttMbmsMessage::getTMGI()
{
	return m_pMessage->tmgi;
}

const char* McpttMbmsMessage::getMediaIP()
{
	return m_pMessage->media_ip;
}

short McpttMbmsMessage::getMediaPort()
{
	return m_pMessage->media_port;
}
//getMediaControlPort test1
short McpttMbmsMessage::getMediaControlPort()
{
	return m_pMessage->media_control_port;
}

/* ======================== McpttMbmsEvent ========================*/
McpttMbmsEvent::McpttMbmsEvent(const tmcptt_mbms_event_t *_mcpttmbmsevent)
{
	this->_event = _mcpttmbmsevent;
	if(this->_event && this->_event->message){	
		m_pMessage = new McpttMbmsMessage((tmcptt_mbms_message_t *)this->_event->message);
	}
	else{
		m_pMessage = tsk_null;
	}
}

McpttMbmsEvent::~McpttMbmsEvent()
{
	if(m_pMessage){
		delete m_pMessage;
	}
}

tmcptt_mbms_event_type_t McpttMbmsEvent::getType()
{
	if(this->_event){
		return this->_event->type;
	}
	return tmcptt_mbms_event_type_none;
}

const CallSession* McpttMbmsEvent::getSipSession()
{
	if(this->_event && this->_event->callback_data){
		return dyn_cast<const CallSession*>((const CallSession*)this->_event->callback_data);
	}
	return tsk_null;
}

const McpttMbmsMessage* McpttMbmsEvent::getMessage() const
{
	return m_pMessage;
}
/**
CALLBACK
*/
int twrap_mcptt_cb(const tmcptt_event_t* _event) 
{
	const CallSession* session = dyn_cast<const CallSession*>((const CallSession*)_event->callback_data);
	if(session && session->getMcpttCallback()){
		const McpttEvent* e = new McpttEvent(_event);
		int ret = const_cast<McpttCallback*>(session->getMcpttCallback())->OnEvent(e);
		return ret;
	}
	return 0;
}
int twrap_mcptt_mbms_cb(const tmcptt_mbms_event_t* _event) 
{
	const CallSession* session = dyn_cast<const CallSession*>((const CallSession*)_event->callback_data);
	if(session && session->getMcpttMbmsCallback()){
		const McpttMbmsEvent* e = new McpttMbmsEvent(_event);
		int ret = const_cast<McpttMbmsCallback*>(session->getMcpttMbmsCallback())->OnEvent(e);
		return ret;
	}
	return 0;
}
