/*
 * Copyright (c) 2010-2022 Belledonne Communications SARL.
 *
 * This file is part of Liblinphone
 * (see https://gitlab.linphone.org/BC/public/liblinphone).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef _L_GENERAL_H_
#define _L_GENERAL_H_

#ifdef __cplusplus
#include <memory>
#include <type_traits>
#endif

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

// -----------------------------------------------------------------------------
// Namespace.
// -----------------------------------------------------------------------------

#ifdef __cplusplus
#define LINPHONE_BEGIN_NAMESPACE namespace LinphonePrivate {
#define LINPHONE_END_NAMESPACE }
#else
#define LINPHONE_BEGIN_NAMESPACE
#define LINPHONE_END_NAMESPACE
#endif

// -----------------------------------------------------------------------------

LINPHONE_BEGIN_NAMESPACE

// -----------------------------------------------------------------------------
// Export.
// -----------------------------------------------------------------------------

#ifndef LINPHONE_PUBLIC
#if defined(_MSC_VER)
#ifdef LINPHONE_STATIC
#define LINPHONE_PUBLIC
#else
#ifdef LINPHONE_EXPORTS
#define LINPHONE_PUBLIC __declspec(dllexport)
#else
#define LINPHONE_PUBLIC __declspec(dllimport)
#endif
#endif
#else
#define LINPHONE_PUBLIC
#endif
#endif

#ifndef LINPHONE_DEPRECATED
#if defined(_MSC_VER)
#define LINPHONE_DEPRECATED __declspec(deprecated)
#else
#define LINPHONE_DEPRECATED __attribute__((deprecated))
#endif
#endif

// -----------------------------------------------------------------------------

#ifdef __cplusplus

// -----------------------------------------------------------------------------
// Debug.
// -----------------------------------------------------------------------------

LINPHONE_PUBLIC void lAssert(const char *condition, const char *file, int line);

#ifdef DEBUG
#define L_ASSERT(CONDITION)                                                                                            \
	((CONDITION) ? static_cast<void>(0) : LinphonePrivate::lAssert(#CONDITION, __FILE__, __LINE__))
#else
#define L_ASSERT(CONDITION) static_cast<void>(false && (CONDITION))
#endif

// -----------------------------------------------------------------------------
// Optimization.
// -----------------------------------------------------------------------------

#ifndef _MSC_VER
#define L_LIKELY(EXPRESSION) __builtin_expect(static_cast<bool>(EXPRESSION), true)
#define L_UNLIKELY(EXPRESSION) __builtin_expect(static_cast<bool>(EXPRESSION), false)
#else
#define L_LIKELY(EXPRESSION) EXPRESSION
#define L_UNLIKELY(EXPRESSION) EXPRESSION
#endif

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

// Define an integer version like: 0xXXYYZZ, XX=MAJOR, YY=MINOR, and ZZ=PATCH.
constexpr unsigned int makeVersion(unsigned int major, unsigned int minor, unsigned int patch) {
	return ((major << 16) | (minor << 8) | patch);
}

// Not available in C++11...
template <typename T, typename... Args>
std::unique_ptr<T> makeUnique(Args &&...args) {
	return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

#define L_AUTO_RETURN(VALUE)                                                                                           \
	->decltype(VALUE) {                                                                                                \
		return VALUE;                                                                                                  \
	}

// -----------------------------------------------------------------------------
// Class tools.
// -----------------------------------------------------------------------------

#define L_DISABLE_COPY(CLASS)                                                                                          \
	CLASS(const CLASS &) = delete;                                                                                     \
	CLASS &operator=(const CLASS &) = delete;

// -----------------------------------------------------------------------------
// PImpl tools.
// -----------------------------------------------------------------------------

class BaseObject;
class BaseObjectPrivate;
class ClonableObject;
class ClonableObjectPrivate;
class Object;
class ObjectPrivate;

namespace Private {
template <typename T>
using BetterPrivateAncestor = typename std::conditional<
    std::is_base_of<BaseObject, T>::value,
    BaseObject,
    typename std::conditional<std::is_base_of<ClonableObject, T>::value, ClonableObject, T>::type>::type;

// Generic public helper.
template <typename R, typename P, typename C>
constexpr R *getPublicHelper(P *object, const C *) {
	return static_cast<R *>(object);
}

// Generic public helper. Deal with shared data.
template <typename R, typename P, typename C>
inline R *getPublicHelper(const P &objectSet, const C *) {
	auto it = objectSet.cbegin();
	L_ASSERT(it != objectSet.cend());
	return static_cast<R *>(*it);
}

template <typename T, typename U>
struct AddConstMirror {
	typedef U type;
};

template <typename T, typename U>
struct AddConstMirror<const T, U> {
	typedef typename std::add_const<U>::type type;
};
} // namespace Private

#define L_INTERNAL_CHECK_OBJECT_INHERITANCE(CLASS)                                                                     \
	static_assert(!(std::is_base_of<BaseObject, CLASS>::value && std::is_base_of<ClonableObject, CLASS>::value),       \
	              "Multiple inheritance between BaseObject and ClonableObject is not allowed.");

#define L_INTERNAL_DECLARE_PRIVATE(CLASS)                                                                              \
	inline CLASS##Private *getPrivate() {                                                                              \
		L_INTERNAL_CHECK_OBJECT_INHERITANCE(CLASS);                                                                    \
		using TypeAncestor = LinphonePrivate::Private::BetterPrivateAncestor<CLASS>;                                   \
		return reinterpret_cast<CLASS##Private *>(TypeAncestor::mPrivate);                                             \
	}                                                                                                                  \
	inline const CLASS##Private *getPrivate() const {                                                                  \
		L_INTERNAL_CHECK_OBJECT_INHERITANCE(CLASS);                                                                    \
		using TypeAncestor = LinphonePrivate::Private::BetterPrivateAncestor<CLASS>;                                   \
		return reinterpret_cast<const CLASS##Private *>(TypeAncestor::mPrivate);                                       \
	}                                                                                                                  \
	friend class CLASS##Private;                                                                                       \
	friend class Wrapper;

// Allows access to private internal data.
// Gives a control to C Wrapper.
#ifndef LINPHONE_TESTER
#define L_DECLARE_PRIVATE(CLASS) L_INTERNAL_DECLARE_PRIVATE(CLASS)
#else
#define L_DECLARE_PRIVATE(CLASS)                                                                                       \
	L_INTERNAL_DECLARE_PRIVATE(CLASS)                                                                                  \
	friend class Tester;
#endif

#define L_DECLARE_PUBLIC(CLASS)                                                                                        \
	CLASS *getPublic() {                                                                                               \
		return LinphonePrivate::Private::getPublicHelper<CLASS>(mPublic, this);                                        \
	}                                                                                                                  \
	const CLASS *getPublic() const {                                                                                   \
		return LinphonePrivate::Private::getPublicHelper<const CLASS>(mPublic, this);                                  \
	}                                                                                                                  \
	friend class CLASS;

// Get Private data.
#define L_D() decltype(getPrivate()) const d = getPrivate();

// Get Public data.
#define L_Q() decltype(getPublic()) const q = getPublic();

// Get Private data of class in a multiple inheritance case.
#define L_D_T(CLASS, NAME)                                                                                             \
	auto const NAME =                                                                                                  \
	    static_cast<LinphonePrivate::Private::AddConstMirror<std::remove_reference<decltype(*this)>::type,             \
	                                                         CLASS##Private>::type *>(CLASS::mPrivate);

// Get Public data of class in a multiple inheritance case.
#define L_Q_T(CLASS, NAME)                                                                                             \
	auto const NAME = static_cast<                                                                                     \
	    LinphonePrivate::Private::AddConstMirror<std::remove_reference<decltype(*this)>::type, CLASS>::type *>(        \
	    getPublic());
// -----------------------------------------------------------------------------
// Macro.
// -----------------------------------------------------------------------------

#define EPHEMERAL_MESSAGE_TASKS_MAX_NB 10

// -----------------------------------------------------------------------------
// Overload.
// -----------------------------------------------------------------------------

#define L_OVERRIDE_SHARED_FROM_THIS(CLASS)                                                                             \
	inline std::shared_ptr<CLASS> getSharedFromThis() {                                                                \
		return std::static_pointer_cast<CLASS>(Object::getSharedFromThis());                                           \
	}                                                                                                                  \
	inline std::shared_ptr<const CLASS> getSharedFromThis() const {                                                    \
		return std::static_pointer_cast<const CLASS>(Object::getSharedFromThis());                                     \
	}

namespace Private {
template <typename... Args>
struct ResolveMemberFunctionOverload {
	template <typename Ret, typename Obj>
	constexpr auto operator()(Ret (Obj::*func)(Args...)) const L_AUTO_RETURN(func);
};

template <typename... Args>
struct ResolveConstMemberFunctionOverload {
	template <typename Ret, typename Obj>
	constexpr auto operator()(Ret (Obj::*func)(Args...) const) const L_AUTO_RETURN(func);
};

template <typename... Args>
struct ResolveOverload : ResolveMemberFunctionOverload<Args...>, ResolveConstMemberFunctionOverload<Args...> {
	using ResolveMemberFunctionOverload<Args...>::operator();
	using ResolveConstMemberFunctionOverload<Args...>::operator();

	template <typename Ret>
	constexpr auto operator()(Ret (*func)(Args...)) const L_AUTO_RETURN(func);
};
} // namespace Private

// Useful to select a specific overloaded function. (Avoid usage of static_cast.)
template <typename... Args>
using resolveOverload = Private::ResolveOverload<Args...>;

// -----------------------------------------------------------------------------
// Math.
// -----------------------------------------------------------------------------

// Returns the number of digits of the absolute value of the input number
// If the number is negative, add one to the length to account for - sign
constexpr int getIntLength(int n) {
	return n < 0 ? 1 + getIntLength(-n) : (n < 10 ? 1 : 1 + getIntLength(n / 10));
}

namespace Private {
constexpr int pow10Impl(int n, int acc) {
	return n == 0 ? acc : pow10Impl(n - 1, acc * 10);
}
} // namespace Private

template <typename T>
constexpr T abs(const T &value) {
	return value < 0 ? -value : value;
}

constexpr int pow10(int n) {
	return (n < 0 ? -1 : +1) * Private::pow10Impl(abs(n), 1);
}

// Returns the sum of n elements.
constexpr int sums() {
	return 0;
}

template <typename T, typename... Args>
constexpr int sums(T i, Args... args) {
	return i + sums(args...);
}

// -----------------------------------------------------------------------------
// Wrapper public.
// -----------------------------------------------------------------------------

#define L_DECL_C_STRUCT(STRUCT) typedef struct _##STRUCT STRUCT;
#define L_DECL_C_STRUCT_PREFIX_LESS(STRUCT) typedef struct STRUCT STRUCT;

#endif // ifdef __cplusplus

LINPHONE_END_NAMESPACE

#endif // ifndef _L_GENERAL_H_
