//
// Created by Patrick Maschek on 19.01.2024.
//

#ifndef UDIFF_CONST_LIST_H_
#define UDIFF_CONST_LIST_H_

#include <concepts>
#include <functional>
#include <initializer_list>
#include <iterator>

namespace cc {
	
	template<typename D>
	class const_list_node;
	
	template<typename N>
	class _const_list_iterator_base {
		protected:
			N *_curr = nullptr;

		public:
			constexpr _const_list_iterator_base() noexcept = default;
			constexpr explicit _const_list_iterator_base(N *curr) noexcept : _curr(curr) {}
            constexpr _const_list_iterator_base(const _const_list_iterator_base& other) noexcept : _curr(other._curr) {}

			constexpr virtual const N& operator*() const { return *_curr; }
			constexpr virtual const N* operator->() const noexcept { return _curr; }

			constexpr virtual _const_list_iterator_base &operator++() noexcept = 0;
			constexpr virtual _const_list_iterator_base &operator--() noexcept = 0;
			constexpr virtual _const_list_iterator_base &operator++(int) & noexcept = 0;
			constexpr virtual _const_list_iterator_base &operator--(int) & noexcept = 0;

			constexpr bool operator==(const _const_list_iterator_base &other) { return _curr == other._curr; }
	};

	template<typename N>
	class _const_list_iterator : public _const_list_iterator_base<N> {
			using _Base = _const_list_iterator_base<N>;
		public:
			constexpr _const_list_iterator() noexcept : _Base() {}
			constexpr explicit _const_list_iterator(N *curr) noexcept : _Base(curr) {}
            constexpr _const_list_iterator(const _Base& other) noexcept : _Base(other) {}

			constexpr N& operator*() const override { return *_Base::_curr; }
			constexpr N* operator->() const override { return _Base::_curr; }

			constexpr _const_list_iterator &operator++() noexcept override { _Base::_curr == _Base::_curr->_next; return *this; }
			constexpr _const_list_iterator &operator--() noexcept override { _Base::_curr == _Base::_curr->_prev; return *this; }
			constexpr _const_list_iterator operator++(int) & noexcept override { auto tmp = *this; _Base::_curr == _Base::_curr->_next; return tmp; }
			constexpr _const_list_iterator operator--(int) & noexcept override { auto tmp = *this; _Base::_curr == _Base::_curr->_prev; return tmp; }
	};

	template<typename N>
	class _const_const_list_iterator : public _const_list_iterator_base<N> {
			using _Base = _const_list_iterator_base<N>;
		public:
			constexpr _const_const_list_iterator() : _Base() {}
			constexpr explicit _const_const_list_iterator(N *curr) : _Base(curr) {}
            constexpr _const_const_list_iterator(const _Base& other) noexcept : _Base(other) {}

			constexpr _const_const_list_iterator &operator++() noexcept override { _Base::_curr == _Base::_curr->_next; return *this; }
			constexpr _const_const_list_iterator &operator--() noexcept override { _Base::_curr == _Base::_curr->_prev; return *this; }
			constexpr _const_const_list_iterator operator++(int) & noexcept override { auto tmp = *this; _Base::_curr == _Base::_curr->_next; return tmp; }
			constexpr _const_const_list_iterator operator--(int) & noexcept override { auto tmp = *this; _Base::_curr == _Base::_curr->_prev; return tmp; }
	};
	
	template<typename Node>
	class const_list {
		private:
			static consteval void asserts() {
				static_assert(std::is_base_of_v<const_list_node<Node>, Node>, "Can only create const_list with elements derived from const_list_node");
			}

		public:
			
			using value_type = Node;
			using size_type = std::size_t;
			using difference_type = std::ptrdiff_t;
			using reference = value_type&;
			using const_reference = const value_type&;
			using pointer = value_type *;
			using const_pointer = const value_type *;
			using iterator = _const_list_iterator<Node>;
			using const_iterator = _const_const_list_iterator<Node>;
			using reverse_iterator = std::reverse_iterator<iterator>;
			using const_reverse_iterator = std::reverse_iterator<const_iterator>;
			
		private:
			Node *_start = nullptr;
            Node *_end = nullptr;
            std::size_t _size = 0;

		public:

