/*
* Copyright (C) 2020, University of the Basque Country (UPV/EHU)
* Contact for licensing options: <licensing-mcpttclient(at)mcopenplatform(dot)com>
*
* The original file was part of Open Source Doubango Framework
* Copyright (C) 2010-2011 Mamadou Diop.
* Copyright (C) 2012 Doubango Telecom <http://doubango.org>
*
* This file is part of Open Source Doubango Framework.
*
* DOUBANGO 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.
*
* DOUBANGO 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 DOUBANGO.
*
*/
#include "SipMessage.h"
#define VALUE_CONTENT_TYPE_MULTIPART "multipart/mixed"
#define VALUE_CONTENT_TYPE_MESSAGE_MBMS "application/vnd.3gpp.mcptt-mbms-usage-info+xml"
#define VALUE_CONTENT_TYPE_SDP "application/sdp"


SdpMessage::SdpMessage()
:m_pSdpMessage(tsk_null)
{
}

SdpMessage::SdpMessage(tsdp_message_t *_sdpmessage)
{
	m_pSdpMessage = (tsdp_message_t *)tsk_object_ref(_sdpmessage);
}

SdpMessage::~SdpMessage()
{
	TSK_OBJECT_SAFE_FREE(m_pSdpMessage);
}

char* SdpMessage::getSdpHeaderValue(const char* media, char name, unsigned index /*= 0*/)
{
	const tsdp_header_M_t* M;

	if((M = (const tsdp_header_M_t*)tsdp_message_get_header(m_pSdpMessage, tsdp_htype_M))){
		tsdp_header_type_t type = tsdp_htype_Dummy;
		const tsdp_header_t* header;
		switch(name){
			case 'a': type = tsdp_htype_A; break;
			case 'b': type = tsdp_htype_B; break;
			case 'c': type = tsdp_htype_C; break;
			case 'e': type = tsdp_htype_E; break;
			case 'i': type = tsdp_htype_I; break;
			case 'k': type = tsdp_htype_K; break;
			case 'm': type = tsdp_htype_M; break;
			case 'o': type = tsdp_htype_O; break;


			case 'p': type = tsdp_htype_P; break;
			case 'r': type = tsdp_htype_R; break;
			case 's': type = tsdp_htype_S; break;
			case 't': type = tsdp_htype_T; break;
			case 'u': type = tsdp_htype_U; break;
			case 'v': type = tsdp_htype_V; break;
			case 'z': type = tsdp_htype_Z; break;
		}

		if((header = tsdp_message_get_headerAt(m_pSdpMessage, type, index))){
			return tsdp_header_tostring(header);
		}
	}
		
	return tsk_null;
}

char* SdpMessage::getSdpHeaderAValue(const char* media, const char* attributeName)
{
	const tsdp_header_M_t* M;
	tsk_size_t i;

	for(i = 0; (M = (const tsdp_header_M_t*)tsdp_message_get_headerAt(m_pSdpMessage, tsdp_htype_M, i)); i++){
		if(tsk_striequals(M->media, media)){
			const tsdp_header_A_t* A;
			if((A = tsdp_header_M_findA(M, attributeName))){
				return tsk_strdup(A->value);
			}
		}
	}
	
	return tsk_null;
}

int SdpMessage::getSdpHeaderMPort(const char* media, unsigned index /*= 0*/)
{
	const tsdp_header_M_t* M;
	tsk_size_t i;
	tsk_size_t con;
	for(i = 0,con=0; (M = (const tsdp_header_M_t*)tsdp_message_get_headerAt(m_pSdpMessage, tsdp_htype_M, i)); i++){
		if(tsk_striequals(M->media, media)){
			if(con>=index){
				return M->port;
			}else{
				con++;
			}
			
		}
	}
	
	return -1;
}


char* SdpMessage::getSdpHeaderCAddr(const char* media, unsigned index /*= 0*/)
{
	const tsdp_header_M_t* M;
	tsk_size_t i;
	tsk_size_t con;
	for(i = 0,con=0; (M = (const tsdp_header_M_t*)tsdp_message_get_headerAt(m_pSdpMessage, tsdp_htype_M, i)); i++){
		if(tsk_striequals(M->media, media)){
			if(con>=index){
				return tsk_strdup(M->C->addr);
			}else{
				con++;
			}
			
		}
	}
	
	return tsk_null;
}

char* SdpMessage::getSdpHeaderCAddrType(const char* media, unsigned index /*= 0*/)
{
	const tsdp_header_M_t* M;
	tsk_size_t i;
	tsk_size_t con;
	for(i = 0,con=0; (M = (const tsdp_header_M_t*)tsdp_message_get_headerAt(m_pSdpMessage, tsdp_htype_M, i)); i++){
		if(tsk_striequals(M->media, media)){
			if(con>=index){
				return tsk_strdup(M->C->addrtype);
			}else{
				con++;
			}
			
		}
	}
	
	return tsk_null;
}

