/*
 * Copyright (c) 2001-2020 Mellanox Technologies, Ltd. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef VMA_LIST_H
#define VMA_LIST_H

#include "vma/util/list.h"
#include "vlogger/vlogger.h"

#define VLIST_DEBUG        0
#define VLIST_ID_SIZE    200

#define vlist_logwarn(log_fmt, log_args...)     vlog_printf(VLOG_WARNING, "vlist[%p]:%d:%s() " log_fmt "\n", this, __LINE__, __FUNCTION__, ##log_args)
#define vlist_logerr(log_fmt, log_args...)      vlog_printf(VLOG_ERROR,   "vlist[%p]:%d:%s() " log_fmt "\n", this, __LINE__, __FUNCTION__, ##log_args)

#if VLIST_DEBUG
template <class T, size_t offset(void)>
class vma_list_t;
#define VLIST_DEBUG_PRINT_ERROR_IS_MEMBER          vlist_logerr("Buff is already a member in a list! parent.id=[%s], this.id=[%s]", node_obj->list_id(), this->list_id())
#define VLIST_DEBUG_SET_PARENT(node_obj, val)      node_obj->parent = val
#else
#define VLIST_DEBUG_PRINT_ERROR_IS_MEMBER          vlist_logerr("Buff is already a member in a list!")
#define VLIST_DEBUG_SET_PARENT(node_obj, val)
#endif

#define NODE_OFFSET(_obj_type, _node_name) \
		((size_t)(&(char &)(((_obj_type *) 1)->_node_name)) - 1)
#define GET_NODE(_obj, _obj_type, _offset_func) \
		((list_node<_obj_type, _offset_func> *) ((size_t)(_obj) + (size_t)(_offset_func())))

template <class T, size_t offset(void)>
class list_node {
public :

	/* head must be the first field! */
	struct list_head head;
	T *obj_ptr;

#if VLIST_DEBUG
	vma_list_t<T, offset> * parent;

	char* list_id() {
		return this->parent->list_id();
	}

#endif

	list_node() : obj_ptr(NULL) {
		this->head.next = &this->head;
		this->head.prev = &this->head;
		VLIST_DEBUG_SET_PARENT(this, NULL);
	}

	/* is_list_member - check if the node is already a member in a list. */
	bool is_list_member() {
		return this->head.next != &this->head || this->head.prev != &this->head;
	}
};

template<typename T, size_t offset(void)>
class list_iterator_t : public std::iterator<std::random_access_iterator_tag, T, std::ptrdiff_t, T*, T&>
{
public:

	list_iterator_t(T* ptr = NULL) : m_ptr(ptr) {}

	list_iterator_t(const list_iterator_t<T, offset>& iter) : m_ptr(iter.m_ptr) {}

	~list_iterator_t() {}

	list_iterator_t<T, offset>& operator=(T* ptr) {
		m_ptr = ptr;
		return (*this);
	}

	list_iterator_t<T, offset>& operator=(const list_iterator_t<T, offset>& iter) {
		m_ptr = iter.m_ptr;
		return (*this);
	}

	operator bool() const {
		return m_ptr ? true : false;
	}

	bool operator==(const list_iterator_t<T, offset>& iter) const {
		return m_ptr == iter.getConstPtr();
	}

	bool operator!=(const list_iterator_t<T, offset>& iter) const {
		return m_ptr != iter.getConstPtr();
	}

	list_iterator_t<T, offset> operator++(int) {
		list_iterator_t<T, offset> iter(*this);
		increment_ptr();
		return iter;
	}

	list_iterator_t<T, offset>& operator++() {
		increment_ptr();
		return *this;
	}

	list_iterator_t<T, offset> operator--(int) {
		list_iterator_t<T, offset> iter(*this);
		decrement_ptr();
		return iter;
	}

	list_iterator_t<T, offset>& operator--() {
		decrement_ptr();
		return *this;
	}

	T* operator*() {
		return m_ptr;
	}

	const T* operator*() const {
		return m_ptr;
	}

	T* operator->() {
		return m_ptr;
	}

	T* getPtr() const {
		return m_ptr;
	}

	const T* getConstPtr() const {
		return m_ptr;
	}

private:

	T*	m_ptr;

	inline void increment_ptr() {
		m_ptr = ((list_node<T, offset> *)GET_NODE(m_ptr, T, offset)->head.next)->obj_ptr;
	}

	inline void decrement_ptr() {
		m_ptr = ((list_node<T, offset> *)GET_NODE(m_ptr, T, offset)->head.prev)->obj_ptr;
	}

};

template <class T, size_t offset(void)>
class  vma_list_t
{
public:
	typedef list_iterator_t<T, offset> iterator;
	vma_list_t() {
		init_list();
	}

	void set_id(const char *format, ...) {
		if (format) {
	#if VLIST_DEBUG
			va_list arg;
			va_start (arg, format);
			vsnprintf (id, sizeof(id) ,format, arg);
			va_end (arg);
	#endif
		}
	}

	~vma_list_t() {
		if (!empty()) {
			vlist_logwarn("Destructor is not supported for non-empty list! size=%zu", m_size);
		}
	}

	vma_list_t<T, offset> (const vma_list_t<T, offset>& other) {
		if (!other.empty())
			vlist_logwarn("Copy constructor is not supported for non-empty list! other.size=%zu", other.m_size);
		init_list();
	}

	vma_list_t<T, offset>& operator=(const vma_list_t<T, offset>& other) {
		if (!empty() || !other.empty())
			vlist_logwarn("Operator= is not supported for non-empty list! size=%zu, other.size=%zu", m_size, other.m_size);
		if (this != &other) {
			init_list();
		}
		return *this;
	}

