/*
 * Copyright (c) 2010-2019 Belledonne Communications SARL.
 *
 * This file is part of Liblinphone.
 *
 * 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/>.
 */

#ifndef _L_C_TYPES_H_
#define _L_C_TYPES_H_

// TODO: Remove me in the future.
#include "linphone/types.h"

#include "linphone/enums/call-enums.h"
#include "linphone/enums/chat-message-enums.h"
#include "linphone/enums/chat-room-enums.h"
#include "linphone/enums/conference-enums.h"
#include "linphone/enums/encryption-engine-enums.h"
#include "linphone/enums/event-log-enums.h"
#include "linphone/enums/security-event-enums.h"
#include "linphone/utils/enum-generator.h"

// =============================================================================

#ifdef __cplusplus
	extern "C" {
#endif // ifdef __cplusplus

// =============================================================================
// Misc.
// =============================================================================

#ifdef TRUE
	#undef TRUE
#endif

#ifdef FALSE
	#undef FALSE
#endif

#define TRUE 1
#define FALSE 0

// -----------------------------------------------------------------------------
// Authentication.
// -----------------------------------------------------------------------------

/**
 * @brief Object holding authentication information.
 *
 * In most case, authentication information consists of a username and password.
 * If realm isn't set, it will be deduced automatically from the first authentication challenge as for the hash algorithm.
 * Sometimes, a userid is required by the proxy and then domain can be useful to discriminate different credentials.
 * You can also use this object if you need to use a client certificate.
 *
 * Once created and filled, a #LinphoneAuthInfo must be added to the #LinphoneCore in
 * order to become known and used automatically when needed.
 * Use linphone_core_add_auth_info() for that purpose.
 *
 * The #LinphoneCore object can take the initiative to request authentication information
 * when needed to the application through the authentication_requested() callback of it's #LinphoneCoreCbs.
 *
 * The application can respond to this information request later using
 * linphone_core_add_auth_info(). This will unblock all pending authentication
 * transactions and retry them with authentication headers.
 *
 * @ingroup authentication
**/
typedef struct _LinphoneAuthInfo LinphoneAuthInfo;

// -----------------------------------------------------------------------------
// Address.
// -----------------------------------------------------------------------------

/**
 * @brief Object that represents a parsed SIP address.
 *
 * A SIP address is made of display name, username, domain name, port, and various
 * uri headers (such as tags). It looks like 'Alice <sip:alice@example.net>'.
 * 
 * You can create an address using linphone_factory_create_address() or linphone_core_interpret_url()
 * and both will return a NULL object if it doesn't match the grammar defined by the standard.
 * 
 * This object is used in almost every other major objects to identity people (including yourself) & servers.
 * 
 * The #LinphoneAddress has methods to extract and manipulate all parts of the address.
 * @ingroup linphone_address
 */
typedef struct _LinphoneAddress LinphoneAddress;

// -----------------------------------------------------------------------------
// Conference.
// -----------------------------------------------------------------------------

/**
 * @brief TODO
 * @ingroup conferencing
 */
typedef struct _LinphoneConference LinphoneConference;

/**
 * @brief TODO
 * @ingroup conferencing
 */
typedef struct _LinphoneConferenceParams LinphoneConferenceParams;

/**
 * @brief An object to handle the callbacks for the handling a #LinphoneConference objects.
 *
 * Use linphone_factory_create_conference_cbs() to create an instance. 
 * Then pass the object to a #LinphoneConference instance through linphone_conference_add_callbacks().
 * @ingroup conferencing
 */
typedef struct _LinphoneConferenceCbs LinphoneConferenceCbs;

// -----------------------------------------------------------------------------
// Participants.
// -----------------------------------------------------------------------------

/**
 * @brief Identifies a member of a #LinphoneConference or #LinphoneChatRoom.
 * 
 * A participant is identified by it's SIP address.
 * It can have many #LinphoneParticipantDevice.
 * @ingroup conference
 */
typedef struct _LinphoneParticipant LinphoneParticipant;

/**
 * @brief This object represents a unique device for a member of a #LinphoneConference or #LinphoneChatRoom.
 * 
 * Devices are identified by the gruu parameter inside the #LinphoneAddress which can be obtained by linphone_participant_device_get_address().
 * It is specially usefull to know the security level of each device inside an end-to-end encrypted #LinphoneChatRoom.
 * 
 * You can get a list of all #LinphoneParticipantDevice using linphone_participant_get_devices().
 * @ingroup conference
 */
typedef struct _LinphoneParticipantDevice LinphoneParticipantDevice;

/**
 * @brief This object represents the delivery/display state of a given chat message for a given participant.
 * 
 * It also contains a timestamp at which this participant state has changed.
 * 
 * Use linphone_chat_message_get_participants_by_imdn_state() to get all #LinphoneParticipantImdnState for a given state.
 * From there use linphone_participant_imdn_state_get_participant() to get the #LinphoneParticipant object if you need it.
 * @ingroup conference
 */
typedef struct _LinphoneParticipantImdnState LinphoneParticipantImdnState;

/**
 * @brief This object is only used on server side for #LinphoneChatRoom with #LinphoneChatRoomBackendFlexisipChat backend.
 * @ingroup conference
 */
typedef struct _LinphoneParticipantDeviceIdentity LinphoneParticipantDeviceIdentity;

// -----------------------------------------------------------------------------
// Call.
// -----------------------------------------------------------------------------

/**
 * @brief This object represents a call issued or received by the #LinphoneCore.
 * 
 * You may have multiple calls at the same time, but only one will be 
 * in #LinphoneCallStateStreamsRunning at any time unless they are merged into a #LinphoneConference,
 * others will be paused.
 * 
 * You can get the #LinphoneCallState of the call using linphone_call_get_state(),
 * it's current #LinphoneCallParams with linphone_call_get_current_params() and 
 * the latest statistics by calling linphone_call_get_audio_stats() or linphone_call_get_video_stats().
 * 
 * @ingroup call_control
 */
typedef struct _LinphoneCall LinphoneCall;

/** Callback prototype */
typedef void (*LinphoneCallCbFunc) (LinphoneCall *call, void *ud);

/**
 * @brief That class holds all the callbacks which are called by #LinphoneCall objects.
 *
 * Use linphone_factory_create_call_cbs() to create an instance. Then, call the
 * callback setters on the events you need to monitor and pass the object to
 * a #LinphoneCall instance through linphone_call_add_callbacks().
 * @ingroup call_control
 */
typedef struct _LinphoneCallCbs LinphoneCallCbs;

/**
 * @brief An object containing various parameters of a #LinphoneCall.
 * 
 * You can specify your params while answering an incoming call using linphone_call_accept_with_params() 
 * or while initiating an outgoing call with linphone_core_invite_address_with_params().
 * 
 * This object can be created using linphone_core_create_call_params(), using NULL for the call pointer if you plan to use it for an outgoing call.
 * 
 * For each call, three #LinphoneCallParams are available: yours, your correspondent's 
 * and the one that describe the current state of the call that is the result of the negociation between the previous two.
 * For example, you might enable a certain feature in your call param but this feature can be denied in the remote's configuration, hence the difference.
 * 
 * @see linphone_call_get_current_params(), linphone_call_get_remote_params() and linphone_call_get_params().
 * @ingroup call_control
**/
typedef struct _LinphoneCallParams LinphoneCallParams;

/**
 * @brief Object used to keep track of all calls initiated, received or missed.
 * 
 * It contains the call ID, date & time at which the call took place and it's duration (0 if it wasn't answered).
 * You can also know if video was enabled or not or if it was a conference, as well as it's average quality.
 * 
 * If needed, you can also create a fake #LinphoneCallLog using linphone_core_create_call_log(), 
 * otherwise use linphone_core_get_call_logs() or even linphone_call_get_call_log() to get the log of an ongoing call.
 * 
 * @ingroup call_logs
**/
typedef struct _LinphoneCallLog LinphoneCallLog;

// -----------------------------------------------------------------------------
// Audio.
// -----------------------------------------------------------------------------

/**
 * @brief Object holding audio device information.
 * 
 * It contains the name of the device, it's type if available (Earpiece, Speaker, Bluetooth, etc..)
 * and capabilities (input, output or both) the name of the driver that created it (filter in mediastreamer).
 * 
 * You can use the #LinphoneAudioDevice objects to configure default input/output devices or do it dynamically during a call.
 * 
 * To get the list of available devices, use linphone_core_get_audio_devices(). This list will be limited to one device of each type. 
 * Use linphone_core_get_extended_audio_devices() for a complete list. 
 * 
 * @ingroup audio
**/
typedef struct _LinphoneAudioDevice LinphoneAudioDevice;

// -----------------------------------------------------------------------------
// ChatRoom.
// -----------------------------------------------------------------------------

/**
 * @brief An chat message is the object that is sent or received through a #LinphoneChatRoom.
 * 
 * To create a #LinphoneChatMessage, use linphone_chat_room_create_empty_message(), 
 * then either add text using linphone_chat_message_add_utf8_text_content() or a
 * #LinphoneContent with file informations using linphone_chat_message_add_file_content().
 * A valid #LinphoneContent for file transfer must contain a type and subtype, the name of the file and it's size.
 * Finally call linphone_chat_message_send() to send it.
 * 
 * To send files through a #LinphoneChatMessage, you need to have configured a file transfer server URL with linphone_core_set_file_transfer_server().
 * On the receiving side, either use linphone_chat_message_download_content() to download received files or enable auto-download in the #LinphoneCore using 
 * linphone_core_set_max_size_for_auto_download_incoming_files(), -1 disabling the feature and 0 always downloading files no matter it's size.
 * 
 * Keep in mind a #LinphoneChatMessage created by a #LinphoneChatRoomBackendBasic #LinphoneChatRoom can only contain one #LinphoneContent, either text or file.
 * @ingroup chatroom
 */
typedef struct _LinphoneChatMessage LinphoneChatMessage;

/**
 * @brief An object to handle the callbacks for the handling a #LinphoneChatMessage objects.
 * @ingroup chatroom
 */
typedef struct _LinphoneChatMessageCbs LinphoneChatMessageCbs;

/**
 * @brief A chat room is the place where #LinphoneChatMessage are exchanged.
 * 
 * To create (or find) a #LinphoneChatRoom, you first need a #LinphoneChatRoomParams object.
 * A chat room is uniquely identified by it's local and remote SIP addresses, meaning you can
 * only have one chat room between two accounts (unless the backend is #LinphoneChatRoomBackendFlexisipChat).
 * Then you can call linphone_core_search_chat_room() or linphone_core_create_chat_room_6().
 * 
 * Be careful as a #LinphoneChatRoomBackendFlexisipChat backend #LinphoneChatRoom will be created asynchronously, so
 * make sure you add a #LinphoneChatRoomCbs to the returned object to be notified 
 * when it will be in state #LinphoneChatRoomStateCreated.
 * 
 * All chat rooms are loaded from database when the #LinphoneCore starts, and you can get them using
 * linphone_core_get_chat_rooms(). This method doesn't return empty chat rooms nor ones for which the local address
 * doesn't match an existing #LinphoneProxyConfig identity, unless you specify otherwise in the [misc] section 
 * of your configuration file by setting hide_empty_chat_rooms=0 and/or hide_chat_rooms_from_removed_proxies=0. 
 * @ingroup chatroom
 */
typedef struct _LinphoneChatRoom LinphoneChatRoom;

/**
 * @brief Object defining parameters for a #LinphoneChatRoom.
 * 
 * Can be created with linphone_core_create_default_chat_room_params().
 * You can use linphone_chat_room_params_is_valid() to check if your configuration is valid or not.
 * 
 * If the #LinphoneChatRoom backend is #LinphoneChatRoomBackendBasic, then no other parameter is required, 
 * but #LinphoneChatMessage sent and received won't benefit from all features a #LinphoneChatRoomBackendFlexisipChat can offer 
 * like conversation with multiple participants and a subject, end-to-end encryption, ephemeral messages, etc... 
 * but this type is the only one that can interoperate with other SIP clients or with non-flexisip SIP proxies.
 * @ingroup chatroom
 */
typedef struct _LinphoneChatRoomParams LinphoneChatRoomParams;

/**
 * @brief A mask of #LinphoneChatRoomCapabilities
 * @ingroup chatroom
 */
typedef int LinphoneChatRoomCapabilitiesMask;

/**
 * @brief An object to handle the callbacks for the handling a #LinphoneChatRoom objects.
 * @ingroup chatroom
 */
typedef struct _LinphoneChatRoomCbs LinphoneChatRoomCbs;

/**
 * @brief Object holding chat message data received by a push notification on iOS platform only.
 * 
 * This object is a subset of #LinphoneChatMessage, so only a few methods of it's parent are available,
 * like linphone_push_notification_message_get_text_content() and linphone_push_notification_message_get_subject(),
 * just enough to be able to build a notification to show the user.
 * @ingroup chatroom
**/
typedef struct _LinphonePushNotificationMessage LinphonePushNotificationMessage;

// -----------------------------------------------------------------------------
// EventLog.
// -----------------------------------------------------------------------------

/**
 * @brief Object that represents an event that must be stored in database.
 * 
 * For example, all chat related events are wrapped in an #LinphoneEventLog, 
 * and many callbacks use this kind of type as parameter.
 * 
 * Use linphone_event_log_get_type() to get the #LinphoneEventLogType it refers to, 
 * and then you can use one of the accessor methods to get the underlying object, 
 * for example linphone_event_log_get_chat_message() for a #LinphoneChatMessage.
 * @ingroup events
 */
typedef struct _LinphoneEventLog LinphoneEventLog;

// -----------------------------------------------------------------------------
// Misc.
// -----------------------------------------------------------------------------

/**
 * @brief This object holds data that can be embedded in a signaling message.
 * 
 * Use linphone_core_create_content() to create it, and then you should set at least it's
 * type and subtype and fill the buffer with your data.
 * 
 * A #LinphoneContent can be multipart (contain other contents), have file information (name, path, size), 
 * be encrypted, have custom headers, etc...
 * 
 * It is mainly used to send information through a #LinphoneChatMessage. 
 * @ingroup misc
 */
typedef struct _LinphoneContent LinphoneContent;

/**
 * @brief Represents a dial plan
 * @ingroup misc
 */
typedef struct _LinphoneDialPlan LinphoneDialPlan;

// -----------------------------------------------------------------------------
// Search.
// -----------------------------------------------------------------------------

/**
 * @brief A #LinphoneMagicSearch is used to do specifics searchs
 * @ingroup misc
 */
typedef struct _LinphoneMagicSearch LinphoneMagicSearch;

/**
 * @brief The LinphoneSearchResult object represents a result of a search
 * @ingroup misc
 */
typedef struct _LinphoneSearchResult LinphoneSearchResult;

#ifdef __cplusplus
	}
#endif // ifdef __cplusplus

#endif // ifndef _L_C_TYPES_H_