int SdpMessage::getSdpHeaderMPort(const char* media)
{
	return getSdpHeaderMPort(media,0);
}

SipMessage::SipMessage()
:m_pSipMessage(tsk_null), m_pSdpMessage(tsk_null)
{ 
}

SipMessage::SipMessage(tsip_message_t *_sipmessage)
: m_pSdpMessage(tsk_null)
{
	m_pSipMessage = (tsip_message_t *)tsk_object_ref(_sipmessage);
}

SipMessage::~SipMessage()
{
	TSK_OBJECT_SAFE_FREE(m_pSipMessage);
	if(m_pSdpMessage){
		delete m_pSdpMessage;
	}
}

bool SipMessage::isResponse()
{
	return TSIP_MESSAGE_IS_RESPONSE(m_pSipMessage);
}

tsip_request_type_t SipMessage::getRequestType()
{
	if(TSIP_MESSAGE_IS_REQUEST(m_pSipMessage)){
		return (m_pSipMessage)->line.request.request_type;
	}
	return tsip_NONE;
}

short SipMessage::getResponseCode()
{
	return TSIP_RESPONSE_CODE(m_pSipMessage);
}

const char* SipMessage::getResponsePhrase()
{
	return TSIP_RESPONSE_PHRASE(m_pSipMessage);
}

const tsip_header_t* SipMessage::getSipHeader(const char* name, unsigned index /* =0 */)
{
	/* Do not worry about calling tsk_striequals() several times because the function
	* is fully optimized.
	*/
	/* Code below comes from tsip_message_get_headerAt() */
	tsk_size_t pos = 0;
	const tsk_list_item_t *item;
	const tsip_header_t* hdr = tsk_null;
	if(!m_pSipMessage || !name){
		return tsk_null;
	}			

	if(tsk_striequals(name, "v") || tsk_striequals(name, "via")){
		if(index == 0){
			hdr = (const tsip_header_t*)m_pSipMessage->firstVia;
			goto bail;
		}else pos++; }
	if(tsk_striequals(name, "f") || tsk_striequals(name, "from")){
		if(index == 0){
			hdr = (const tsip_header_t*)m_pSipMessage->From;
			goto bail;
		}else pos++; }
	if(tsk_striequals(name, "t") || tsk_striequals(name, "to")){
		if(index == 0){
			hdr = (const tsip_header_t*)m_pSipMessage->To;
			goto bail;
		}else pos++; }
	if(tsk_striequals(name, "m") || tsk_striequals(name, "contact")){
		if(index == 0){
			hdr = (const tsip_header_t*)m_pSipMessage->Contact;
			goto bail;
		}else pos++; }
	if(tsk_striequals(name, "i") || tsk_striequals(name, "call-id")){
		if(index == 0){
			hdr = (const tsip_header_t*)m_pSipMessage->Call_ID;
			goto bail;
		}else pos++; }
	if(tsk_striequals(name, "cseq")){
		if(index == 0){
			hdr = (const tsip_header_t*)m_pSipMessage->CSeq;
			goto bail;
		}else pos++; }
	if(tsk_striequals(name, "expires")){
		if(index == 0){
			hdr = (const tsip_header_t*)m_pSipMessage->Expires;
			goto bail;
		}else pos++; }
	if(tsk_striequals(name, "c") || tsk_striequals(name, "content-type")){
		if(index == 0){
			hdr = (const tsip_header_t*)m_pSipMessage->Content_Type;
			goto bail;
		}else pos++; }
	if(tsk_striequals(name, "l") || tsk_striequals(name, "content-length")){
		if(index == 0){
			hdr = (const tsip_header_t*)m_pSipMessage->Content_Length;
			goto bail;
		}else pos++; }

	tsk_list_foreach(item, m_pSipMessage->headers){
		if(tsk_striequals(tsip_header_get_name_2(TSIP_HEADER(item->data)), name)){
			if(pos++ >= index){
				hdr = (const tsip_header_t*)item->data;
				break;
			}
		}
	}
	

bail:
	return hdr;
}

// e.g. getHeaderParamValue("content-type");
char* SipMessage::getSipHeaderValue(const char* name, unsigned index /* = 0*/)
{
	const tsip_header_t* header;
	if((header = this->getSipHeader(name, index))){

		switch(header->type){
			case tsip_htype_From:
				return tsip_uri_tostring(((const tsip_header_From_t*)header)->uri, tsk_false, tsk_false);
			case tsip_htype_To:
				return tsip_uri_tostring(((const tsip_header_To_t*)header)->uri, tsk_false, tsk_false);
				break;
			case tsip_htype_P_Asserted_Identity:
				return tsip_uri_tostring(((const tsip_header_P_Asserted_Identity_t*)header)->uri, tsk_false, tsk_false);
				break;

			default:
				return tsip_header_value_tostring(header);
		}
	}
	// SWIG: %newobject getHeaderValueAt;
	return tsk_null;
}