	T* operator[](size_t idx) const {
		return get(idx);
	}

	inline bool empty() const {
		return m_size == 0;
	}

	inline size_t size() const {
		return m_size;
	}

	inline T* front() const {
		if (unlikely(empty()))
			return NULL;
		return ((list_node<T, offset> *)m_list.head.next)->obj_ptr;
	}

	inline T* back() const {
		if (unlikely(empty()))
			return NULL;
/* clang analyzer reports:
 * Use of memory after it is freed
 * This issue comes from ~chunk_list_t() 
 * Root cause is unknown.
 * TODO: Fix based on root cause instead of supressing
 */
#ifndef __clang_analyzer__
                return ((list_node<T, offset> *)m_list.head.prev)->obj_ptr;
#endif
	}

	inline void pop_front() {
		erase(front());
	}

	inline void pop_back() {
		erase(back());
	}

	inline T* get_and_pop_front() {
		T* list_front = front();
		pop_front();
		return list_front;
	}

	inline T* get_and_pop_back() {
		T* list_back = back();
		pop_back();
		return list_back;
	}

	void erase(T* obj) {
		if (unlikely(!obj)) {
			vlist_logwarn("Got NULL object - ignoring");
			return;
		}

		list_node<T, offset> *node_obj = GET_NODE(obj, T, offset);
		VLIST_DEBUG_SET_PARENT(node_obj, NULL);
		list_del_init(&node_obj->head);
		m_size--;
	}

	/**
	 * Clear content
	 * Removes all elements from the list container (which are NOT destroyed), and leaving the container with a size of 0.
	 *
	 * NOTE: we don't expect calling this method in normal situations (it is workaround at application shutdown); Hence, there is no cleanup of node.parent
	 */
	void clear_without_cleanup() {
		init_list();
	}

	void push_back(T* obj) {
		if (unlikely(!obj)) {
			vlist_logwarn("Got NULL object - ignoring");
			return;
		}

		list_node<T, offset> *node_obj = GET_NODE(obj, T, offset);
		if (unlikely(node_obj->is_list_member())) {
			VLIST_DEBUG_PRINT_ERROR_IS_MEMBER;
		}

		VLIST_DEBUG_SET_PARENT(node_obj, this);
		node_obj->obj_ptr = obj;
		list_add_tail(&node_obj->head, &m_list.head);
		m_size++;
	}

	void push_front(T* obj) {
		if (unlikely(!obj)) {
			vlist_logwarn("Got NULL object - ignoring");
			return;
		}

		list_node<T, offset> *node_obj = GET_NODE(obj, T, offset);
		if (unlikely(node_obj->is_list_member())) {
			VLIST_DEBUG_PRINT_ERROR_IS_MEMBER;
		}

		VLIST_DEBUG_SET_PARENT(node_obj, this);
		node_obj->obj_ptr = obj;
		list_add(&node_obj->head, &m_list.head);
		m_size++;
	}

	T* get(size_t index) const {
		if (m_size <= index) {
			return NULL;
		} else {
			list_head* ans = m_list.head.next;
			for (size_t i = 0 ; i < index ; i++) {
				ans = ans->next;
			}
			return ((list_node<T, offset> *)ans)->obj_ptr;
		}
	}

	// concatenate 'from' at the head of this list
	void splice_head(vma_list_t<T, offset>& from) {

		this->m_size += from.m_size;
		list_splice(&from.m_list.head, &this->m_list.head);
		from.init_list();
		// TODO: in case VLIST_DEBUG, this invalidates parent list of all nodes in the list
	}

	// concatenate 'from' at the tail of this list
	void splice_tail(vma_list_t<T, offset>& from) {
		this->m_size += from.m_size;
		list_splice_tail(&from.m_list.head, &this->m_list.head);
		from.init_list();
		// TODO: in case VLIST_DEBUG, this invalidates parent list of all nodes in the list
	}

	/**
	 * Swap content
	 * Exchanges the content of the container by the content of x, which is another list of the same type. Sizes may differ.
	 *
	 * After the call to this member function, the elements in this container are those which were in x before the call, and
	 * the elements of x are those which were in this. All iterators, references and pointers remain valid for the swapped objects.
	 */
	void swap (vma_list_t<T, offset>& x) {
		vma_list_t<T, offset> temp_list;
		this->move_to_empty(temp_list);
		x.move_to_empty(*this);
		temp_list.move_to_empty(x);
	}

	list_iterator_t<T, offset> begin() {
		return list_iterator_t<T, offset>(front());
	}

	list_iterator_t<T,offset> end() {
		return list_iterator_t<T, offset>(NULL);
	}

#if VLIST_DEBUG
	char* list_id() {
		return (char*)&id;
	}
#endif

private:

	list_node<T, offset> m_list;
	size_t m_size;

#if VLIST_DEBUG
	char id[VLIST_ID_SIZE];
#endif

	void move_to_empty(vma_list_t<T, offset>& to) {
		assert(to.empty());
		to.m_size   = this->m_size;
		list_splice_tail(&this->m_list.head, &to.m_list.head);
		this->init_list();
		// TODO: in case VLIST_DEBUG, this invalidates parent list of all nodes in the list
	}

	void init_list() {
		m_size = 0;
		INIT_LIST_HEAD(&m_list.head);
	#if VLIST_DEBUG
		id[0] = '\0';
	#endif
	}
};

#endif /* VMA_LIST_H */