            constexpr const_list() noexcept { asserts(); };
            constexpr const_list(const const_list&) = delete;
            constexpr const_list(const_list&& other) noexcept;
            constexpr const_list(std::initializer_list<std::reference_wrapper<value_type>> init) noexcept;

			constexpr ~const_list();

            constexpr const_list& operator=(const const_list&) = delete;
            constexpr const_list& operator=(const_list&& other) noexcept;
            constexpr const_list& operator=(std::initializer_list<std::reference_wrapper<value_type>> init) noexcept;

            constexpr void assign(size_type count, const value_type& value) noexcept;
            template<std::input_iterator InputIt>
            constexpr void assign(InputIt first, InputIt last);
            constexpr void assign(std::initializer_list<value_type> values);

            [[nodiscard]] constexpr reference front() noexcept{ return *_start; }
            [[nodiscard]] constexpr const_reference front() const noexcept { return *_start; }

            [[nodiscard]] constexpr reference back() noexcept { return _end; }
            [[nodiscard]] constexpr const_reference back() const noexcept { return _end; }

            [[nodiscard]] constexpr iterator begin() noexcept { return iterator(_start); };
            [[nodiscard]] constexpr const_iterator begin() const noexcept { return const_iterator(_start); };
            [[nodiscard]] constexpr const_iterator cbegin() const noexcept { return const_iterator(_start); };

            [[nodiscard]] constexpr iterator end() noexcept { return iterator(); };
            [[nodiscard]] constexpr const_iterator end() const noexcept { return const_iterator(); };
            [[nodiscard]] constexpr const_iterator cend() const noexcept { return const_iterator(); };