// e.g. getHeaderParamValue("content-type", "charset");
char* SipMessage::getSipHeaderParamValue(const char* name, const char* param, unsigned index /*=0*/)
{
	const tsip_header_t* header;

	if((header = this->getSipHeader(name, index))){
		return tsip_header_get_param_value(header, param);
	}

	// SWIG: %newobject getSipHeaderParamValue;
	return tsk_null;
}

/** Returns the content length.
*/
unsigned SipMessage::getSipContentLength()
{
	return TSIP_MESSAGE_CONTENT_DATA_LENGTH(m_pSipMessage);
}

/*
unsigned SipMessage::getSipContentMbms()
{
	return TSIP_MESSAGE_CONTENT_DATA_LENGTH(m_pSipMessage);
}
unsigned SipMessage::getSipContentSdp()
{
	return TSIP_MESSAGE_CONTENT_DATA_LENGTH(m_pSipMessage);
}
*/
/** Gets the message content
* @param output A pointer to the output buffer where to copy the data. MUST
* be allocated by the caller.
* @param maxsize The maximum number of octets to copy. Should be less than the size of the
* @a output buffer. You can use @a getSipContentLength() to get the right value to use.
* @retval The number of octet copied in the @a output buffer.
*/
unsigned SipMessage::getSipContent(void* output, unsigned maxsize)
{
	unsigned retsize = 0;
	if(output && maxsize && TSIP_MESSAGE_HAS_CONTENT(m_pSipMessage)){
		retsize = (m_pSipMessage->Content->size > maxsize) ? maxsize : m_pSipMessage->Content->size;
		memcpy(output, m_pSipMessage->Content->data, retsize);
	}
	return retsize;
}

const void* SipMessage::getSipContentPtr()
{
    if(m_pSipMessage && m_pSipMessage->Content){
        return m_pSipMessage->Content->data;
    }
    return tsk_null;
}

//MCPTT
unsigned SipMessage::getSipContentSdp(void* output, unsigned maxsize)
{
	return getSipContentContetType(output, maxsize,VALUE_CONTENT_TYPE_SDP);
}
//MCPTT MBMS
unsigned SipMessage::getSipContentMbms(void* output, unsigned maxsize)
{
	return getSipContentContetType(output, maxsize,VALUE_CONTENT_TYPE_MESSAGE_MBMS);
}


//MCPTT
unsigned SipMessage::getSipContentContetType(void* output, unsigned maxsize,char* content_type)
{
	char* boundary = tsk_null;
	tmedia_multipart_body_t* mp_body = tsk_null;
	tmedia_content_multipart_t* mp_content = tsk_null;
	tsip_header_t* content_type_data=tsk_null;
	unsigned retsize = 0;
	if(output && maxsize && TSIP_MESSAGE_HAS_CONTENT(m_pSipMessage)){
		content_type_data=(tsip_header_t*)m_pSipMessage->Content_Type;
		boundary = tsip_header_get_param_value(content_type_data, "boundary");
		if(boundary == tsk_null) {			
							TSK_DEBUG_ERROR("[%s] content-type is not supportted", TSIP_MESSAGE_CONTENT_TYPE(m_pSipMessage));
							return -3;
		}else{
			mp_body = tmedia_content_multipart_body_parse(TSIP_MESSAGE_CONTENT_DATA(m_pSipMessage), TSIP_MESSAGE_CONTENT_DATA_LENGTH(m_pSipMessage), VALUE_CONTENT_TYPE_MULTIPART, boundary);
			if(mp_body != tsk_null)
			{
				mp_content = tmedia_content_multipart_body_get_content(mp_body,content_type);
				if(mp_content != tsk_null)
				{
					retsize = (mp_content->data_size > maxsize) ? maxsize : mp_content->data_size;
					memcpy(output, mp_content->data, retsize);
				}
		
			}
		}
			
	}
	return retsize;
}

const SdpMessage* SipMessage::getSdpMessage()
{
	char* sdpString=tsk_null;
	if(!m_pSdpMessage && TSIP_MESSAGE_HAS_CONTENT(m_pSipMessage)){
		tsdp_message_t* sdp = tsdp_message_parse(m_pSipMessage->Content->data, m_pSipMessage->Content->size);
		if(sdp){
			m_pSdpMessage = new SdpMessage(sdp);
			TSK_OBJECT_SAFE_FREE(sdp);
		}else{
			#if HAVE_CRT //Debug memory
		sdpString = (char*)malloc(getSipContentLength());
			#else
		sdpString = (char*)tsk_malloc(getSipContentLength());
			#endif //HAVE_CRT
			
			int size=getSipContentSdp(sdpString,getSipContentLength());
			tsdp_message_t* sdp = tsdp_message_parse(sdpString,size);
			if(sdp){
				m_pSdpMessage = new SdpMessage(sdp);
				TSK_OBJECT_SAFE_FREE(sdp);
			}
		}
	}
	
	return m_pSdpMessage;
}