#ifndef BST_HPP
# define BST_HPP

# include <memory> // std::allocator
# include <cstddef> // NULL, size_t, ptrdiff_t
# include <algorithm> // max()
# include <functional> // std::less()

# include "reverse_iterator.hpp"
# include "equal.hpp"
# include "lexicographical_compare.hpp"

# include "pair.hpp"
# include "bst_node.hpp"
# include "bst_iterator.hpp"

namespace ft {

template <
	typename Key,
	typename T,
	typename Compare = std::less<Key>,
	typename Allocator = std::allocator< ft::pair<const Key, T> >
> class Bst
{
	public:
		typedef Key					key_type;
		typedef T					mapped_type;
		typedef pair<const Key, T>	value_type;
		typedef Compare				key_compare;
		typedef Allocator			allocator_type;
		typedef std::size_t			size_type;
		typedef std::ptrdiff_t		difference_type;

		typedef typename Allocator::pointer			pointer;
		typedef typename Allocator::const_pointer	const_pointer;
		typedef typename Allocator::reference		reference;
		typedef typename Allocator::const_reference	const_reference;


		typedef Bst_iterator<Key, T, Compare, Allocator>		iterator;
		typedef Bst_const_iterator<Key, T, Compare, Allocator>	const_iterator;
		typedef ft::reverse_iterator<iterator>					reverse_iterator;
		typedef ft::reverse_iterator<const_iterator>			const_reverse_iterator;


		// Member functions
		explicit Bst(const Compare& comp = Compare(), const Allocator& alloc = Allocator() );
		template < typename InputIt >
		    Bst(InputIt first, InputIt last, const Compare& comp = Compare(), const Allocator& alloc = Allocator());
		Bst(const Bst& src);
		~Bst();

		Bst&	operator=(const Bst& rhs);

		// Element access
		T&	operator[](const Key& key);

		// Iterators
		iterator				begin();
		const_iterator			begin() const;
		iterator				end();
		const_iterator			end() const;
		reverse_iterator		rbegin();
		const_reverse_iterator	rbegin() const;
		reverse_iterator		rend();
		const_reverse_iterator	rend() const;

		// Capacity
		bool		empty() const;
		size_type	size() const;
		size_type	max_size() const;

		// Modifiers
		void					clear();
		pair<iterator, bool>	insert(const value_type& value);
		iterator				insert(iterator hint, const value_type& value);
		template < typename InputIt >
		    void				insert(InputIt first, InputIt last);
		void					erase(iterator pos);
		void					erase(iterator first, iterator last);
		size_type				erase(const Key& key);
		void					swap(Bst& other);

		// Lookup
		iterator		find(const Key& key);
		const_iterator	find(const Key& key) const;
		size_type		count(const Key& key) const;

	private:
		size_type					_size;
		node<value_type>*			_root;
		node_sentinel<value_type>*	_sentinel;
		Compare						_comp;
		Allocator					_allocator;

		// TODO : rebind syntaxe pas clair.
		typename Allocator::template rebind< node<value_type> >::other _allocator_node; // Peu clair, verifier syntaxe
			typename Allocator::template rebind< node_sentinel<value_type> >::other _allocator_node_sentinel; // Peu clair, verifier syntaxe

		void					_init_sentinel();
		pair<iterator, bool>	_insert(const value_type& value);
		node<value_type>*		_erase(iterator pos);
		node<value_type>*		_subtree_shift(node<value_type>* st_old, node<value_type>* st_new);

		// AVL Balancing
		void				_insert_rebalancing(node<value_type>* n);
		void				_erase_rebalancing(node<value_type>* n);

		short				_compute_height(node<value_type>* n);
		short				_bf(node<value_type>* n); // balance factor
		node<value_type>*	_rotate_left(node<value_type>* n);
		node<value_type>*	_rotate_right(node<value_type>* n);
 };

	// Non-member functions
	template < typename Key, typename T, typename Compare, typename Alloc >
		bool    operator==(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
	template < typename Key, typename T, typename Compare, typename Alloc >
		bool    operator!=(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
	template < typename Key, typename T, typename Compare, typename Alloc >
		bool    operator<(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
	template < typename Key, typename T, typename Compare, typename Alloc >
		bool    operator>(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
	template < typename Key, typename T, typename Compare, typename Alloc >
		bool    operator<=(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
	template < typename Key, typename T, typename Compare, typename Alloc >
		bool    operator>=(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);

	template < typename Key, typename T, typename Compare, typename Alloc >
		void    swap(Bst<Key,T,Compare,Alloc>& lhs, Bst<Key,T,Compare,Alloc>& rhs);

} // namespace ft

# include "bst.tpp"

// https://en.wikipedia.org/wiki/Binary_search_tree
// https://en.wikipedia.org/wiki/AVL_tree

// https://fr.wikipedia.org/wiki/Arbre_binaire_de_recherche
// https://fr.wikipedia.org/wiki/Arbre_AVL

// https://visualgo.net/en/bst
// https://visualgo.net/en/bst?slide=14-8 // --> to 14-13


#endif