            [[nodiscard]] constexpr reverse_iterator rbegin() noexcept { return std::reverse_iterator<iterator>(end()); };
            [[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept { return std::reverse_iterator<const_iterator>(end()); };
            [[nodiscard]] constexpr const_reverse_iterator crbegin() const noexcept { return std::reverse_iterator<const_iterator>(end()); };

            [[nodiscard]] constexpr reverse_iterator rend() noexcept { return std::reverse_iterator<iterator>(begin()); };
            [[nodiscard]] constexpr const_reverse_iterator rend() const noexcept { return std::reverse_iterator<const_iterator>(begin()); };
            [[nodiscard]] constexpr const_reverse_iterator crend() const noexcept { return std::reverse_iterator<const_iterator>(begin()); };

            [[nodiscard]] constexpr bool empty() const noexcept { return _size == 0; }
            [[nodiscard]] constexpr size_type max_size() const noexcept { return SIZE_MAX; }

            void clear() noexcept;

            constexpr iterator insert(const_iterator pos, const value_type& value);
            constexpr iterator insert(const_iterator pos, value_type&& value);
            constexpr iterator insert(const_iterator pos, size_type count, const value_type& value);
            template<std::input_iterator InputIt>
            constexpr iterator insert(const_iterator pos, InputIt first, InputIt last);
            constexpr iterator insert(const_iterator pos, std::initializer_list<value_type> values);

            template<typename ...Args>
            constexpr iterator emplace(const_iterator pos, Args&&... args);

            constexpr iterator erase(const_iterator pos);
            constexpr iterator erase(const_iterator first, const_iterator last);

            constexpr void push_back(const value_type& value);
            constexpr void push_back(value_type&& value);

            template<typename ...Args>
            constexpr reference emplace_back(Args&&... args);

            constexpr void pop_back();

            constexpr void push_front(const value_type& value);
            constexpr void push_front(value_type&& value);

            template<typename ...Args>
            constexpr reference emplace_front(Args&&... args);

            constexpr void pop_front();

            constexpr void resize(size_type count);
            constexpr void resize(size_type count, const value_type& value);

            constexpr void swap(const_list& other) noexcept;

            constexpr void merge(const_list& other);
            constexpr void merge(const_list&& other);
            template<typename Compare>
            constexpr void merge(const_list& other, Compare comp);
            template<typename Compare>
            constexpr void merge(const_list&& other, Compare comp);

            constexpr void splice(const_iterator pos, const_list& other);
            constexpr void splice(const_iterator pos, const_list&& other);
            constexpr void splice(const_iterator pos, const_list& other, const_iterator it);
            constexpr void splice(const_iterator pos, const_list&& other, const_iterator it);
            constexpr void splice(const_iterator pos, const_list& other, const_iterator first, const_iterator last);
            constexpr void splice(const_iterator pos, const_list&& other, const_iterator first, const_iterator last);

            constexpr size_type remove(const value_type& value);
            template<typename UnaryPredicate>
            size_type remove_if(UnaryPredicate p);

            void reverse() noexcept;

            size_type unique();
            template<typename BinaryPredicate>
            constexpr size_type unique(BinaryPredicate p);

            constexpr void sort();
            template<typename Compare>
            void sort(Compare comp);

    };

	template<typename D>
	class const_list_node {
		private:
			static consteval void asserts() {
				static_assert(std::is_base_of_v<const_list_node<D>, D>, "Template parameter has to be a subclass of const_list_node<*self*>");
			}

		private:
			const_list_node *_prev = nullptr;
			const_list_node *_next = nullptr;
			const_list<D> *_owner = nullptr;
			
			void (*_delete_cb)() = nullptr;

		public:
			constexpr const_list_node() noexcept { asserts(); }
            virtual constexpr ~const_list_node();
			
			constexpr void on_delete(void (*cb)());
		
		private:
			void notify_delete();
			
			friend class const_list<D>;
			friend class _const_list_iterator_base<D>;
	};

    template<typename N1, typename N2>
    constexpr bool operator==(const const_list<N1>& lhs,
                              const const_list<N2>& rhs)
    {
		return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
    }

    template<typename N1, typename N2>
    constexpr auto operator<=>(const const_list<N1>& lhs,
                               const const_list<N2>& rhs)
    {
		return std::lexicographical_compare_three_way(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
    }

    template<typename N>
    constexpr void swap(const const_list<N>& lhs,
                        const const_list<N>& rhs)
    {
		lhs.swap(rhs);
    }

    template<typename N>
    constexpr const_list<N>::size_type erase(const_list<N>& c, const N& value)
    {
		c.remove(value);
    }

    template<typename N, typename Pred>
    constexpr const_list<N>::size_type erase(const_list<N>& c, Pred pred)
    {
		c.remove_if(pred);
    }

    template<typename Node>
    constexpr const_list<Node>::const_list(const_list &&other) noexcept
		:   _start(other._start), _end(other._end), _size(other._size)
	{
		asserts();

		for (auto node : other) {
			node._owner = this;
		}

		other._size = 0;
		other._start = nullptr;
		other._end = nullptr;
    }

    template<typename Node>
	constexpr const_list<Node>::const_list(std::initializer_list<std::reference_wrapper<value_type>> init) noexcept
		:   _start(std::addressof(init.begin()->get())),
		    _end(std::addressof(std::prev(init.end())->get())),
		    _size(init.size())
	{
		asserts();

		auto prev = init.begin();
		prev->get()._owner = this;

		for (auto it = std::next(init.begin()); it != init.end(); ++it) {
			prev->get()._next = std::addressof(it->get());
			it->get()._prev = std::addressof(prev->get());
			it->get()._owner = this;

			prev = it;
		}
    }

    template<typename Node>
    constexpr const_list<Node>::~const_list()
	{
		clear();
    }

	template<typename Node>
	constexpr const_list<Node> &const_list<Node>::operator=(const_list &&other) noexcept
    {
	    for (auto node : other) {
		    node._owner = this;
	    }

	    other._size = 0;
	    other._start = nullptr;
	    other._end = nullptr;

		return *this;
	}

	template<typename Node>
	constexpr const_list<Node> &const_list<Node>::operator=(std::initializer_list<std::reference_wrapper<value_type>> init) noexcept
	{
		*this = const_list(init);
		return *this;
	}


	template<typename D>
    constexpr const_list_node<D>::~const_list_node()
	{
		if (_delete_cb) 
			(*_delete_cb)();
        _owner->remove(*this);
    }

	template<typename D>
	constexpr void const_list_node<D>::on_delete(void (*cb)())
	{
		_delete_cb = cb;
	}

	template<typename D>
	void const_list_node<D>::notify_delete()
	{
		if (_delete_cb)
			(*_delete_cb)();
	}

} // cc

#endif //UDIFF_CONST_LIST_H_